import type { Browser } from 'puppeteer';
import { CheerioAPI } from 'cheerio';
import { Element as Element_2 } from 'cheerio';
import { ElementHandle } from 'puppeteer';
import type { HTTPRequest } from 'puppeteer';
import type { HTTPResponse } from 'puppeteer';
import { Page } from 'puppeteer';
import type { PuppeteerLifeCycleEvent } from 'puppeteer';
import type { Viewport } from 'puppeteer';

export declare type ActionConfig = {
    name: string;
    arguments?: string[];
};

export declare const actionDefinitions: ({
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {
            plan: {
                type: string;
                description: string;
            };
        };
    };
    required: string[];
} | {
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {
            filename: {
                type: string;
                description: string;
            };
        };
    };
    required: string[];
} | {
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {
            url: {
                type: string;
                description: string;
            };
        };
    };
    required: string[];
} | {
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {
            form_data: {
                type: string;
                items: {
                    type: string;
                    properties: {
                        pp_id: {
                            type: string;
                            description: string;
                        };
                        label: {
                            type: string;
                            description: string;
                        };
                        name: {
                            type: string;
                            description: string;
                        };
                        text: {
                            type: string;
                            description: string;
                        };
                        select: {
                            type: string;
                            description: string;
                            items: {
                                type: string;
                                description: string;
                            };
                        };
                        index: {
                            type: string;
                            description: string;
                        };
                        check: {
                            type: string;
                            description: string;
                        };
                    };
                };
            };
            submit: {
                type: string;
                description: string;
            };
        };
    };
    required: string[];
} | {
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {
            parentType: {
                type: string;
                description: string;
            };
            parentId: {
                type: string;
                description: string;
            };
            type: {
                type: string;
                description: string;
            };
            id: {
                type: string;
                description: string;
            };
            selector: {
                type: string;
                description: string;
            };
            content: {
                type: string;
                description: string;
            };
        };
    };
} | {
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {
            summary: {
                type: string;
                description: string;
            };
            answer: {
                type: string;
                description: string;
            };
        };
    };
    required: string[];
} | {
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {
            query: {
                type: string;
                description: string;
            };
            searchEngine: {
                type: string;
                description: string;
            };
        };
    };
    required: string[];
} | {
    name: string;
    description: string;
    parameters: {
        type: string;
        properties: {};
    };
    required: never[];
})[];

export declare class ActionDefinitionsRegistry {
    definitions: any[];
    setDefinitions(definitions: any[]): void;
    addDefinition(definition: any, overwrite?: boolean): void;
    addDefinitions(definitions: any[], overwrite?: boolean): void;
    defaultDefinitions(): ({
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                plan: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    } | {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                filename: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    } | {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                url: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    } | {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                form_data: {
                    type: string;
                    items: {
                        type: string;
                        properties: {
                            pp_id: {
                                type: string;
                                description: string;
                            };
                            label: {
                                type: string;
                                description: string;
                            };
                            name: {
                                type: string;
                                description: string;
                            };
                            text: {
                                type: string;
                                description: string;
                            };
                            select: {
                                type: string;
                                description: string;
                                items: {
                                    type: string;
                                    description: string;
                                };
                            };
                            index: {
                                type: string;
                                description: string;
                            };
                            check: {
                                type: string;
                                description: string;
                            };
                        };
                    };
                };
                submit: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    } | {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                parentType: {
                    type: string;
                    description: string;
                };
                parentId: {
                    type: string;
                    description: string;
                };
                type: {
                    type: string;
                    description: string;
                };
                id: {
                    type: string;
                    description: string;
                };
                selector: {
                    type: string;
                    description: string;
                };
                content: {
                    type: string;
                    description: string;
                };
            };
        };
    } | {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                summary: {
                    type: string;
                    description: string;
                };
                answer: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    } | {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                query: {
                    type: string;
                    description: string;
                };
                searchEngine: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    } | {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {};
        };
        required: never[];
    })[];
}

export declare class ActionsRegistry {
    driver: IAgentDriver;
    actions: TActionStore;
    constructor(driver: IAgentDriver);
    registerAction(action: IDriverAction, id?: string): void;
    removeAction(id: string): void;
    protected addDefinition(definition: string): void;
}

export declare class AgentBrowser implements IAgentBrowser {
    page?: Page;
    launched: boolean;
    loaded: boolean;
    debug: boolean;
    headless: boolean;
    downloadStarted: boolean;
    responses: number;
    requests: number;
    view: ViewportOpts;
    browser?: Browser;
    driver: IAgentDriver;
    constructor(driver: IAgentDriver, opts?: BrowserOpts);
    launch(): Promise<void>;
    getNewPage(): Promise<Page | undefined>;
    createPuppeteerBrowser(): Promise<Browser>;
    start(): Promise<Page>;
    close(): void;
    protected get defaultViewport(): {
        width: number;
        height: number;
        deviceScaleFactor: number;
    };
    get viewport(): Viewport;
    protected print(...msgs: any[]): void;
    protected isBlock(_request: HTTPRequest): boolean;
    protected onRequestBlock(request: HTTPRequest): void;
    protected incRequestCount(): void;
    protected startDownload(): void;
    protected isLargeResponse(response: HTTPResponse): boolean;
    protected isBinary(headers: PageHeaders): boolean;
    protected hasAttachment(headers: PageHeaders): boolean;
    protected hasLargeContent(headers: PageHeaders): boolean;
    protected get maxMbs(): number;
    protected incResponseCount(): void;
    protected sleep(ms: number, debug?: boolean): Promise<unknown>;
}

