import { ElicitationResponse } from './elicitation';
import { Dto } from './client';
import { paths } from './schema';
import { DictationMint } from '../dictation/dictation-session';
import { WidgetConfig } from '../types/widget-config';
import { AgentTurnMessagesDto, ResolveSessionDto, SendMessageDto, VoteInputDto } from '../types/dtos';
type ConnectionStartResult = NonNullable<paths['/backend/widget/v5/connections/{serverId}/start']['post']>['responses'][201]['content']['application/json'];
type ConnectionAttemptStatus = NonNullable<paths['/backend/widget/v5/connections/{serverId}/attempts/{attemptId}']['get']>['responses'][200]['content']['application/json']['status'];
export declare class ConnectionRequestExpiredError extends Error {
    constructor();
}
export declare class ConnectionAttemptUnavailableError extends Error {
    constructor();
}
export declare class ApiCaller {
    private client;
    private config;
    private userToken;
    constructor({ config }: {
        config: WidgetConfig;
    });
    private constructClientOptions;
    private createOpenAPIClient;
    listApprovalPreferences: () => Promise<{
        key: string;
        serverId: string;
        serverName: string;
        message: string;
        toolName: string;
    }[]>;
    revokeApprovalPreference: (serverId: string, key: string) => Promise<void>;
    listElicitations: (sessionId: string, signal?: AbortSignal) => Promise<{
        id: string;
        serverId: string;
        serverName: string;
        expiresAt: number;
        form: {
            message: string;
            requestedSchema: {
                properties: Record<string, {
                    type: "string" | "number" | "boolean" | "array" | "integer";
                    title?: string | undefined;
                    description?: string | undefined;
                    default?: string | number | boolean | string[] | undefined;
                    enum?: string[] | undefined;
                    oneOf?: {
                        const: string;
                        title?: string | undefined;
                    }[] | undefined;
                    items?: {
                        enum?: string[] | undefined;
                        anyOf?: {
                            const: string;
                            title?: string | undefined;
                        }[] | undefined;
                    } | undefined;
                    minItems?: number | undefined;
                    maxItems?: number | undefined;
                    minimum?: number | undefined;
                    maximum?: number | undefined;
                    minLength?: number | undefined;
                    maxLength?: number | undefined;
                    format?: string | undefined;
                }>;
                required?: string[] | undefined;
            };
        };
        approvalKey?: string | undefined;
    }[]>;
    answerElicitation: (sessionId: string, requestId: string, answer: ElicitationResponse) => Promise<void>;
    listConnections: (signal?: AbortSignal) => Promise<{
        server_id: string;
        name: string;
        status: "not_connected" | "connected" | "reconnect_required";
    }[]>;
    startConnection: (serverId: string, requestId: string, signal?: AbortSignal) => Promise<ConnectionStartResult>;
    getConnectionAttempt: (serverId: string, attemptId: string, signal?: AbortSignal) => Promise<ConnectionAttemptStatus>;
    disconnectConnection: (serverId: string) => Promise<void>;
    setAuthToken: (token: string) => void;
    /**
     * AUTH headers only (X-Bot-Token / Authorization), stripped of
     * content-type/accept. The transport sets its own Content-Type, and a second
     * (case-differing) copy gets COMBINED by the Headers init into
     * "application/json, application/json" — which the server rejects (415). Also
     * reused for the reconnect/stop control calls (empty-body POST/GET).
     */
    private getStreamAuthContext;
    /**
     * Wiring for the agent-chat streaming adapter: the send endpoint, the
     * session-scoped reconnect endpoint, and the shared auth headers.
     * Computed lazily so a later `setAuthToken` is always reflected.
     */
    getStreamTransportOptions: () => {
        api: string;
        reconnectApi: (sessionId: string) => string;
        headers: Record<string, string>;
    };
    /**
     * Stop / interrupt the session's in-flight streamed turn. With resumable
     * streams on, a client abort is treated as a disconnect (the stream
     * survives), so a real "stop" is this explicit call — the backend cancels
     * generation and clears the resume pointer. Throws on failure — the caller
     * decides how to react, so a failed cancel is never mistaken for an ACKed
     * one.
     */
    stopStream: (sessionId: string) => Promise<void>;
    /**
     * What actually happened on the page, back to the turn that is waiting for
     * it. The widget does the thing, looks at the result, and says so; until
     * this call lands the agent only knows that it asked.
     *
     * Never throws and never blocks anything the visitor is doing: a lost
     * answer costs the tool call its timeout, which the server already handles,
     * and a browser stuck on this would be a browser that cannot get on with
     * the page.
     */
    sendPageReply: (sessionId: string, reply: {
        callId: string;
        outcome: "done" | "covered" | "gone" | "hidden" | "unsupported" | "no_change" | "declined";
        detail?: string;
        controls?: {
            ref: string;
            role: string;
            name: string;
            disabled?: boolean;
        }[];
        truncated?: boolean;
    }) => Promise<void>;
    /**
     * The session's settled agent turns with their final UIMessage parts and
     * the transcript rows each produced — the reload-fidelity read (widget v5).
     * Returns null on any failure: the caller then keeps the plain-row
     * rendering, exactly the pre-feature behavior.
     */
    getAgentTurnMessages: (sessionId: string, presentation?: WidgetConfig["presentation"]) => Promise<AgentTurnMessagesDto | null>;
    /**
     * Mint a short-lived transcription token for voice dictation (widget v5).
     * Org-gated server-side; throws on any failure so the caller can surface
     * "dictation unavailable" instead of hanging with an open mic.
     */
    createDictationSession: ({ language, }: {
        language?: string | undefined;
    }) => Promise<DictationMint>;
    getExternalWidgetConfig: () => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header: {
                "x-bot-token": string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetConfigDto"] | import('./schema').components["schemas"]["WidgetPreludeDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        params: {
            header: {
                'x-bot-token': string;
            };
        };
    }, `${string}/${string}`>>;
    sendMessage: (body: SendMessageDto, abortSignal?: AbortSignal) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": import('./schema').components["schemas"]["WidgetSendMessageInputDto"];
            };
        };
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetSendMessageOutputDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        body: {
            uuid: string;
            content: string;
            session_id: string;
            bot_token: string;
            headers?: {
                [key: string]: string;
            } | null;
            query_params?: {
                [key: string]: string;
            } | null;
            body_properties?: {
                [key: string]: unknown;
            } | null;
            language?: string | null;
            attachments?: import('./schema').components["schemas"]["ChatAttachmentDto"][] | null;
            clientContext?: {
                [key: string]: unknown;
            } | null;
            presentation?: import('./schema').components["schemas"]["WidgetPresentationOverrideDto"];
            capabilities?: {
                connections?: boolean;
                structured_questions?: boolean;
                rich_replies?: boolean;
                page_effects?: boolean;
            } | null;
            features?: {
                preamble?: boolean;
                inline_ui?: boolean;
                page_context?: boolean;
                client_tools?: boolean;
                page_actions?: boolean;
            } | null;
            custom_data?: {
                [key: string]: unknown;
            } | null;
            exit_mode_prompt?: string;
            action_form_submitted_prompt?: string;
            option_reply?: {
                message_id: string;
                option_id: string;
            };
            initial_messages?: {
                uuid: string;
                content: string;
            }[];
        };
        signal: AbortSignal | undefined;
    }, `${string}/${string}`>>;
    createUnverifiedContact: (body: Dto["CreateUnverifiedContactDto"]) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header: {
                "x-bot-token": string;
            };
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": import('./schema').components["schemas"]["CreateUnverifiedContactDto"];
            };
        };
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetContactTokenResponseDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        params: {
            header: {
                'x-bot-token': string;
            };
        };
        body: {
            email?: string | null;
            non_verified_name?: string | null;
            non_verified_custom_data?: {
                [key: string]: string | number | boolean;
            } | null;
        };
    }, `${string}/${string}`>>;
    createSession: (body: Dto["CreateWidgetSessionDto"], abortSignal?: AbortSignal) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": import('./schema').components["schemas"]["CreateWidgetSessionDto"];
            };
        };
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetSessionDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        body: {
            customData?: {
                [key: string]: string | number | boolean;
            };
        } | null;
        signal: AbortSignal | undefined;
    }, `${string}/${string}`>>;
    pollSessionAndHistory: ({ sessionId, abortSignal, }: {
        sessionId: string;
        abortSignal: AbortSignal;
    }) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path: {
                sessionId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetSessionAndHistoryDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        params: {
            path: {
                sessionId: string;
            };
        };
        signal: AbortSignal;
    }, `${string}/${string}`>>;
    /** The visitor is looking at this session right now. */
    markSessionRead: ({ sessionId, abortSignal, }: {
        sessionId: string;
        abortSignal?: AbortSignal;
    }) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path: {
                sessionId: string;
            };
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetSessionDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        params: {
            path: {
                sessionId: string;
            };
        };
        signal: AbortSignal | undefined;
    }, `${string}/${string}`>>;
    getSessions: ({ cursor, filters, abortSignal, }: {
        /** Opaque pagination token: the `next` value from the previous page (the backend paginates by `offset`). */
        cursor: string | undefined;
        filters: Record<string, string>;
        abortSignal?: AbortSignal;
    }) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query: {
                filters: string;
                offset?: string;
            };
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody?: never;
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["PaginatedWidgetSessionsDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        params: {
            query: {
                offset: string | undefined;
                filters: string;
            };
        };
        signal: AbortSignal | undefined;
    }, `${string}/${string}`>>;
    /**
     * openapi-fetch usually works fine for file uploads, but this time around it parses the payload in a weird way and results in 413 errors (payload too large)
     * Anyway, good old XHR even does it better with progress events
     */
    uploadFile: ({ file, abortSignal, onProgress, }: {
        file: File;
        abortSignal: AbortSignal;
        onProgress?: (percentage: number) => void;
    }) => Promise<Dto["UploadWidgetFileResponseDto"]>;
    vote: (body: VoteInputDto) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": import('./schema').components["schemas"]["WidgetVoteDto"];
            };
        };
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetVoteResponseDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        body: {
            action: "upvote" | "downvote";
            sessionId: string;
            messagePublicId: string;
        };
    }, `${string}/${string}`>>;
    resolveSession: (body: ResolveSessionDto, abortSignal?: AbortSignal) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": import('./schema').components["schemas"]["WidgetResolveSessionInputDto"];
            };
        };
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetSessionDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        body: {
            session_id: string;
        };
        signal: AbortSignal | undefined;
    }, `${string}/${string}`>>;
    createStateCheckpoint: (body: Dto["WidgetCreateStateCheckpointInputDto"]) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": import('./schema').components["schemas"]["WidgetCreateStateCheckpointInputDto"];
            };
        };
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetCreateStateCheckpointOutputDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        body: {
            session_id: string;
            payload: {
                [key: string]: unknown;
            };
        };
    }, `${string}/${string}`>>;
    submitCsat: (body: Dto["WidgetSubmitCsatInputDto"]) => Promise<import('openapi-fetch').FetchResponse<{
        parameters: {
            query?: never;
            header?: never;
            path?: never;
            cookie?: never;
        };
        requestBody: {
            content: {
                "application/json": import('./schema').components["schemas"]["WidgetSubmitCsatInputDto"];
            };
        };
        responses: {
            200: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["WidgetSubmitCsatOutputDto"];
                };
            };
            500: {
                headers: {
                    [name: string]: unknown;
                };
                content: {
                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
                };
            };
        };
    }, {
        body: {
            session_id: string;
            score: number;
            feedback?: string;
            system_message_uuid?: string;
        };
    }, `${string}/${string}`>>;
}
export {};
//# sourceMappingURL=api-caller.d.ts.map