export declare class AgentDriver implements IAgentDriver {
    browser: AgentBrowser;
    page?: Page;
    message?: string;
    autopilot: boolean;
    contextLengthLimit: number;
    model: string;
    messageToController?: any;
    debug: boolean;
    agentState?: IAgentState;
    nextStep: any;
    context?: any[];
    elementSelector: IElementSelector;
    messageBuilder: IMessageBuilder;
    inputController: IInputController;
    messageBroker: IMessageBroker;
    stepRunner: IStepRunner;
    costCalculator: ITokenCostCalculator;
    actionsRegistry: IActionsRegistry;
    actionDefinitionsRegistry: IActionDefinitionsRegistry;
    opts: DriverOpts;
    constructor(opts?: DriverOpts);
    get element(): ElementHandle<Element> | undefined;
    setInteractiveElements(elements: ElementHandle<Element>[]): void;
    get interactiveElements(): ElementHandle<Element>[];
    setNoContent(val: boolean): void;
    get noContent(): boolean;
    get definitions(): any[];
    get actions(): TActionStore;
    setDefinitions(definitions: any[]): void;
    addDefinitions(definitions: any[]): void;
    addDefinition(definition: any): void;
    start(): Promise<void>;
    run(agentState: IAgentState): Promise<void>;
    doStep(): Promise<void>;
    closeBrowser(): void;
    log(msg: any): void;
    markerClass(id: number): string;
    protected prepareStep(agentState: IAgentState): void;
    protected onStepDone(): void;
    protected initialize(): Promise<void>;
    protected setState(agentState: IAgentState): void;
    get response(): HTTPResponse | undefined;
    protected createActionDefinitionsRegistry(): ActionDefinitionsRegistry;
    protected createActionRegistry(): ActionsRegistry;
    protected createDefaultInputReader(): {
        question: (text: string) => Promise<string>;
    };
    protected createStepRunner(): StepRunner;
    protected createMessageBroker(): MessageBroker;
    protected createInputController(): TerminalInputController;
    protected createMessageBuilder(): MessageBuilder;
    protected createElementSelector(): ElementSelector;
    protected createAgentBrowser(): AgentBrowser;
    protected createCostCalculator(): OpenAITokenCostCalculator;
    protected openBrowserPage(): Promise<void>;
    printCurrentCost(): void;
    protected get autopilotOn(): boolean;
    protected getAnswerTo(content: string): Promise<string>;
    getInput(prompt: string): Promise<string>;
    addToMessage(message: string): void;
    setMessage(message: string): void;
    createMessageForController(content: string): Promise<void>;
    get structuredMsg(): StructuredMsg;
    getControllerResponse(structuredMsg: StructuredMsg, context: any, actionConfig?: {
        name: string;
    }): Promise<void>;
}

export declare class AgentPlanner implements IAgentPlanner {
    context: any[];
    aiAgentResponse?: any;
    assignedMsg?: AssignedMsg;
    promptMessage?: string;
    promptText?: string;
    driver: IAgentDriver;
    debug: boolean;
    acceptPlan?: boolean;
    opts: PlannerOpts;
    agentState?: IAgentState;
    constructor(context: any, opts?: PlannerOpts);
    get messageBroker(): IMessageBroker;
    get definitions(): any[];
    setDefinitions(definitions: any[]): void;
    addDefinitions(definitions: any[]): void;
    start(): Promise<void>;
    runPlan(): Promise<void>;
    askForPlanAcceptance(): Promise<void>;
    protected onPlanCompleted(): void;
    protected get structuredMsg(): StructuredMsg;
    protected parseResponseArgs(): any;
    protected createInitialContext(): {
        role: string;
        content: string;
    }[];
    protected isPlanAccepted(): boolean;
    protected closeBrowser(): void;
    protected prepareAgentState(): {
        context: any[];
        response: any;
    };
    protected runDriver(): Promise<void>;
    protected preparePlanPrompt(): void;
    protected createDriver(): AgentDriver;
    protected startDriver(): Promise<void>;
    protected get browser(): IAgentBrowser;
    protected logContext(): void;
    protected addToContext(item: unknown): void;
    protected addMessageToContext(msg: unknown): void;
    protected addResponseToContext(response: HTTPResponse): void;
    protected getAgentResponse(): Promise<void>;
    createActionConfig(): {
        name: string;
        arguments: string[];
    };
    protected getControllerResponse(msg: any, context: any, actionConfig: any): Promise<void>;
    protected handleAcceptPlan(): Promise<void>;
    protected userAccept(): Promise<boolean>;
    protected autoAccept(): boolean;
    protected getInput(prompt: string): Promise<string>;
    protected handleArgs(args: any): void;
    protected log(data: any): void;
}

export declare interface AIMessageRedactor {
    redactMessages(messages: any[]): string[];
}

export declare type AssignedMsg = {
    role: string;
    content: string;
};

export declare abstract class BaseDriverAction implements IDriverAction {
    driver: IAgentDriver;
    fnArgs: FnArgs;
    context: Context;
    debug: boolean;
    definition: any;
    opts: IDriverActionOpts;
    taskPrefix: string;
    name: string;
    constructor(driver: IAgentDriver, opts?: IDriverActionOpts);
    protected updateState(): void;
    setState({ args, context }: {
        args: any;
        context: any;
    }): void;
    protected setContext(context: any[]): void;
    protected setArgs(args: any): void;
    protected get prefix(): string | undefined;
    execute(): Promise<void>;
    protected baseInit(): void;
    protected initialize(): void;
    protected addToMessage(message: string): void;
    protected get page(): Page | undefined;
    protected get autopilot(): boolean;
    protected getInput(msg: string): Promise<string>;
    resetMessage(): void;
    protected setMessage(msg: string): void;
    protected logTask(msg: any): void;
    protected log(msg: any): void;
}

export declare abstract class BaseResponseHandler implements IResponseHandler {
    step: any;
    driver: IAgentDriver;
    opts: IResponseHandlerOpts;
    constructor(driver: IAgentDriver, opts?: IResponseHandlerOpts);
    protected setStep(step: any): this;
    protected isFunctionCallStep(): any;
    handle(step: any): Promise<void>;
}

export declare type BrowserOpts = {
    debug?: boolean;
    headless?: boolean;
    viewport?: ViewportOpts;
};

export declare class ClickLinkAction extends ElementAction implements IClickLinkAction {
    message: string;
    link?: HTMLAnchorElement;
    linkId?: string;
    linkText?: string;
    userMsg?: string;
    interactiveElements: any;
    url?: string;
    requestCount: number;
    responseCount: number;
    downloadStarted: boolean;
    navigator: IPageNavigator;
    name: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                text: {
                    type: string;
                    description: string;
                };
                pp_id: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    };
    constructor(driver: IAgentDriver, interactiveElements: any[]);
    protected updateState(): void;
    protected createNavigator(): PageNavigator;
    protected missingLinkId(): void;
    protected missingLinkText(): void;
    protected findLink(): any;
    protected get page(): Page | undefined;
    protected onStart(linkText?: string): void;
    protected initAction(): void;
    protected get linkElementSelector(): string;
    action(): void;
    onTimeOutError(_link?: HTMLAnchorElement): void;
    onError(link: any): void;
    clickLink(): Promise<void>;
    clickOnPage(): void;
    waitForNavigation(): Promise<void>;
    onLinkNavigation(): void;
    onDownloadStarted(): true | undefined;
    set noContent(val: boolean);
    get noContent(): boolean;
    execute(): Promise<void>;
    validatePage(): void;
    scrapePage(): Promise<void>;
    getElementsOn(page: Page): Promise<ElementHandle<Element>[]>;
}

export declare class CommunicateAction extends BaseDriverAction implements IReceiveInputAction {
    costCalculator?: ITokenCostCalculator;
    text?: string;
    name: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                summary: {
                    type: string;
                    description: string;
                };
                answer: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    };
    protected initialize(): void;
    protected createCostCalculator(): OpenAITokenCostCalculator;
    execute(): Promise<void>;
    protected prepareAnswer(): void;
    protected get promptAnswer(): string;
    protected setText(text?: string): void;
    protected textFromFnArgs(): any;
    protected get userMsg(): string;
    protected get autoPilotMsg(): string;
    receiveInput(msg: string): Promise<string>;
    protected printCurrentCost(): void;
}

export declare class ContentResponseHandler extends BaseResponseHandler {
    actionId?: string;
    handle(step: any): Promise<void>;
    createMessageForController(content: string): void;
    printCurrentCost(): void;
}

export declare type Context = any[];

export declare type ControllerResponseData = {
    choices: any[];
    usage: TokenUsage;
};

export declare type DebugOpts = {
    debug?: boolean;
};

export declare class DocumentTraverser implements IDocumentTraverser {
    html?: string;
    $: CheerioAPI;
    driver: IAgentDriver;
    formatter: IHtmlFormatter;
    debug: boolean;
    opts: DebugOpts;
    elementTypeHandler: IElementTypeHandler;
    constructor(driver: IAgentDriver, opts?: DebugOpts);
    createElementTypeHandler(): ElementTypeHandler;
    formatHtml(bodyHtml: string): CheerioAPI;
    createFormatter(): HtmlFormatter;
    initialize(html: string): void;
    start(html: string): string;
    traverse(element: Element_2): string;
}

export declare type DriverOpts = DebugOpts & {
    definitions?: any[];
};

export declare abstract class ElementAction extends BaseDriverAction implements IDriverAction {
    protected getCssSelector(elem: Element): string;
    protected getRelevantTextBeforeNextHeader(headingElement: Element): string;
    protected findNearestHeadingElement(startElement: Element): Element | undefined;
    protected getTabbableElements(): Promise<ElementHandle<Element>[]>;
    getContentFor(handle: ElementHandle, maxLength?: number): Promise<string>;
    protected sliceOff(text?: string, length?: number): string | undefined;
    getContentForFirst(handle: ElementHandle, selector: string): Promise<string | null>;
    getContentForAll(mainHandle: ElementHandle, selector: string): Promise<string[]>;
    handleToElement(element: ElementHandle<Element>): Promise<Element>;
    protected matchesContent(element: Element, content: string): boolean | "";
    protected markerClass(id: number | string): string;
    protected get elementSelector(): IElementSelector;
    protected set element(elem: ElementHandle<Element>);
    protected get element(): ElementHandle<Element> | undefined;
}

export declare class ElementEvaluator {
    element?: Element;
    id: number;
    selector: string;
    role?: string | null;
    placeholder?: string;
    textContent?: string;
    type?: string;
    value?: string;
    href?: string;
    title?: string;
    driver: IAgentDriver;
    debug: boolean;
    opts: DebugOpts;
    maxAttrLength: number;
    constructor(driver: IAgentDriver, element: any, id: number, selector: string, opts?: DebugOpts);
    evaluate(): Element | undefined;
    protected configureElement(): void;
    protected get markerClass(): string;
    protected addMarkerClass(): void;
    protected elemRole(): void;
    protected titledElement(): void;
    protected externalRefElem(): void;
    protected formElement(): void;
    protected text(): void;
    protected sliceOff(text?: string, length?: number): string | undefined;
    ignoreElement(): boolean;
    trimWhiteSpaces(textContent: string | null): string;
}

export declare class ElementSelector implements IElementSelector {
    page?: Page;
    interactiveElementHandler: InteractiveElementHandler;
    skipped: ElementHandle<Element>[];
    selected: ElementHandle<Element>[];
    debug: boolean;
    driver: IAgentDriver;
    constructor(driver: IAgentDriver, opts?: SelectorOpts);
    getElements(page: Page, selector?: string): Promise<ElementHandle<Element>[]>;
    protected createInteractiveElementHandler(): InteractiveElementHandler;
    protected get elementSelector(): string;
    get selectors(): string[];
    protected getNext(element: ElementHandle<Element>, id: number, selector: string): Promise<false | Element>;
    protected skipElement(element: ElementHandle<Element>): void;
    protected selectElement(element: ElementHandle<Element>): void;
    protected writeElements(fileName: string, elements: ElementHandle<Element>[]): void;
    protected logElements(): void;
}

export declare class ElementTypeHandler implements IElementTypeHandler {
    element?: Element_2;
    docTraverser: IDocumentTraverser;
    output: string;
    driver: IAgentDriver;
    tagBuilder: ITagBuilder;
    debug: boolean;
    opts: DebugOpts;
    constructor(driver: IAgentDriver, docTraverser: DocumentTraverser, opts?: DebugOpts);
    handle(element: Element_2): string;
    protected get $(): CheerioAPI;
    protected addToOutput(text: string): void;
    protected handleHeaderElement(): void;
    protected handleFormElement(): void;
    protected handleSections(): void;
    protected handleHeadersAndSectionElements(): void;
    protected makeTag(element?: Element_2): any;
    protected createTagBuilder(): TagBuilder;
    protected handleSpecialAttr(elemTag: any): boolean;
    protected handleNonSpecialTag(): boolean;
    protected handleMisc(): void;
    protected traverse(element: Element_2): string;
    protected handleChildren(): void;
    protected formatOutput(): string;
}

export declare class EnterDataFormAction extends ElementAction implements IEnterDataAction {
    formData: IFieldData[];
    prevInput?: ElementHandle;
    navigator: IPageNavigator;
    taskName: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                form_data: {
                    type: string;
                    items: {
                        type: string;
                        properties: {
                            pp_id: {
                                type: string;
                                description: string;
                            };
                            label: {
                                type: string;
                                description: string;
                            };
                            name: {
                                type: string;
                                description: string;
                            };
                            text: {
                                type: string;
                                description: string;
                            };
                            select: {
                                type: string;
                                description: string;
                                items: {
                                    type: string;
                                    description: string;
                                };
                            };
                            index: {
                                type: string;
                                description: string;
                            };
                            check: {
                                type: string;
                                description: string;
                            };
                        };
                    };
                };
                submit: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    };
    constructor(driver: IAgentDriver, opts?: DebugOpts);
    protected createNavigator(): PageNavigator;
    selectElement(elementCssSelector: string): Promise<ElementHandle<Element> | null | undefined>;
    getElementAttr(element: Element, attrName: string): string;
    getSelectElementAttr(element: Element): {
        options: HTMLOptionsCollection;
        selectedIndex: number;
        selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
        multiple: boolean;
    };
    getElementChecked(element: Element): string;
    getElementType(element: Element): string;
    getElementName(element: Element): string;
    getElementTagName(element: Element): string;
    onSubmittable({ tagName, type }: IElementDetails): boolean;
    isTextInputField({ tagName, type }: IElementDetails): boolean;
    isFileInput({ tagName, type }: IElementDetails): boolean;
    isTextAreaField({ tagName }: IElementDetails): boolean;
    onTextField(element: ElementHandle, details: IElementDetails, data: any): Promise<void>;
    onFileField(element: ElementHandle, details: IElementDetails, data: any): Promise<void>;
    uploadFile(handle: ElementHandle<HTMLInputElement>, data: any): Promise<void>;
    protected hasMatchingOption(options: HTMLOptionsCollection, data: any): HTMLOptionElement | undefined;
    onSelectField(handle: ElementHandle, element: Element, details: IElementDetails, data: IFieldData): Promise<void>;
    isRadioField({ type, tagName }: IElementDetails): boolean;
    findTextFieldWithPlaceholder(selector: string, text: string): Promise<Element | null | undefined>;
    findElementWithText(selector: string, text: string): Promise<Element | null | undefined>;
    findHandleForFieldNamed(name: string): Promise<ElementHandle | null | undefined>;
    onRadioField(handle: ElementHandle, element: Element, details: IElementDetails, data: IFieldData): Promise<void>;
    onFormField(handle: ElementHandle, element: Element, details: IElementDetails, data: IFieldData): Promise<void>;
    get checkAnswers(): string[];
    get uncheckAnswers(): string[];
    clickRadio(handle: ElementHandle, details: IElementDetails, checked: boolean): Promise<void>;
    checkRadioOn(handle: ElementHandle, details: IElementDetails, checked: boolean, data: IFieldData): Promise<void>;
    unselectSelected(select: TSelectAttrs): void;
    selectOptionsOn(handle: ElementHandle, details: IElementDetails, select: TSelectAttrs, data: IFieldData): Promise<void>;
    selectSingleOption(handle: ElementHandle, select: TSelectAttrs, data: IFieldData): Promise<void>;
    selectMultipleOptions(handle: ElementHandle, details: IElementDetails, select: TSelectAttrs, data: IFieldData): Promise<true | undefined>;
    selectOptionFor(handle: ElementHandle, details: IElementDetails, option: string): Promise<void>;
    typeTextIn(element: ElementHandle, details: IElementDetails, data: IFieldData): Promise<void>;
    elementClassIdSelector(id: string): string;
    setElement(element: ElementHandle<Element>): void;
    findFieldForLabel(labelElem: Element): Promise<ElementHandle<Element> | null | undefined> | undefined;
    getFormData(): any;
    getElementById(id: string): Promise<ElementHandle<Element> | null | undefined>;
    getElementDetails(element: Element): IElementDetails;
    getFieldHandleByPlaceholder(data: IFieldData): Promise<Element | null | undefined>;
    getFieldHandleByLabel(data: IFieldData): Promise<ElementHandle<Element> | null | undefined>;
    getFieldHandleById(data: IFieldData): Promise<ElementHandle<Element> | null | undefined>;
    getFieldHandle(data: IFieldData): Promise<ElementHandle<Element>>;
    execute(): Promise<void>;
    protected waitForNavigation(): Promise<void>;
    protected onSubmit(): Promise<void>;
    setInteractiveElements(elements: ElementHandle<Element>[]): void;
    getPageUrl(): Promise<string | undefined>;
    handleForm(): Promise<void>;
    onSubmitFormError(error: any): void;
}

export declare type FindElementDetails = {
    parentType?: "main" | "footer" | "header" | "aside" | "dialog" | "nav" | "article" | "section" | "form";
    parentId?: string;
    type: "header" | "section" | "field" | "form" | "canvas" | "figure" | "article" | "video" | "code" | "table";
    id?: string;
    selector?: string;
    content?: string;
};

export declare type FnArgs = Record<string, any>;

export declare class FunctionResponseHandler extends BaseResponseHandler implements IFunctionResponseHandler {
    actionId?: string;
    fn?: any;
    fnName: string;
    fnArgs: FnArgs;
    chatMsg?: string;
    handle(step: any): Promise<void>;
    get contextLengthLimit(): number;
    get context(): any[] | undefined;
    protected setFunctionAttributes(): void;
    protected parseArgs(): any;
    protected performAction(): Promise<boolean>;
    protected log(msg: string): void;
    protected communicateMessage(msg: string): void;
    protected handleAction(): void;
    protected defaultAction(): void;
    protected findAction(): IDriverAction;
    get actions(): TActionStore;
}

export declare class GotoUrlAction extends ElementAction implements IGotoUrlAction {
    waitUntil: PuppeteerLifeCycleEvent;
    interactiveElements?: ElementHandle<Element>[];
    name: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                url: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    };
    onStart(url: string): void;
    execute(): Promise<void>;
    gotoUrl(url: string): Promise<void>;
    getUrl(): Promise<string | undefined>;
    onStartScraping(): void;
    get defaultGotoErrorMessage(): string;
    protected getTabbableElements(): Promise<ElementHandle<Element>[]>;
    downloadError(error: unknown): string | undefined;
}

export declare type GotoUrlOpts = DebugOpts & {};

export declare class HtmlFormatter implements IHtmlFormatter {
    html?: string;
    $?: CheerioAPI;
    debug: boolean;
    driver: IAgentDriver;
    constructor(driver: IAgentDriver, opts?: DebugOpts);
    protected get prioritySelectors(): string[];
    format(html: string): CheerioAPI;
}

export declare interface IActionDefinitionsRegistry {
    definitions: any[];
    setDefinitions(definitions: any[]): void;
    addDefinition(definition: any, overwrite?: boolean): void;
    addDefinitions(definitions: any[], overwrite?: boolean): void;
}

export declare interface IActionsRegistry {
    actions: TActionStore;
    registerAction(action: IDriverAction, id?: string): void;
    removeAction(id: string): void;
}

export declare interface IAgentBrowser {
    launch(): Promise<void>;
    start(): Promise<Page>;
    close(): void;
}

export declare interface IAgentDriver {
    structuredMsg: StructuredMsg;
    context?: any[];
    message?: string;
    markerClass(id: number | string): string;
    createMessageForController(content: string): Promise<void>;
    start(): Promise<void>;
    closeBrowser(): void;
    run(agentState: IAgentState): Promise<void>;
    doStep(interactiveElements: any, element: any): Promise<void>;
    setMessage(msg: string): void;
    addToMessage(message: string): void;
    getInput(msg: string): Promise<string>;
    getControllerResponse(structuredMsg: StructuredMsg, context: any, actionConfig: any): Promise<any>;
    page?: Page;
    elementSelector: IElementSelector;
    autopilot: boolean;
    noContent: boolean;
    contextLengthLimit: number;
    model: string;
    definitions: any[];
    actions: TActionStore;
    setDefinitions(definitions: any[]): void;
    addDefinition(definition: string): void;
    addDefinitions(definitions: any[]): void;
    printCurrentCost(): void;
    log(msg: any): void;
    browser: IAgentBrowser;
    messageBroker: IMessageBroker;
    inputController: IInputController;
    messageBuilder: IMessageBuilder;
    element?: ElementHandle<Element>;
    setInteractiveElements(elements: ElementHandle<Element>[]): void;
    setNoContent(val: boolean): void;
}

export declare interface IAgentPlanner {
    askForPlanAcceptance(): Promise<void>;
    definitions: any[];
    setDefinitions(definitions: any[]): void;
    addDefinitions(definitions: any[]): void;
}

export declare interface IAgentState {
    context: any[];
    response: HTTPResponse;
}

export declare interface IAIController {
    getResponse(messages: any[], definitions: any[], fnCall: any): Promise<any>;
}

export declare interface IClickLinkAction extends IDriverAction {
}

export declare interface IContentResponseHandler extends IResponseHandler {
}

export declare type ICreateTerminalReader = () => ITerminalReader;

export declare interface IDocumentTraverser {
    $: CheerioAPI;
    start(html: string): string;
    traverse(element: Element_2): string;
}

export declare interface IDriverAction {
    execute(): Promise<void>;
    definition: any;
    name: string;
    setState({ args, context }: {
        args: any;
        context: any;
    }): void;
}

export declare type IDriverActionOpts = DebugOpts & {
    definition?: any;
};

export declare interface IElementDetails {
    name: string;
    type: string;
    tagName: string;
}

export declare interface IElementSelector {
    getElements(page: Page, selector?: string): Promise<ElementHandle<Element>[]>;
}

export declare interface IElementTypeHandler {
    handle(element: Element_2): string;
}

export declare interface IEnterDataAction extends IDriverAction {
}

export declare interface IFieldData {
    pp_id: string;
    text: string;
    label?: string;
    name?: string;
    select?: string[];
    index?: number;
    check?: boolean;
    multipleFiles?: boolean;
    filepath?: string;
    filepaths?: string[];
}

export declare interface IFunctionResponseHandler extends IResponseHandler {
}

export declare interface IGotoUrlAction extends IDriverAction {
}

export declare interface IHtmlFormatter {
    format(html: string): CheerioAPI;
}

export declare interface IInputController {
    getInput(text: string): Promise<string>;
}

export declare interface IMessageBroker {
    getControllerResponse(message: unknown, context: any, actionConfig: ActionConfig): Promise<unknown>;
}

export declare interface IMessageBuilder {
    message: StructuredMsg;
    setContent(content?: string): void;
    addContent(content: string): void;
    setUrl(url: string): void;
}

export declare interface InputData {
    prompt: string;
    imageData: string;
}

export declare class InteractiveElementHandler {
    driver: IAgentDriver;
    debug: boolean;
    opts: DebugOpts;
    constructor(driver: IAgentDriver, opts?: DebugOpts);
    get page(): Page | undefined;
    onEvaluate: (element: Element, id: number, selector: string) => Promise<Element | undefined>;
    createElementEvaluator(element: Element, id: number, selector: string): ElementEvaluator;
    protected markerClass(id: number): string;
    nextInteractiveElement(element: ElementHandle<Element>, id: number, selector?: string): Promise<false | Element>;
    addBoundingBoxTo(element: Element, id: number): void;
}

export declare interface IPageNavigator {
    waitForNavigation(page: Page): Promise<void>;
}

export declare interface IPageScraper {
    getPageContent(page: Page): Promise<string>;
}

export declare type IQuestionFn = (text: string) => Promise<string>;

export declare interface IReadFileAction extends IDriverAction {
    readFile(): Promise<boolean>;
}

export declare interface IReceiveInputAction extends IDriverAction {
    receiveInput(msg: string): Promise<string>;
}

export declare interface IResponseHandler {
    step: any;
    handle(step: any): Promise<void>;
}

export declare type IResponseHandlerOpts = DebugOpts & {};

export declare interface ISearchAction extends IDriverAction {
}

export declare interface ISearchEngineAdapter {
    getSearchResults(): Promise<ISearchResult[]>;
}

export declare interface ISearchResult {
    href: string;
    title: string;
    description?: string;
}

export declare interface IStepRunner {
    run(step: any): Promise<void>;
    noContent: boolean;
    element?: ElementHandle<Element>;
    interactiveElements: ElementHandle<Element>[];
    clearHandlers(): void;
    registerHandler(handler: IResponseHandler): void;
}

export declare type IStepRunnerOpts = DebugOpts & {};

export declare interface ITagBuilder {
    build(element: Element_2): any;
}

export declare type ITakeScrenshotAction = IDriverAction;

export declare interface ITerminalReader {
    question: IQuestionFn;
}

export declare interface ITokenCostCalculator {
    tokenCost(promptTokens: number, completionTokens: number): number;
    printCurrentCost(): void;
}

export declare class MessageBroker implements IMessageBroker {
    debug: boolean;
    messages: unknown[];
    tokenUsage: TokenUsage;
    taskPrefix: string;
    autopilot: boolean;
    opts: DebugOpts;
    model: string;
    calculator?: ITokenCostCalculator;
    actions: any[];
    controller?: IAIController;
    driver: IAgentDriver;
    constructor(driver: IAgentDriver, opts?: TBrokerOpts);
    get definitions(): any[];
    getControllerResponse(message: unknown, context: any, actionConfig: ActionConfig): Promise<any>;
    get costLimits(): {
        min: number;
    };
    protected createController(): OpenAIController;
    protected createTokenCostCalculator(): OpenAITokenCostCalculator;
    protected logMessageContext(messages: unknown): void;
    protected filterDefinitions(actions?: string[], definitions?: any[]): any[];
    protected getControllerResponseData(actionConfig: ActionConfig, filteredDefinitions: any[]): Promise<any>;
    protected getController(): void;
    protected print(data: any): void;
    protected handleInvalidData(data: any): void;
    protected formatResponseData(data: any): void;
    protected calculateTokenCost(data: any): number | undefined;
    protected tokenCost(promptTokens: number, completionTokens: number): number | undefined;
    protected handleCost(cost: number, data: any): void;
    protected round(cost: number, decimals?: number): string;
    protected getMessageFromAiData(data: ControllerResponseData): any;
    protected onAutoPilotActivated(data: ControllerResponseData): void;
}

export declare class MessageBuilder implements IMessageBuilder {
    content: string;
    url: string;
    get message(): StructuredMsg;
    setContent(content?: string): void;
    addContent(content: string): void;
    setUrl(url: string): void;
}

export declare class NavigationOutlineAction extends ElementAction {
    name: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {};
        };
        required: never[];
    };
    get defaultNavSelector(): string;
    get navSelector(): any;
    getLinkInfoFor(element: HTMLAnchorElement): {
        href: string;
        text: string;
    } | undefined;
    execute(): Promise<void>;
}

export declare type ObjType = Record<string, string | undefined>;

export declare class OpenAIController {
    definitions: any[];
    debug: boolean;
    model: string;
    redacter: OpenAIMessageRedactor;
    opts: DebugOpts;
    get openaiApiKey(): string | undefined;
    constructor(driver: IAgentDriver, definitions?: any[], opts?: DebugOpts);
    get apiEndpoint(): string;
    redactMessages(messages: any[]): void;
    getResponse(messages: any[], definitions: any[], fnCall?: string): Promise<any>;
    print(data: any): void;
}

export declare class OpenAIMessageRedactor implements AIMessageRedactor {
    currentUrl: string;
    debug: boolean;
    driver: IAgentDriver;
    constructor(driver: IAgentDriver, opts: DebugOpts);
    redactMessages(messages: any[]): any[];
    redactMessage(message: any): any;
    logRedacted(redactedMessages: any[]): void;
}

export declare class OpenAITokenCostCalculator {
    tokenUsage: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
    driver: IAgentDriver;
    model: string;
    debug: boolean;
    constructor(driver: IAgentDriver, opts?: DebugOpts);
    printCurrentCost(): void;
    tokenCost(promptTokens: number, completionTokens: number): number;
    protected getTokenPrice(model: string, direction: string): number;
    protected round(num: number, decimals?: number): string;
    protected print(message?: string): void;
}

export declare type PageHeaders = Record<string, string>;

export declare class PageNavigator implements IPageNavigator {
    navigationTimeout: number;
    waitUntil: PuppeteerLifeCycleEvent;
    debug: boolean;
    driver: IAgentDriver;
    opts: PageNavigatorOpts;
    constructor(driver: IAgentDriver, opts?: PageNavigatorOpts);
    get defaults(): {
        navigationTimeout: number;
    };
    waitForNavigation(page: Page): Promise<void>;
    log(msg: string): void;
    onError(_error: any): void;
}

export declare type PageNavigatorOpts = DebugOpts & {
    navigationTimeout?: number;
};

export declare class PageScraper implements IPageScraper {
    debug: boolean;
    opts: DebugOpts;
    driver: IAgentDriver;
    documentTraverser: IDocumentTraverser;
    constructor(driver: IAgentDriver, opts?: DebugOpts);
    createDocumentTraverser(): DocumentTraverser;
    getPageContent(page: Page): Promise<string>;
    formatHtml(html: string): string;
}

export declare type PlannerOpts = DebugOpts & {
    model?: string;
};

export declare class PresearchAdapter implements ISearchEngineAdapter {
    page: Page;
    constructor(page: Page);
    get resultSelector(): string;
    get resultLink(): string;
    get resultTitle(): string;
    get resultDescription(): string;
    getContentFor(handle: ElementHandle, selector: string): Promise<string | null>;
    getSearchResultFrom(handle: ElementHandle): Promise<{
        href: string;
        title: string;
        description: string | undefined;
    } | undefined>;
    getSearchResults(): Promise<ISearchResult[]>;
}

export declare type QueryFn = (query: string) => string;

export declare class ReadFileAction extends BaseDriverAction implements IReadFileAction {
    filename?: string;
    contextLengthLimit: number;
    skipFile: boolean;
    name: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                filename: {
                    type: string;
                    description: string;
                };
            };
        };
        required: string[];
    };
    onStartTask(): void;
    readFile(): Promise<boolean>;
    getFileData(): Promise<string>;
    contentFromFileData(fileData: string): string;
    handleReadError(_error: any): void;
    attemptToReadFile(): Promise<void>;
    handleCannotReadFile(): void;
    execute(): Promise<void>;
    protected prepareReadFile(): void;
    protected setFileName(): void;
    getInput(msg: string): Promise<string>;
    get askToReadFileMsg(): string;
    shouldReadFile(): Promise<string | true>;
}

export declare type ResponseData = {
    usage: TokenUsage;
};

export declare class SearchAction extends ElementAction implements ISearchAction {
    waitUntil: PuppeteerLifeCycleEvent;
    name: string;
    defaultEngine: string;
    searchEngines: SearchEngineRegistry;
    searchResults?: ISearchResult[];
    adapters: Record<string, ISearchEngineAdapter>;
    registerDefaultAdapters(): void;
    registerAdapter(key: string, adapter: ISearchEngineAdapter): void;
    get query(): any;
    get searchEngineName(): any;
    get searchEngine(): QueryFn | undefined;
    get adapter(): ISearchEngineAdapter | undefined;
    get queryUrl(): string;
    onStart(): void;
    execute(): Promise<void>;
    gotoUrl(url: string): Promise<void>;
    onStartScraping(): void;
    protected getSearchResults(): Promise<ISearchResult[] | undefined>;
}

export declare type SearchEngineRegistry = Record<string, QueryFn>;

export declare type SearchOpts = DebugOpts & {};

export declare class SectionOutlineAction extends ElementAction {
    taskName: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                maxSectionTextSize: {
                    type: string;
                    description: string;
                    default: number;
                };
            };
        };
        required: never[];
    };
    get maxSectionTextSize(): any;
    get headersSelector(): string;
    execute(): Promise<void>;
}

export declare type SelectorOpts = {
    debug?: boolean;
};

export declare class SimpleGPTVision {
    private openai;
    constructor(options: SimpleGPTVisionOptions);
    processInput(input: InputData): Promise<string>;
}

export declare interface SimpleGPTVisionOptions {
    apiKey: string;
}

export declare class StepRunner {
    step: any;
    element?: ElementHandle<Element>;
    interactiveElements: ElementHandle<Element>[];
    driver: IAgentDriver;
    debug: boolean;
    opts: IStepRunnerOpts;
    noContent: boolean;
    handlers: IResponseHandler[];
    pageScraper: IPageScraper;
    domElement?: Element;
    constructor(driver: IAgentDriver, opts?: IStepRunnerOpts);
    clearHandlers(): void;
    registerHandler(handler: IResponseHandler): void;
    run(step: any): Promise<void>;
    protected doNextStep(): Promise<void>;
    protected defaultHandlers(): (FunctionResponseHandler | ContentResponseHandler)[];
    protected createPageScraper(): PageScraper;
    protected createFunctionHandler(): FunctionResponseHandler;
    protected createContentHandler(): ContentResponseHandler;
    protected get context(): any[] | undefined;
    protected logContext(): void;
    protected initState(step: any): void;
    protected handleStep(): Promise<void>;
    protected getPageData(): Promise<void>;
    protected prepareNextStep(): Promise<void>;
    protected ensurePageContent(): Promise<void>;
    protected hasContent(): boolean;
    protected getPageContent(): Promise<string>;
    protected get page(): Page | undefined;
    protected get messageBuilder(): IMessageBuilder;
    protected addPageContent(pageContent: string): void;
    get contextLengthLimit(): number;
    protected updateContext(): void;
    get structuredMsg(): StructuredMsg;
    get message(): string | undefined;
    protected getNextStep(): Promise<void>;
    getControllerResponse(structuredMsg: StructuredMsg, context: any, actionConfig?: {
        name: string;
    }): Promise<any>;
    setPageUrl(): Promise<void>;
    getPageUrl(): Promise<string | undefined>;
    addToContext(data: any): void;
}

export declare type StructuredMsg = {
    content: string;
    url: string;
};

export declare type TActionStore = Record<string, IDriverAction>;

export declare class TagBuilder implements ITagBuilder {
    element: any;
    tagName?: string;
    value?: string;
    role?: string;
    type?: string;
    id?: string;
    tag?: string;
    title?: string;
    href?: string;
    placeholder?: string;
    textContent?: string;
    obj: ObjType;
    driver: IAgentDriver;
    opts: DebugOpts;
    constructor(driver: IAgentDriver, opts?: DebugOpts);
    initialize(): void;
    getAttrValue(name: string): string | undefined;
    build(element: Element_2): ObjType;
    createObj(): ObjType;
    setTag(): void;
    setTextContent(): void;
    setPlaceholder(): void;
    setTitle(): void;
    setHref(): void;
}

export declare class TakeScrenshotAction extends ElementAction implements ITakeScrenshotAction {
    name: string;
    definition: {
        name: string;
        description: string;
        parameters: {
            type: string;
            properties: {
                parentType: {
                    type: string;
                    description: string;
                };
                parentId: {
                    type: string;
                    description: string;
                };
                type: {
                    type: string;
                    description: string;
                };
                id: {
                    type: string;
                    description: string;
                };
                selector: {
                    type: string;
                    description: string;
                };
                content: {
                    type: string;
                    description: string;
                };
            };
        };
    };
    get filePath(): any;
    get startFrom(): any;
    get screenshotOptions(): {
        path: any;
    };
    execute(): Promise<void>;
    pageScreenshot(): Promise<true | undefined>;
    parentSelector(startFrom: FindElementDetails): "article" | "aside" | "dialog" | "footer" | "form" | "main" | "nav" | "section" | "h1,h2,h3" | undefined;
    mainSelector(startFrom: FindElementDetails): "article" | "canvas" | "code" | "figure" | "form" | "section" | "table" | "video" | "h1,h2,h3" | "input,select,textarea";
    idSelector(id: string): string;
    selectorFor(startFrom: FindElementDetails): string;
    findElement(startFrom: FindElementDetails): Promise<ElementHandle<Element> | undefined>;
    elementScreenshot(): Promise<true | undefined>;
}

export declare type TBrokerOpts = DebugOpts;

export declare class TerminalInputController implements IInputController {
    createReader: ICreateTerminalReader;
    constructor(createReader: any);
    getInput(text: string): Promise<string>;
}

export declare type TokenUsage = {
    completionTokens: number;
    promptTokens: number;
    totalTokens: number;
};

export declare type TSelectAttrs = {
    multiple: boolean;
    options: HTMLOptionsCollection;
    selectedIndex: number;
    selectedOptions: HTMLCollectionOf<HTMLOptionElement>;
};

export declare type ViewportOpts = {
    width?: number;
    height?: number;
    scaleFactor?: number;
};

export { }