@deepdesk/deepdesk-sdk 10.0.0-beta.12

package/dist/index.d.mts

@@ -0,0 +1,2047 @@
+import React, { FC, HTMLAttributes, ForwardRefExoticComponent, RefAttributes, ReactNode, SyntheticEvent } from 'react';
+import * as redux from 'redux';
+import * as _reduxjs_toolkit_dist_configureStore from '@reduxjs/toolkit/dist/configureStore';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import { Middleware } from '@reduxjs/toolkit';
+
+declare enum Sources {
+    SEARCH = "search",
+    TEMPLATE = "template",
+    ELASTIC_SEARCH = "studio-search",
+    GPT = "gpt",
+    TRIE = "trie",
+    TRIE_WITH_TYPOS = "trie-with-typos",
+    SEMANTIC = "semantic",
+    TEXT_RECOMMENDATION = "text_recommendation",
+    URL_RECOMMENDATION = "url_recommendation",
+    LINK_RECOMMENDATION = "link_recommendation",
+    PERSONAL_COLLECTION = "personal-collection",
+    PERSONAL_COLLECTION_SEARCH = "personal-collection-search"
+}
+declare enum InputType {
+    TAB = "tab",
+    ARROW = "arrow",
+    HOTKEY = "hotkey",
+    MOUSE = "mouse"
+}
+
+/**
+ * A selection range representation for textarea's and contenteditables only using offsets.
+ */
+type SelectionRange = {
+    start: number;
+    end: number;
+};
+interface InputEventMap {
+    /**
+     * User and platform changes (excluding changes by plugin)
+     */
+    change: (event: {
+        plainText: string;
+        rawHtml: string | null;
+    }) => void;
+    /**
+     * Updated value after User, platform and plugin changes
+     */
+    updated: (event: {
+        plainText: string;
+        rawHtml: string | null;
+    }) => void;
+    /**
+     * Changed selection of input
+     */
+    selection: (event: SelectionRange | null) => void;
+    keydown: (event: KeyboardEvent) => void;
+    paste: (event: {
+        pastedText: string;
+        selectionText: string;
+    }) => void;
+    cut: (event: {
+        selectionText: string;
+    }) => void;
+    submit: () => void;
+    enabled: () => void;
+    disabled: () => void;
+    unmounted: () => void;
+    focus: () => void;
+    blur: () => void;
+}
+type InputHandler<K extends keyof InputEventMap> = InputEventMap[K];
+type InputEventListeners<K extends keyof InputEventMap> = Record<K, InputHandler<K>[]>;
+declare abstract class InputMediator<HTMLElementType extends HTMLElement> {
+    protected element: HTMLElementType;
+    protected eventListeners: Partial<InputEventListeners<keyof InputEventMap>>;
+    protected disposeHandlers: (() => void)[];
+    protected currentText: string;
+    protected currentHTML: string | null;
+    protected currentSelection: SelectionRange | null;
+    protected isFocused: boolean;
+    protected isActive: boolean;
+    protected isSettingValue: boolean;
+    protected isSubmitting: boolean;
+    protected isPossibleClearInputAction: boolean;
+    protected isDisposed: boolean;
+    constructor(element: HTMLElementType);
+    protected addEventListener(eventName: string, listener: EventListenerOrEventListenerObject): void;
+    protected removeEventListener(eventName: string, listener: EventListenerOrEventListenerObject): void;
+    protected triggerChange(): void;
+    abstract getSelectedText(): string;
+    protected handleKeyUp(event: KeyboardEvent): void;
+    protected handleFocus(): void;
+    protected handleBlur(): void;
+    protected handleKeyDown(event: KeyboardEvent): void;
+    protected handleCut(): void;
+    protected handlePaste(event: ClipboardEvent): void;
+    protected listen(): void;
+    abstract getText(): string;
+    abstract getHTML(): string | null;
+    abstract getSelection(): SelectionRange | null;
+    abstract applyChanges(callback: (element: HTMLElementType) => void): void;
+    focus(): void;
+    emit<K extends keyof InputEventMap>(type: K, ...args: Parameters<InputHandler<K>>): void;
+    on<K extends keyof InputEventMap>(type: K, handler: InputHandler<K>): void;
+    activate(): void;
+    deactivate(): void;
+    dispose(): void;
+}
+
+type State$f = {
+    startTime: Date | null;
+    stopTime: Date | null;
+};
+
+interface State$e {
+    contentType: string | null;
+    suggestion: TextSuggestion | null;
+}
+
+/**
+ * CamelCase type manipulation
+ * ```
+ *  type InputType = 'snake_case_key_1'
+ *  type OutputType = CamelCase<InputType>; // 'snakeCaseKey1'
+ * ```
+ */
+type CamelCase<S extends string> = S extends `${infer P1}_${infer P2}${infer P3}` ? `${Lowercase<P1>}${Uppercase<P2>}${CamelCase<P3>}` : Lowercase<S>;
+/**
+ * CamelCaseKeys type manipulation
+ * Convert object keys and nested objects keys to camel case
+ * ```
+ *  type InputType = {
+ *      snake_case_key_1: number,
+ *      snake_case_key_2: string,
+ *  }
+ *
+ *  type OutputType = CamelCaseKeys<InputType>;
+ *  >    ^ =
+ *  > type OutputType = {
+ *  >     snakeCaseKey1: number;
+ *  >     snakeCaseKey2: string;
+ *  > }
+ * ```
+ */
+type CamelCaseKeys<T> = T extends Array<any> ? {
+    [K in keyof T[number] as CamelCase<K & string>]: CamelCaseKeys<T[number][K]>;
+}[] : T extends object ? {
+    [K in keyof T as CamelCase<K & string>]: CamelCaseKeys<T[K]>;
+} : T;
+
+type Fetch = typeof window.fetch;
+type HTTPClientOptions = {
+    fetch?: typeof window.fetch;
+};
+interface RetryInit {
+    abortLatest?: boolean;
+    attempts?: number;
+    retryDelay?: number;
+    retryOnError?(error: Error): boolean;
+    retryOnResponse?(response: Response): boolean;
+}
+interface RefreshTokenInit {
+    refreshTokenOn401?: boolean;
+}
+interface APIVersionInit {
+    version?: 'v1' | 'v2' | null;
+}
+interface ExtendedRequestInit extends RequestInit, RefreshTokenInit, RetryInit, APIVersionInit {
+}
+declare class HTTPClient {
+    baseUrl: string;
+    options: HTTPClientOptions;
+    private latestRequestByUrl;
+    csrfToken?: string;
+    fetch: ((input: RequestInfo | URL, init?: RequestInit | undefined) => Promise<Response>) & typeof fetch;
+    private static refreshingToken;
+    constructor(baseUrl?: string, options?: HTTPClientOptions);
+    patchFetch(patch: (fetchFn: Fetch) => Fetch): void;
+    setCsrfToken(token: string): void;
+    request<TResponse>(path: string, init?: ExtendedRequestInit): Promise<TResponse>;
+    /**
+     * SDK used to talk to backend endpoints only. Backend requires an accessToken for authentication and therefore /auth/validate (backend) is checked.
+     * Now SDK will also use admin endpoints. Admin requires a session for authentication.
+     * Therefore, both admin and backend authentication is checked
+     */
+    validateToken(): Promise<boolean>;
+    refreshToken(): Promise<void>;
+    get<TResponse>(path: string, init?: ExtendedRequestInit): Promise<TResponse>;
+    post<TPayload, TResponse>(path: string, body: TPayload, init?: ExtendedRequestInit): Promise<TResponse>;
+    patch<TPayload, TResponse>(path: string, body: TPayload, init?: ExtendedRequestInit): Promise<TResponse>;
+    put<TPayload, TResponse>(path: string, body: TPayload, init?: ExtendedRequestInit): Promise<TResponse>;
+    delete<TResponse>(path: string, init?: ExtendedRequestInit): Promise<TResponse>;
+}
+
+type SSEClientOptions = {
+    timeout: number;
+};
+declare class SSEClient<TEventMap extends Record<string, (data?: any) => void>> {
+    url: string;
+    private eventListeners;
+    private options;
+    private timeoutTimer;
+    eventSource: EventSource | undefined;
+    constructor(url: string, options?: Partial<SSEClientOptions>);
+    private proxyEvent;
+    connect(): void;
+    disconnect(): void;
+    emit(type: keyof TEventMap, eventPayload: any): void;
+    on(type: keyof TEventMap, handler: any): () => void;
+    off(type: keyof TEventMap, handler: any): void;
+}
+
+declare namespace Server$1 {
+    interface CustomMessageReplyOption {
+        title: string;
+        payload: string;
+    }
+    interface CustomMessage {
+        text: string;
+        reply_options?: CustomMessageReplyOption[];
+    }
+    interface CustomMessagesResponse {
+        suggestions: CustomMessage[];
+    }
+    declare enum AutoflowSessionState {
+        Started = "Started",
+        Aborted = "Aborted",
+        Completed = "Completed"
+    }
+    interface Autoflow {
+        description?: string;
+        display_name?: string;
+        trigger_payload?: string;
+        state: AutoflowSessionState | null;
+    }
+    interface AutoflowsResponse {
+        autoflows: Autoflow[];
+    }
+    interface AutoflowSessionPayload {
+        platform_session_id: string;
+        trigger_payload: string;
+    }
+    interface AutoflowSession {
+        id: string;
+        platform_session_id: string;
+        session_type: string;
+        state: AutoflowSessionState;
+        data: {
+            trigger_payload: string;
+            'trigger-payload': string;
+        };
+    }
+}
+type EventMap = {
+    customMessageSuggestion: (data: CamelCaseKeys<Server$1.CustomMessage>) => void;
+    sessionAborted: (data: {
+        id: string;
+    }) => void;
+    sessionCompleted: (data: {
+        id: string;
+    }) => void;
+};
+declare class DeepdeskBrokerAPI {
+    apiUrl: string;
+    client: HTTPClient;
+    streams: Record<string, SSEClient<EventMap>>;
+    logger: Logger;
+    constructor(apiUrl: string, options?: HTTPClientOptions);
+    getCustomMessages(platformSessionId: string): Promise<CamelCaseKeys<Server$1.CustomMessage[]>>;
+    sendCustomMessage(platformSessionId: string, suggestion: CamelCaseKeys<Server$1.CustomMessage>): Promise<CamelCaseKeys<Server$1.CustomMessage>>;
+    answerCustomMessage(platformSessionId: string, reply: CamelCaseKeys<Server$1.CustomMessageReplyOption>): Promise<void>;
+    getAutoflows(platformSessionId: string): Promise<CamelCaseKeys<Server$1.Autoflow[]>>;
+    startAutoflowSession(autoflowSession: CamelCaseKeys<Server$1.AutoflowSessionPayload>): Promise<CamelCaseKeys<Server$1.AutoflowSession>>;
+    stopAutoflowSession(platformSessionId: string): Promise<void>;
+    openStream(platformSessionId: string): SSEClient<EventMap>;
+    closeStream(platformSessionId: string): void;
+}
+
+interface StoreConfig {
+    deepdeskAPI: DeepdeskAPI;
+    deepdeskBrokerAPI?: DeepdeskBrokerAPI;
+    dynamicThunkObject?: Record<string, unknown>;
+    middleware?: Middleware[];
+    preloadedState?: any;
+}
+declare function createStore(config: StoreConfig): _reduxjs_toolkit_dist_configureStore.ToolkitStore<redux.EmptyObject & {
+    activeSuggestion: State$e;
+    answer: State$6;
+    auth: State$d;
+    autoflows: State$c;
+    conversation: State$b;
+    contentTypes: State$a;
+    customMessages: State$9;
+    exchangeToken: State$8;
+    entities: State$7;
+    handlingTime: State$f;
+    info: {
+        agentInfo?: AgentInfo | undefined;
+        agentSettings: unknown;
+        visitorInfo?: VisitorInfo | undefined;
+        fetchState: FetchState;
+    };
+    input: State$5;
+    overlayInput: State$5;
+    settings: {
+        locale: Locale;
+        deanonymize: boolean;
+        fallbackImage: string | false;
+        isEmbedded: boolean;
+        showAutoflows: number | boolean;
+        showCustomMessages: number | boolean;
+        showImages: boolean;
+        showPersonalCollectionLink: boolean;
+        showSearch: boolean;
+        showImageSearch: boolean;
+        showStyleSuggestions: number | boolean;
+        showMidSentenceSuggestions: boolean;
+        showSuggestionsBeforePattern: string | false;
+        showSuggestionsAfterPattern: string | false;
+        showTabCompletion: boolean;
+        showTextSuggestions: boolean;
+        showEntitiesCommand: boolean;
+        showSummaryCommand: boolean;
+        showKnowledgeSearch: boolean;
+        textSuggestionsCount: number;
+        recommendTextSuggestions: boolean;
+        searchTriggerKey: string;
+        visible: boolean;
+        insertLink: boolean;
+        inlineSuggestions: boolean;
+        adminUrl?: string | undefined;
+    };
+    profile: State$4;
+    search: State$3;
+    summary: State$2;
+    styleSuggestions: State$1;
+    ui: {
+        showTabHint: boolean;
+        inputHasFocus: boolean;
+        overlayCollapsed: boolean;
+        openOverlayWhenTyping: boolean;
+        overlayCollapsedUserOverwrite: boolean;
+    };
+    textSuggestions: TextSuggestionState;
+}, redux.AnyAction, _reduxjs_toolkit.ThunkMiddleware<redux.CombinedState<{
+    activeSuggestion: State$e;
+    answer: State$6;
+    auth: State$d;
+    autoflows: State$c;
+    conversation: State$b;
+    contentTypes: State$a;
+    customMessages: State$9;
+    exchangeToken: State$8;
+    entities: State$7;
+    handlingTime: State$f;
+    info: {
+        agentInfo?: AgentInfo | undefined;
+        agentSettings: unknown;
+        visitorInfo?: VisitorInfo | undefined;
+        fetchState: FetchState;
+    };
+    input: State$5;
+    overlayInput: State$5;
+    settings: {
+        locale: Locale;
+        deanonymize: boolean;
+        fallbackImage: string | false;
+        isEmbedded: boolean;
+        showAutoflows: number | boolean;
+        showCustomMessages: number | boolean;
+        showImages: boolean;
+        showPersonalCollectionLink: boolean;
+        showSearch: boolean;
+        showImageSearch: boolean;
+        showStyleSuggestions: number | boolean;
+        showMidSentenceSuggestions: boolean;
+        showSuggestionsBeforePattern: string | false;
+        showSuggestionsAfterPattern: string | false;
+        showTabCompletion: boolean;
+        showTextSuggestions: boolean;
+        showEntitiesCommand: boolean;
+        showSummaryCommand: boolean;
+        showKnowledgeSearch: boolean;
+        textSuggestionsCount: number;
+        recommendTextSuggestions: boolean;
+        searchTriggerKey: string;
+        visible: boolean;
+        insertLink: boolean;
+        inlineSuggestions: boolean;
+        adminUrl?: string | undefined;
+    };
+    profile: State$4;
+    search: State$3;
+    summary: State$2;
+    styleSuggestions: State$1;
+    ui: {
+        showTabHint: boolean;
+        inputHasFocus: boolean;
+        overlayCollapsed: boolean;
+        openOverlayWhenTyping: boolean;
+        overlayCollapsedUserOverwrite: boolean;
+    };
+    textSuggestions: TextSuggestionState;
+}>, redux.AnyAction, {
+    dynamicThunkObject: Record<string, unknown> | undefined;
+    deepdeskAPI: DeepdeskAPI;
+    deepdeskBrokerAPI: DeepdeskBrokerAPI | undefined;
+}>[]>;
+type Store = ReturnType<typeof createStore>;
+
+interface State$d {
+    isLoggedIn: boolean | null;
+    loginFetchState: FetchState;
+    verifyFetchState: FetchState;
+    showLoginOverlay: boolean;
+}
+
+type Autoflow = CamelCaseKeys<Server$1.Autoflow> & {
+    isBusy?: boolean;
+};
+interface State$c {
+    list: Autoflow[];
+    fetchState: FetchState;
+    isInitialRequest: null | boolean;
+}
+
+interface State$b {
+    current: Conversation | null;
+    isSupported: boolean | null;
+}
+
+type ContentType = CamelCaseKeys<Server.ContentType>;
+type State$a = {
+    data: ContentType[] | null;
+    fetchState: FetchState;
+};
+
+type CustomMessage = CamelCaseKeys<Server$1.CustomMessage>;
+interface State$9 {
+    list: CustomMessage[];
+    fetchState: FetchState;
+    isInitialRequest: null | boolean;
+    sentSuggestions: string[];
+    errorSuggestions: string[];
+    answeredSuggestions: string[];
+}
+
+type State$8 = {
+    jwt: string | null;
+    accountUrl: string | null;
+    interval: NodeJS.Timer | null;
+};
+
+type State$7 = {
+    data: Entity[] | null;
+    fetchState: FetchState;
+};
+
+interface ListItemSource {
+    url?: string;
+    name: string;
+}
+
+interface KnowledgeAnswer {
+    answer: string;
+    timestamp: string;
+    sources: ListItemSource[];
+}
+interface KnowledgeRequest {
+    question: string;
+    answer: KnowledgeAnswer;
+}
+type State$6 = {
+    data: KnowledgeRequest[];
+    fetchState: FetchState;
+};
+
+declare namespace Server {
+    /**
+     * API create conversation payload
+     */
+    type CreateConversationPayload = {
+        platform: string;
+        session_id: string;
+        agent_id: string;
+        profile_code?: string;
+        tags?: Record<string, string> | null;
+        agent_name?: string;
+        agent_nickname?: string;
+        agent_email?: string;
+    };
+    /**
+     * API message object
+     */
+    type ConversationMessage = {
+        id: string;
+        time: string;
+        source: 'agent' | 'visitor' | 'bot' | 'system';
+        author_id: string;
+        author_name?: string;
+        author_email?: string;
+        text: string;
+        tags: Record<string, string> | null;
+    };
+    /**
+     * API conversation object
+     */
+    type Conversation = {
+        id: string;
+        profile_code: string | null;
+        channel: string | null;
+        platform: string;
+        agent_id: string;
+        agent_name: string | null;
+        agent_nickname: string | null;
+        agent_email: string | null;
+        agent_role: string | null;
+        engagement_type: string | null;
+        engagement_id: string | null;
+        engagement_name: string | null;
+        engagement_skill: string | null;
+        agent_note: string | null;
+        survey_email: string | null;
+        survey_name: string | null;
+        survey_phone: string | null;
+        visitor_id: string | null;
+        visitor_name: string | null;
+        visitor_device: string | null;
+        visitor_browser: string | null;
+        visitor_os: string | null;
+        visitor_country: string | null;
+        visitor_state: string | null;
+        visitor_city: string | null;
+        visitor_isp: string | null;
+        visitor_organization: string | null;
+        visitor_ip_address: string | null;
+        chat_start_time: number | null;
+        session_start_time: number | null;
+        visit_start_time: string | null;
+        session_id: string;
+        messages: ConversationMessage[];
+        tags: Record<string, string> | null;
+        has_active_profile: boolean;
+        created: string;
+        updated: string;
+    };
+    /**
+     * API object for url suggestion
+     */
+    type UrlSuggestion = {
+        id?: string;
+        score: number;
+        url: string;
+        context?: string;
+        image: string;
+        summary?: string;
+        title?: string;
+        image_sizes?: {
+            small: string;
+            medium: string;
+            large: string;
+        };
+    };
+    /**
+     * API object for platform config
+     */
+    type PlatformConfig = {
+        config: {
+            account: {
+                code: string;
+                name: string;
+                url: string;
+                is_trial: boolean;
+            };
+            platform: {
+                name: string;
+                url: string;
+                has_sso: boolean;
+                authorization_url: string;
+                client_config: unknown;
+            };
+        };
+    };
+    /**
+     * API object for free suggestion
+     */
+    type RecommendFreeSuggestion = {
+        score?: number;
+        title?: string;
+        text: string;
+        message?: string;
+        url?: string;
+        ab_variant?: string;
+        ab_test_name?: string;
+        training_jobs?: string[];
+        source_text: string;
+    };
+    type ContentType = {
+        id: number;
+        code: string;
+        name: string;
+        description: string;
+    };
+    /**
+     * API object for autocomplete suggestion
+     */
+    type AutocompleteSuggestion = {
+        label: string;
+        source: string;
+        value: string;
+        training_jobs: string[];
+        source_text: string;
+        search_keywords?: string[];
+    };
+    /**
+     * API object for pinned message
+     */
+    type PinnedMessage = {
+        message: string;
+        title: string;
+        image: string;
+        image_sizes?: {
+            small: string;
+            medium: string;
+            large: string;
+        };
+    };
+    /**
+     * API object for style suggestions
+     */
+    type StyleSuggestion = {
+        keyword_matches: {
+            keyword: string;
+            suggestion: string;
+        }[];
+    };
+    declare enum EventType {
+        SEND_MESSAGE = "Send Message",
+        HANDLING_TIME = "Handling Time",
+        START_AUTOFLOW = "Start Autoflow",
+        ABORT_AUTOFLOW = "Abort Autoflow",
+        ADD_TO_PERSONAL_COLLECTION = "Add to personal collection",
+        DELETE_FROM_PERSONAL_COLLECTION = "Delete from personal collection"
+    }
+    type UsedSuggestion = {
+        ab_test_name?: string | null;
+        ab_variant?: string | null;
+        input_type: string;
+        source?: string;
+        source_text?: string;
+        text: string;
+        training_jobs?: string[];
+    };
+    /**
+     * Abstract API object for event data
+     * @deprecated in favor of EventDataV2
+     * @see EventV2Data
+     */
+    type EventData = {
+        conversation_id: string;
+        client_version: string;
+        source: 'agent' | 'visitor';
+        pastes: string[];
+        cuts: string[];
+        deletions: string[];
+        len_text_typed: number;
+        len_text_total: number;
+        len_text_assisted: number;
+        len_text_pasted: number;
+        len_text_cut: number;
+        len_text_deleted: number;
+        time_total_seconds: number;
+        chars_per_second: number;
+        text: string;
+        num_pastes: number;
+        text_suggestions_v2: UsedSuggestion[];
+        url_suggestions_v2: UsedSuggestion[];
+        url_link_suggestions_v2: UsedSuggestion[];
+        suggestions_counters: {
+            source: Sources;
+            count_offered: number;
+        }[];
+        time_start: string;
+        time_stop: string;
+        agent_id?: string;
+        agent_name?: string;
+        agent_email?: string;
+        platform: string;
+        backend_version: string;
+        engine_version: string;
+        gpt_version: string;
+    };
+    /**
+     * Backend API object for event data v2
+     */
+    type EventV2Data = {
+        name: string;
+        conversation_id?: string;
+        agent_id?: string;
+        agent_name?: string;
+        agent_email?: string;
+        data: unknown;
+        backend_version?: string;
+        engine_version?: string;
+        gpt_version?: string;
+    };
+    interface GetTextSuggestionsParams {
+        timezone?: string;
+        agent_name?: string;
+        visitor_name?: string;
+    }
+    interface GetAutocompleteSuggestionsParams extends GetTextSuggestionsParams {
+        input: string;
+    }
+    interface GetStyleSuggestionsParams {
+        message: string;
+        profile_code: string;
+    }
+    /**
+     * Handling time event data
+     */
+    type HandlingTimeEventData = Pick<EventData, 'conversation_id' | 'client_version' | 'time_start' | 'time_stop'> & Partial<Pick<EventData, 'agent_id' | 'agent_name' | 'agent_email'>>;
+    /**
+     * Send message event data
+     */
+    type SendMessageEventData = Pick<EventData, 'client_version' | 'conversation_id' | 'source' | 'pastes' | 'cuts' | 'deletions' | 'len_text_typed' | 'len_text_total' | 'len_text_assisted' | 'len_text_pasted' | 'len_text_cut' | 'len_text_deleted' | 'time_total_seconds' | 'chars_per_second' | 'num_pastes' | 'text' | 'text_suggestions_v2' | 'suggestions_counters'> & Partial<Pick<EventData, 'agent_id' | 'agent_name' | 'agent_email'>>;
+    /**
+     * Autoflow event data
+     */
+    type AutoflowEventData = Pick<EventData, 'conversation_id' | 'source'> & {
+        text_suggestions_v2: {
+            source: string;
+        }[];
+    };
+    /**
+     * PersonalCollection event data
+     */
+    type PersonalCollectionEventData = Pick<EventData, 'text' | 'platform'>;
+    /**
+     * Search results data
+     */
+    interface SearchResult {
+        id: string;
+        image: string;
+        labels: string;
+        status: string;
+        text: string;
+        title?: string;
+        type: SearchResultType;
+    }
+    type SearchResultsData = {
+        results: SearchResult[];
+    };
+    /**
+     * Me
+     */
+    type Me = {
+        user_email: string;
+        user_name: string;
+    };
+    /**
+     * A Deepdesk user
+     */
+    type User = {
+        username: string;
+        external_id: string;
+        email?: string;
+        nickname?: string;
+        first_name?: string;
+        last_name?: string;
+    };
+    /**
+     * Profile
+     */
+    type Profile = {
+        code: string;
+        name: string;
+        search: boolean;
+        image_search: boolean;
+        sticky_messages: boolean;
+        custom_messages: boolean;
+        autoflows: boolean;
+        recommend_text_suggestions: boolean;
+        assisted_intake: boolean;
+        autocomplete_with_text_suggestions: boolean;
+        entities_command: boolean;
+        summarizer: boolean;
+        knowledge_search: boolean;
+        ui_config: {
+            widget: {
+                types: Array<{
+                    is_active: boolean;
+                    type: string;
+                    title: string;
+                    amount: number;
+                    lines: 'multiple' | 'single';
+                }>;
+            };
+        };
+    };
+    type ChatHistory = {
+        question: string;
+        answer: string;
+        timestamp: string;
+    };
+}
+type ConversationMessage = CamelCaseKeys<Omit<Server.ConversationMessage, 'tags'>> & {
+    tags: Record<string, string> | null;
+};
+type Conversation = CamelCaseKeys<Omit<Server.Conversation, 'tags' | 'messages'>> & {
+    tags: Record<string, string> | null;
+} & {
+    messages: ConversationMessage[];
+};
+/**
+ * Create Conversation Options
+ */
+type CreateConversationOptions = {
+    /**
+     * The platform's conversation ID.
+     */
+    sessionId: string;
+    /**
+     * The agent ID
+     */
+    agentId: string;
+    /**
+     * The messaging platform, e.g. 'liveengage'
+     */
+    platform: string;
+    /**
+     * The client profile code, e.g. 'b2b' or 'b2c'
+     */
+    profileCode?: string;
+    tags?: Record<string, string> | null;
+    agentName?: string;
+    agentNickname?: string;
+    agentEmail?: string;
+};
+/**
+ * Send message event data
+ */
+type SendMessageEventData$1 = CamelCaseKeys<Server.SendMessageEventData>;
+/**
+ * Event v2 payload
+ */
+type EventV2Payload = CamelCaseKeys<Omit<Server.EventV2Data, 'name' | 'backend_version' | 'engine_version' | 'gpt_version'>>;
+/**
+ * Handling time event data
+ */
+type HandlingTimeEventData = CamelCaseKeys<Pick<Server.HandlingTimeEventData, 'conversation_id' | 'client_version' | 'time_start' | 'time_stop'>>;
+/**
+ * Autoflow event data
+ */
+type AutoflowEventData = CamelCaseKeys<Server.AutoflowEventData>;
+/**
+ * Personal collection event data
+ */
+type PersonalCollectionEventData = CamelCaseKeys<Server.PersonalCollectionEventData>;
+/**
+ * Send event arguments helper
+ */
+type SendEventArgumentMap = {
+    'Send Message': SendMessageEventData$1;
+    'Handling Time': HandlingTimeEventData;
+    'Start Autoflow': AutoflowEventData;
+    'Abort Autoflow': AutoflowEventData;
+    'Add to personal collection': PersonalCollectionEventData;
+    'Delete from personal collection': PersonalCollectionEventData;
+    'entities found': EventV2Payload;
+    'conversation summarized': EventV2Payload;
+    'style suggested': EventV2Payload;
+    'suggestion edited': EventV2Payload;
+    'Image attached': EventV2Payload;
+};
+/**
+ * Request retry options
+ */
+type RetryOptions = {
+    attempts?: number;
+    retryDelay?: number;
+};
+interface SearchOptions {
+    filters: {
+        type?: SearchResultType;
+    };
+    query: string;
+    profile: string;
+    tags?: string[];
+    params: {
+        agentName?: string;
+        visitorName?: string;
+        timezone?: string;
+    };
+}
+interface DeepdeskAPIOptions extends HTTPClientOptions {
+    token?: string;
+}
+declare class DeepdeskAPI {
+    options: DeepdeskAPIOptions;
+    private latestReceivedDeepdeskVersions;
+    client: HTTPClient;
+    account: string;
+    shouldFetchCsrfToken: boolean;
+    static exchangeTokenPromise: Promise<void> | null;
+    private preflight;
+    constructor(apiUrl: string, options?: DeepdeskAPIOptions);
+    createConversation(options: CreateConversationOptions): Promise<CamelCaseKeys<Server.Conversation>>;
+    getProfile(profileCode: string): Promise<CamelCaseKeys<Server.Profile>>;
+    getContentTypes(): Promise<CamelCaseKeys<Server.ContentType[]>>;
+    getPlatformConfig(): Promise<CamelCaseKeys<Server.PlatformConfig['config']>>;
+    checkUserExists(externalId: string): Promise<boolean>;
+    getConversationBySessionId(sessionId: string, options?: RetryOptions): Promise<CamelCaseKeys<Server.Conversation>>;
+    isConversationSupported(sessionId: string, options?: RetryOptions): Promise<boolean>;
+    /**
+     * Update converstation meta data
+     */
+    updateConversation(conversationId: string, data: Partial<Conversation>): Promise<Conversation>;
+    /**
+     * Post converstation messages
+     */
+    postMessages(conversationId: string, messages: CamelCaseKeys<Server.ConversationMessage>[]): Promise<({
+        text: string;
+        id: string;
+        time: string;
+        source: "agent" | "visitor" | "bot" | "system";
+        authorId: string;
+        authorName?: string | undefined;
+        authorEmail?: string | undefined;
+    } & {
+        tags: Record<string, string> | null;
+    })[]>;
+    /**
+     * Send event with meta data for analytics
+     */
+    sendEvent<T extends keyof SendEventArgumentMap>(event: T, payload: SendEventArgumentMap[T]): Promise<void>;
+    /**
+     * Send event with meta data for analytics
+     * @deprecated
+     */
+    sendEventV1<T extends keyof SendEventArgumentMap>(event: T, payload: SendEventArgumentMap[T]): Promise<void>;
+    getEntities(messages: Array<{
+        text: string;
+    }>): Promise<Entity[]>;
+    getSummary(messages: Array<{
+        source: string;
+        text: string;
+    }>): Promise<string>;
+    /**
+     * Get a temporary exchange / login token
+     */
+    getTemporaryExchangeToken(): Promise<string>;
+    /**
+     * Exchange a temporary token for a access token cookie
+     */
+    exchangeTokenForAccessCookie(token: string): Promise<void>;
+    authenticateWithKey(key: string, user: CamelCaseKeys<Server.User>): Promise<void>;
+    /**
+     * Request text suggestions based on the current conversation
+     */
+    getTextSuggestions(conversationId: string, params: {
+        timezone?: string | undefined;
+        agentName?: string | undefined;
+        visitorName?: string | undefined;
+    } | undefined, contentType: string): Promise<TextSuggestion[]>;
+    /**
+     * Validate authentication
+     */
+    isLoggedIn(): Promise<boolean>;
+    /**
+     * Request autocomplete suggestions based on the agent text input
+     */
+    getAutocompleteSuggestions(conversationId: string, params: CamelCaseKeys<Server.GetAutocompleteSuggestionsParams>): Promise<TextSuggestion[]>;
+    /**
+     * Request pinned messages
+     */
+    getPinnedMessages(conversationId: string): Promise<CamelCaseKeys<Server.PinnedMessage[]>>;
+    /**
+     * Request style suggestions
+     */
+    getStyleSuggestions(params: CamelCaseKeys<Server.GetStyleSuggestionsParams>): Promise<CamelCaseKeys<Server.StyleSuggestion>>;
+    /**
+     * Search
+     */
+    search(params: SearchOptions): Promise<CamelCaseKeys<Server.SearchResultsData>>;
+    knowledgeSearch(question: string, chatHistory: KnowledgeRequest[], profile?: string): Promise<CamelCaseKeys<KnowledgeAnswer>>;
+    requestLoginByEmail(email: string): Promise<{
+        code: string;
+        message: string;
+    }>;
+    getCsrfToken(): Promise<string>;
+    verifyLoginToken(token: string): Promise<{
+        isLoggedIn: boolean;
+    }>;
+    private handleDeepdeskVersionHeaders;
+}
+
+declare const styles$l: {
+  readonly "isDisabled": string;
+  readonly "buttonStart": string;
+  readonly "root": string;
+  readonly "buttonStop": string;
+  readonly "stateBadge": string;
+  readonly "isCompleted": string;
+  readonly "isStarted": string;
+  readonly "isAborted": string;
+};
+
+type AutoflowStyles = typeof styles$l;
+
+declare const styles$k: {
+  readonly "root": string;
+  readonly "imageWrapper": string;
+  readonly "image": string;
+  readonly "content": string;
+  readonly "title": string;
+  readonly "contentIsCropped": string;
+  readonly "lineClamp": string;
+};
+
+type ImageProps = {
+    title?: string;
+    src?: string | null;
+};
+type ContentProps = {
+    cropText?: boolean;
+    className?: string;
+    lineClamp?: boolean;
+};
+type TitleProps = {
+    cropText?: boolean;
+    className?: string;
+    as?: string;
+};
+interface CardComposition {
+    Image: FC<ImageProps>;
+    Content: FC<ContentProps>;
+    Title: FC<TitleProps>;
+}
+type CardStyles = typeof styles$k;
+declare const Card: FC & CardComposition;
+
+declare const styles$j: {
+  readonly "root": string;
+  readonly "list": string;
+  readonly "listWrapper": string;
+  readonly "listHorizontal": string;
+  readonly "page": string;
+  readonly "search": string;
+  readonly "pageNav": string;
+  readonly "pageBackButton": string;
+  readonly "listHeading": string;
+  readonly "listItem": string;
+  readonly "listItemContent": string;
+  readonly "listItemText": string;
+  readonly "listItemDescription": string;
+  readonly "truncate": string;
+  readonly "lineClamp": string;
+  readonly "listItemTitle": string;
+  readonly "listItemAction": string;
+  readonly "listItemPrimaryAction": string;
+  readonly "listItemSelected": string;
+  readonly "sources": string;
+  readonly "sourcesTitle": string;
+  readonly "source": string;
+  readonly "icon": string;
+  readonly "searchIcon": string;
+  readonly "searchInputWrapper": string;
+  readonly "searchInput": string;
+  readonly "select": string;
+  readonly "selectType": string;
+  readonly "selectWrapper": string;
+  readonly "image": string;
+  readonly "imageSrc": string;
+  readonly "imageTitle": string;
+  readonly "actions": string;
+  readonly "actionsWrapper": string;
+  readonly "actionsBar": string;
+  readonly "actionButton": string;
+  readonly "actionShortcut": string;
+  readonly "actionShortcutFixKerning": string;
+};
+
+type CommandPaletteStyles = typeof styles$j;
+
+declare const styles$i: {
+  readonly "root": string;
+  readonly "content": string;
+};
+
+type DialogStyles = typeof styles$i;
+
+declare const styles$h: {
+  readonly "root": string;
+  readonly "title": string;
+  readonly "empty": string;
+};
+
+type EntitiesListStyles = typeof styles$h;
+
+declare const styles$g: {
+  readonly "root": string;
+  readonly "isArrowUp": string;
+  readonly "isArrowDown": string;
+  readonly "isTab": string;
+  readonly "isEsc": string;
+  readonly "isEnter": string;
+};
+
+declare enum KeyboardHintKey {
+    ARROW_UP = "arrow-up",
+    ARROW_DOWN = "arrow-down",
+    TAB = "tab",
+    ESC = "esc",
+    ENTER = "enter"
+}
+type Props$7 = HTMLAttributes<HTMLSpanElement> & {
+    className?: string;
+    keyCode: KeyboardHintKey;
+};
+type KeyboardHintStyles = typeof styles$g;
+declare const KeyboardHint: React.FC<Props$7>;
+
+declare const styles$f: {
+  readonly "root": string;
+};
+
+type Props$6 = HTMLAttributes<HTMLSpanElement>;
+type LabelStyles = typeof styles$f;
+declare const Label: React.FC<Props$6>;
+
+declare const styles$e: {
+  readonly "root": string;
+  readonly "content": string;
+};
+
+type LinkSearchStyles = typeof styles$e;
+
+declare const styles$d: {
+  readonly "root": string;
+  readonly "anchor": string;
+  readonly "anchorButton": string;
+};
+
+type LoginStyles = typeof styles$d;
+
+declare const styles$c: {
+  readonly "root": string;
+  readonly "anchorButton": string;
+  readonly "errorMessage": string;
+  readonly "title": string;
+  readonly "subtitle": string;
+  readonly "text": string;
+  readonly "input": string;
+  readonly "actions": string;
+  readonly "button": string;
+  readonly "primaryButton": string;
+};
+
+type LoginTokenDialogStyles = typeof styles$c;
+
+declare const styles$b: {
+  readonly "root": string;
+  readonly "text": string;
+};
+
+type SearchTriggerStyles = typeof styles$b;
+
+declare const styles$a: {
+  readonly "root": string;
+};
+
+type Props$5 = {
+    className?: string;
+    children?: React.ReactNode;
+};
+type SectionListStyles = typeof styles$a;
+declare const SectionList: React.ForwardRefExoticComponent<Props$5 & React.RefAttributes<HTMLDivElement>>;
+
+declare const styles$9: {
+  readonly "root": string;
+  readonly "subTitleContainer": string;
+  readonly "subtitle": string;
+  readonly "suggestions": string;
+};
+
+type Props$4 = HTMLAttributes<HTMLElement> & {
+    title?: string;
+};
+type SectionStyles = typeof styles$9;
+declare const Section: React.FC<Props$4>;
+
+declare const styles$8: {
+  readonly "root": string;
+  readonly "isWithDivider": string;
+};
+
+type SuggestionListStyles = typeof styles$8;
+interface Props$3 {
+    withDivider?: boolean;
+}
+declare const SuggestionList: React.FC<Props$3>;
+
+declare const styles$7: {
+  readonly "root": string;
+  readonly "isInline": string;
+  readonly "toggleButton": string;
+  readonly "toggleButtonWrapper": string;
+  readonly "toggleButtonWrapperHidden": string;
+  readonly "isCollapsed": string;
+  readonly "collapsible": string;
+  readonly "hints": string;
+  readonly "hintsHidden": string;
+  readonly "triggers": string;
+  readonly "triggersRight": string;
+};
+
+type SuggestionsOverlayStyles = typeof styles$7;
+
+declare const styles$6: {
+  readonly "root": string;
+  readonly "fadein": string;
+  readonly "isClickable": string;
+  readonly "isSelected": string;
+  readonly "actions": string;
+  readonly "actionsIsFixed": string;
+  readonly "actionButton": string;
+  readonly "dropdownList": string;
+  readonly "dropdownButton": string;
+  readonly "dropdownItem": string;
+  readonly "dropdownItemButton": string;
+  readonly "actionButtonIsPrimary": string;
+  readonly "actionButtonIsDisabled": string;
+  readonly "labels": string;
+  readonly "label": string;
+};
+
+interface ActionsProps extends HTMLAttributes<HTMLElement> {
+    fixed?: boolean;
+}
+interface ActionButtonProps extends HTMLAttributes<HTMLElement> {
+    primary?: boolean;
+    disabled?: boolean;
+    label: ReactNode;
+}
+interface DropdownItemProps extends HTMLAttributes<HTMLElement> {
+    index: number;
+    label: ReactNode;
+    onClick?(event: SyntheticEvent<any>): void;
+}
+interface LabelProps {
+    labels: string[];
+}
+type Props$2 = HTMLAttributes<HTMLElement> & {
+    selected?: boolean;
+    as?: 'div' | 'button';
+};
+interface SuggestionComposition {
+    Actions: FC<ActionsProps>;
+    ActionButton: FC<ActionButtonProps>;
+    DropdownButton: FC<ActionButtonProps>;
+    DropdownItem: FC<DropdownItemProps>;
+    Labels: FC<LabelProps>;
+}
+type SuggestionStyles = typeof styles$6;
+declare const Suggestion: ForwardRefExoticComponent<Props$2 & RefAttributes<any>> & SuggestionComposition;
+
+declare const styles$5: {
+  readonly "root": string;
+  readonly "agentText": string;
+  readonly "tabText": string;
+  readonly "hint": string;
+  readonly "matchSelection": string;
+  readonly "focus": string;
+  readonly "resetIndent": string;
+  readonly "matchKeyword": string;
+  readonly "matchPlaceholder": string;
+  readonly "hover": string;
+  readonly "hintText": string;
+  readonly "popover": string;
+  readonly "popoverRoot": string;
+  readonly "popoverContentContainer": string;
+  readonly "popoverContent": string;
+  readonly "selectionOptions": string;
+  readonly "selectionOptionsIsHidden": string;
+  readonly "selectionOptionsButton": string;
+  readonly "caret": string;
+  readonly "popoverSuggestionsRoot": string;
+  readonly "suggestionsOverlayInputStyles": string;
+};
+
+type TabCompletionStyles = typeof styles$5;
+
+declare const styles$4: {
+  readonly "root": string;
+  readonly "content": string;
+  readonly "title": string;
+  readonly "actions": string;
+  readonly "pagination": string;
+  readonly "primaryButton": string;
+  readonly "primaryButtons": string;
+};
+
+type EditSuggestionFormStyles = typeof styles$4;
+
+declare const styles$3: {
+  readonly "badge": string;
+  readonly "formattedText": string;
+};
+
+type TextSuggestionStyles = typeof styles$3;
+
+declare const styles$2: {
+  readonly "root": string;
+  readonly "isCollapsed": string;
+};
+
+type Props$1 = HTMLAttributes<HTMLButtonElement> & {
+    isCollapsed: boolean;
+    title: string;
+};
+type ToggleButtonStyles = typeof styles$2;
+declare const ToggleButton: React.FC<Props$1>;
+
+declare const styles$1: {
+  readonly "root": string;
+  readonly "loginText": string;
+  readonly "stateText": string;
+  readonly "sectionList": string;
+  readonly "links": string;
+  readonly "link": string;
+};
+
+type WidgetStyles = typeof styles$1;
+
+declare const styles: {
+  readonly "root": string;
+};
+
+interface Props {
+    children: React.ReactNode;
+}
+type ChipStyles = typeof styles;
+declare const Chip: React.FC<Props>;
+
+type WidgetCustomStyles = {
+    Autoflow?: Partial<AutoflowStyles>;
+    Card?: Partial<CardStyles>;
+    Dialog?: Partial<DialogStyles>;
+    KeyboardHint?: Partial<KeyboardHintStyles>;
+    Label?: Partial<LabelStyles>;
+    LinkSearch?: Partial<LinkSearchStyles>;
+    Login?: Partial<LoginStyles>;
+    Section?: Partial<SectionStyles>;
+    SectionList?: Partial<SectionListStyles>;
+    Suggestion?: Partial<SuggestionStyles>;
+    SuggestionList?: Partial<SuggestionListStyles>;
+    EditSuggestionForm?: Partial<EditSuggestionFormStyles>;
+    Widget?: Partial<WidgetStyles>;
+};
+type InputOverlayCustomStyles = {
+    CommandPalette?: Partial<CommandPaletteStyles>;
+    Chip?: Partial<ChipStyles>;
+    EntitiesList?: Partial<EntitiesListStyles>;
+    Label?: Partial<LabelStyles>;
+    Login?: Partial<LoginStyles>;
+    LoginTokenDialog?: Partial<LoginTokenDialogStyles>;
+    SearchTrigger?: Partial<SearchTriggerStyles>;
+    Suggestion?: Partial<SuggestionStyles>;
+    SuggestionList?: Partial<SuggestionListStyles>;
+    SuggestionsOverlay?: Partial<SuggestionsOverlayStyles>;
+    TextSuggestion?: Partial<TextSuggestionStyles>;
+    ToggleButton?: Partial<ToggleButtonStyles>;
+    KeyboardHint?: Partial<KeyboardHintStyles>;
+    TabCompletion?: Partial<TabCompletionStyles>;
+};
+declare enum Locale {
+    NL_NL = "nl-NL",
+    EN_US = "en-US"
+}
+interface SuggestionApiMetrics {
+    source?: string;
+    score?: number;
+    abVariant?: string;
+    abTestName?: string;
+    sourceText?: string;
+    trainingJobs?: string[];
+}
+interface TextSuggestion extends SuggestionApiMetrics {
+    id?: string;
+    text: string;
+    url?: string;
+    title?: string;
+    sourceLabel?: string;
+    type?: string;
+    searchKeywords?: string[];
+    image?: string;
+    message?: string;
+    imageSizes?: {
+        small: string;
+        medium: string;
+        large: string;
+    };
+}
+interface PinnedMessage extends SuggestionApiMetrics {
+    title: string;
+    message: string;
+    image: string;
+    imageSizes?: {
+        small: string;
+        medium: string;
+        large: string;
+    };
+}
+interface UrlSuggestion extends SuggestionApiMetrics {
+    id?: string;
+    url: string;
+    context?: string;
+    image: string;
+    summary?: string;
+    title?: string;
+    imageSizes?: {
+        small: string;
+        medium: string;
+        large: string;
+    };
+}
+interface SearchSuggestion extends SuggestionApiMetrics {
+    id?: string;
+    text: string;
+    title?: string;
+    context?: string;
+    image?: string;
+    type?: SearchResultType;
+}
+interface SuggestionEventMetrics {
+    inputType: InputType;
+}
+interface SuggestionMetrics extends SuggestionApiMetrics, SuggestionEventMetrics {
+    text: string;
+    searchTerm?: string | null;
+}
+type VisitorInfo = {
+    visitorId?: string;
+    visitorName?: string;
+    visitorTimeZone?: string;
+    psid?: string;
+};
+type AgentInfo = {
+    agentId: string;
+    agentNickname: string;
+    agentName?: string;
+    agentEmail?: string;
+    agentTimeZone?: string;
+};
+type User = CamelCaseKeys<Server.User>;
+type SendMessageEventData = CamelCaseKeys<Server.SendMessageEventData>;
+type Profile = CamelCaseKeys<Server.Profile>;
+
+type CreateConversation = {
+    platform: string;
+    sessionId: string;
+    profileCode?: string;
+    agentId: string;
+    agentName?: string;
+    agentNickname?: string;
+    agentEmail?: string;
+    tags?: Record<string, string> | null;
+};
+interface Entity {
+    text: string;
+    label: string;
+}
+/**
+ * Utils
+ */
+type Logger = {
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+};
+declare enum FetchState {
+    IDLE = "idle",
+    LOADING = "loading",
+    DONE = "done",
+    ERROR = "error"
+}
+
+type KeyboardMetric = Pick<KeyboardEvent, 'key' | 'shiftKey' | 'ctrlKey' | 'altKey' | 'metaKey'>;
+type StageSuggestion = {
+    text: string;
+    suggestion: TextSuggestion;
+    eventMetrics: SuggestionEventMetrics;
+    replace: 'selection' | 'until-selection-end';
+};
+type EditTextSuggestionPayload = {
+    contentType: string;
+    index: number | null;
+    suggestions: TextSuggestion[];
+};
+type MetricState = {
+    numCharsTyped: number;
+    numCharsPasted: number;
+    numCharsCut: number;
+    numCharsDeleted: number;
+    numPaste: number;
+    agentStartedTypingTimestamp: number | null;
+    pastes: any[];
+    deletions: any[];
+    offeredTextSuggestions: TextSuggestion[];
+    textSuggestions: SuggestionMetrics[];
+    cuts: any[];
+};
+type State$5 = {
+    text: string;
+    html: string | null;
+    selection: SelectionRange;
+    stagedSuggestion: StageSuggestion | null;
+    userCommitted: {
+        text: string;
+        selection: SelectionRange;
+    };
+    tabCompletionSuggestion?: TextSuggestion;
+    metrics: MetricState;
+    previousKeyDownEvent: KeyboardMetric | null;
+    textSuggestions: TextSuggestion[];
+    selectedSuggestionIndex: number;
+};
+
+type State$4 = {
+    data: Profile | null;
+    fetchState: FetchState;
+};
+
+type SearchResultType = string | SearchResultDefaultType;
+declare enum SearchResultDefaultType {
+    url = "URL",
+    personal = "PERSONAL",
+    pinned = "STICKYMESSAGE",
+    image = "IMAGE"
+}
+type SearchResult = SearchSuggestion;
+interface State$3 {
+    list: Array<SearchResult>;
+    fetchState: FetchState;
+    isOpen: boolean;
+}
+
+type State$2 = {
+    data: string | null;
+    fetchState: FetchState;
+};
+
+type StyleSuggestion = CamelCaseKeys<Server.StyleSuggestion>;
+interface State$1 {
+    list: StyleSuggestion;
+    fetchState: FetchState;
+    isInitialRequest: null | boolean;
+}
+
+type SuggestionState = {
+    suggestions: TextSuggestion[];
+    fetchState: FetchState;
+    isInitialRequest: null | boolean;
+};
+interface TextSuggestionState {
+    [type: string]: SuggestionState;
+}
+
+type State = {
+    locale: Locale;
+    deanonymize: boolean;
+    fallbackImage: string | false;
+    isEmbedded: boolean;
+    showAutoflows: boolean | number;
+    showCustomMessages: boolean | number;
+    showImages: boolean;
+    showPersonalCollectionLink: boolean;
+    showSearch: boolean;
+    showImageSearch: boolean;
+    showStyleSuggestions: boolean | number;
+    showMidSentenceSuggestions: boolean;
+    showSuggestionsBeforePattern: string | false;
+    showSuggestionsAfterPattern: string | false;
+    showTabCompletion: boolean;
+    showTextSuggestions: boolean;
+    showEntitiesCommand: boolean;
+    showSummaryCommand: boolean;
+    showKnowledgeSearch: boolean;
+    textSuggestionsCount: number;
+    recommendTextSuggestions: boolean;
+    searchTriggerKey: string;
+    visible: boolean;
+    insertLink: boolean;
+    inlineSuggestions: boolean;
+    adminUrl?: string;
+};
+declare const set: _reduxjs_toolkit.ActionCreatorWithPayload<Partial<State>, "settings/set">;
+
+declare global {
+    interface Window {
+        clipboardData: any;
+        __REDUX_DEVTOOLS_EXTENSION_COMPOSE__: any;
+    }
+}
+interface SDKOptions {
+    deepdeskUrl: string;
+    brokerUrl?: string;
+    version?: string;
+    locale?: Locale;
+    token?: string;
+    fetch?: typeof window.fetch;
+}
+interface SDKEventMap {
+    'select-suggestion': {
+        text: string;
+        type: string;
+        replace: SelectionRange;
+        suggestion: TextSuggestion;
+    };
+    'reset': {
+        text: string;
+        selectionAfter: SelectionRange;
+    };
+    'replace': {
+        text: string;
+        replace: SelectionRange;
+    };
+    'select-image': {
+        suggestion: TextSuggestion;
+    };
+    'edit-suggestion': EditTextSuggestionPayload;
+    'send-message': string;
+    'send-message-event': SendMessageEventData;
+    ready: undefined;
+    showSearchOverlay: boolean;
+}
+type SDKHandler<K extends keyof SDKEventMap> = (eventPayload: SDKEventMap[K]) => void;
+interface MountOptions {
+    customStyles?: InputOverlayCustomStyles & {
+        rootNode?: string;
+    };
+    closestScrollSelector?: string;
+    automaticHandlingTime?: boolean;
+    showStyleSuggestions?: boolean;
+    showTabCompletion?: boolean;
+    showTextSuggestions?: boolean;
+    showMidSentenceSuggestions?: boolean;
+    showSuggestionsBeforePattern?: string | false;
+    showSuggestionsAfterPattern?: string | false;
+    textSuggestionsCount?: number;
+    detectSubmit?: boolean;
+    insertLink?: boolean;
+    isEmbedded?: boolean;
+    /**
+     * By default append overlay to target.parentElement
+     * Optionally append to different HTMLElement, for example `document.body`
+     */
+    appendOverlayTo?: HTMLElement;
+    inputMediator?: InputMediator<HTMLElement>;
+    inlineSuggestions?: boolean;
+}
+interface WidgetOptions {
+    customStyles?: WidgetCustomStyles;
+    showImages?: boolean;
+    isEmbedded?: boolean;
+    showPersonalCollectionLink?: boolean;
+}
+declare class DeepdeskSDK {
+    static version: string;
+    static count: number;
+    private deepdeskApi;
+    private inputMediator;
+    private version;
+    private broadcastEvents;
+    private eventListeners;
+    private unmountHandlers;
+    private widgetRoot;
+    private dynamicThunkObject;
+    isMounted: boolean;
+    instanceId: number;
+    private shouldRender;
+    store: Store;
+    constructor({ deepdeskUrl, brokerUrl, version, locale, token, fetch, }: SDKOptions);
+    get state(): redux.EmptyObject & {
+        activeSuggestion: State$e;
+        answer: State$6;
+        auth: State$d;
+        autoflows: State$c;
+        conversation: State$b;
+        contentTypes: State$a;
+        customMessages: State$9;
+        exchangeToken: State$8;
+        entities: State$7;
+        handlingTime: State$f;
+        info: {
+            agentInfo?: AgentInfo | undefined;
+            agentSettings: unknown;
+            visitorInfo?: VisitorInfo | undefined;
+            fetchState: FetchState;
+        };
+        input: State$5;
+        overlayInput: State$5;
+        settings: {
+            locale: Locale;
+            deanonymize: boolean;
+            fallbackImage: string | false;
+            isEmbedded: boolean;
+            showAutoflows: number | boolean;
+            showCustomMessages: number | boolean;
+            showImages: boolean;
+            showPersonalCollectionLink: boolean;
+            showSearch: boolean;
+            showImageSearch: boolean;
+            showStyleSuggestions: number | boolean;
+            showMidSentenceSuggestions: boolean;
+            showSuggestionsBeforePattern: string | false;
+            showSuggestionsAfterPattern: string | false;
+            showTabCompletion: boolean;
+            showTextSuggestions: boolean;
+            showEntitiesCommand: boolean;
+            showSummaryCommand: boolean;
+            showKnowledgeSearch: boolean;
+            textSuggestionsCount: number;
+            recommendTextSuggestions: boolean;
+            searchTriggerKey: string;
+            visible: boolean;
+            insertLink: boolean;
+            inlineSuggestions: boolean;
+            adminUrl?: string | undefined;
+        };
+        profile: State$4;
+        search: State$3;
+        summary: State$2;
+        styleSuggestions: State$1;
+        ui: {
+            showTabHint: boolean;
+            inputHasFocus: boolean;
+            overlayCollapsed: boolean;
+            openOverlayWhenTyping: boolean;
+            overlayCollapsedUserOverwrite: boolean;
+        };
+        textSuggestions: TextSuggestionState;
+    };
+    get settings(): {
+        locale: Locale;
+        deanonymize: boolean;
+        fallbackImage: string | false;
+        isEmbedded: boolean;
+        showAutoflows: number | boolean;
+        showCustomMessages: number | boolean;
+        showImages: boolean;
+        showPersonalCollectionLink: boolean;
+        showSearch: boolean;
+        showImageSearch: boolean;
+        showStyleSuggestions: number | boolean;
+        showMidSentenceSuggestions: boolean;
+        showSuggestionsBeforePattern: string | false;
+        showSuggestionsAfterPattern: string | false;
+        showTabCompletion: boolean;
+        showTextSuggestions: boolean;
+        showEntitiesCommand: boolean;
+        showSummaryCommand: boolean;
+        showKnowledgeSearch: boolean;
+        textSuggestionsCount: number;
+        recommendTextSuggestions: boolean;
+        searchTriggerKey: string;
+        visible: boolean;
+        insertLink: boolean;
+        inlineSuggestions: boolean;
+        adminUrl?: string | undefined;
+    };
+    get selectedTextSuggestion(): TextSuggestion;
+    hasConversation(): boolean;
+    conversationId(): string;
+    private sessionId;
+    private shouldAbort;
+    login(): Promise<void>;
+    isLoggedIn(): Promise<boolean>;
+    /**
+     * Set platform id for current user
+     * @param agentId - The platform id of the current user
+     * @deprecated Since 7.14.6 in favor of setAgentInfo
+     */
+    setPlatformAgentId(agentId: string): Promise<void>;
+    /**
+     * Check if conversation is supported by Deepdesk
+     * @param sessionId - A string with the conversation session ID.
+     *  A session ID is local to the customer service platform, and identifies a
+     *  conversation that takes place within a certain time frame.
+     */
+    isConversationSupported(sessionId: string, options?: Parameters<typeof DeepdeskAPI.prototype.isConversationSupported>[1]): Promise<boolean>;
+    /**
+     * Create a conversation
+     * This should only be used when backend ingestion (via webhooks) is not possible.
+     * @param data - The create conversation options
+     */
+    createConversation(data: CreateConversation): Promise<Conversation>;
+    /**
+     * Get a conversation by session ID
+     * @param sessionId - A string with the conversation session ID.
+     *  A session ID is local to the customer service platform, and identifies a
+     *  conversation that takes place within a certain time frame.
+     */
+    getConversationBySessionId(sessionId: string, options?: Parameters<typeof DeepdeskAPI.prototype.getConversationBySessionId>[1]): Promise<Conversation>;
+    /**
+     * Upsert a conversation: Get and update conversation or create it if it does not exist yet.
+     */
+    upsertConversation(data: CreateConversation): Promise<Conversation>;
+    /**
+     * Method to call when the conversation is updated, either by an incoming message
+     * from the visitor, or a message sent by the agent.
+     */
+    postMessages(messages: ConversationMessage[]): Promise<any>;
+    /**
+     * Update converstation meta data
+     */
+    updateConversation(conversation: Partial<Conversation>): Promise<Conversation>;
+    /**
+     * Reset conversation
+     */
+    resetConversation(): void;
+    /**
+     * Get summary from conversation
+     */
+    getSummary(): Promise<string>;
+    /**
+     * Change settings value
+     */
+    configure(settings: Parameters<typeof set>[0]): void;
+    /**
+     * Store the visitor information in memory
+     */
+    setVisitorInfo(visitorInfo: VisitorInfo): void;
+    /**
+     * Store the agent information in memory
+     */
+    setAgentInfo(agentInfo: AgentInfo): Promise<void>;
+    /**
+     * Store the agent settings
+     */
+    setAgentSettings<T = unknown>(patch: Partial<T>): Promise<void>;
+    /**
+     * Get the agent settings
+     */
+    getAgentSettings<T = unknown>(): Promise<T>;
+    /**
+     * Refresh suggestions based on the current conversation.
+     * Only refresh text suggestions when the agent is not typing.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Method to call when the agent input has changed
+     */
+    private notifyInputChanged;
+    private syncInputHtml;
+    /**
+     * Method to call for the agent input keydown event
+     */
+    private notifyKeyDown;
+    private notifyPaste;
+    private notifyCut;
+    notifyExternalSuggestion(suggestion: StageSuggestion): void;
+    notifyEditSuggestion(data: {
+        contentType: string;
+        suggestions: TextSuggestion[];
+        index: number | null;
+    }): void;
+    private handleInputChanged;
+    private handleKeyDown;
+    private handleAfterSendMessage;
+    handlingTimeStart(): void;
+    handlingTimeStop(): void;
+    private logSendMessage;
+    private logSendEditMessage;
+    private logHandlingTime;
+    /**
+     * Method to call when the agent has sent a message to the visitor
+     * Optionally pass the sent text
+     */
+    notifySubmit(options?: {
+        text?: string;
+    }): void;
+    stageSelectedSuggestion(eventMetrics: SuggestionEventMetrics): void;
+    emit<K extends keyof SDKEventMap>(type: K, eventPayload: SDKEventMap[K], options?: {
+        mayApplyChanges?: boolean;
+    }): void;
+    /**
+     * Attach listener to SDK event
+     * Returns removeListener
+     */
+    on<K extends keyof SDKEventMap>(type: K, handler: SDKHandler<K>): () => void;
+    /**
+     * Remove listener from SDK
+     * Similar to HTMLElement.removeListener
+     */
+    off<K extends keyof SDKEventMap>(type: K, handler: SDKHandler<K>): void;
+    off(): void;
+    /**
+     * Set the fetch function to retrieve conversation data to be used for NER endpoints
+     * This way the NER service can remain a separate system and ensure anonomity
+     * @param fetchFn function that returns the conversation data as a string
+     */
+    setConversationQuery(fetchFn: () => Promise<Array<{
+        source: string;
+        text: string;
+    }>>): void;
+    whenConversationLoaded(callback: () => void): void;
+    private overlayContainerFactory;
+    private createContainer;
+    /**
+     * Renders the tab completion and suggestions overlay and 2-way binds events
+     * @param inputElement - the agent input element to enhance
+     * @param options - optional mount options
+     */
+    mount(inputElement: HTMLElement, options?: MountOptions): void;
+    unmount(): void;
+    /**
+     * Injects the Deepdesk Widget element into the provided DOM element.
+     * @param containerElement - the element to inject the deepdesk element in
+     * @param options - optional widget options
+     */
+    renderWidget(containerElement: HTMLElement, options?: WidgetOptions): void;
+    unmountWidget(): void;
+    private setupHandlingTime;
+    private handleError;
+    private loadProfileConfigPromise;
+    private loadProfileConfig;
+    checkForTrialMode(agentId: string): Promise<void>;
+    private refreshWidgetSuggestions;
+}
+
+declare class ContentEditableInput extends InputMediator<HTMLDivElement> {
+    protected observer?: MutationObserver;
+    getText(): string;
+    getHTML(): string;
+    getSelection(): SelectionRange | null;
+    getSelectedText(): string;
+    applyChanges(callback: (element: HTMLDivElement) => void | Promise<void>): void;
+    listen(): void;
+    dispose(): void;
+}
+
+declare class TextAreaInput extends InputMediator<HTMLTextAreaElement> {
+    getText(): string;
+    getHTML(): string | null;
+    getSelection(): SelectionRange;
+    getSelectedText(): string;
+    applyChanges(callback: (element: HTMLTextAreaElement) => void | Promise<void>): void;
+    listen(): void;
+}
+
+type OverlayOptions = {
+    appendTo?: HTMLElement;
+    mirrorOverflow?: boolean;
+    closestScrollElement?: HTMLElement;
+    overlayContainer?: HTMLElement;
+    onHide?(): void;
+    onShow?(): void;
+    onRemove?(): void;
+};
+/**
+ * border-box: width including scroll width
+ * content-box: width excluding scroll width
+ */
+declare function createOverlayContainer(target: HTMLElement, options?: OverlayOptions): [HTMLElement, () => void];
+
+declare function isSupportedInputElement(element?: HTMLElement): boolean;
+
+type TextAreaOptions = {
+    replace?: SelectionRange;
+    selectionAfter?: SelectionRange;
+    setValue?: (newValue: string) => void | Promise<void>;
+};
+declare function updateTextArea(element: HTMLTextAreaElement, insertText: string, options?: TextAreaOptions): Promise<void>;
+type ContentEditableOptions = {
+    replace?: SelectionRange;
+    selectionAfter?: SelectionRange | false;
+    setRange?: (range: Range) => void | Promise<void>;
+};
+declare function updateContentEditable(element: HTMLElement, insertText: string, options?: ContentEditableOptions): Promise<void>;
+
+/**
+ * Format (markdown) patterns to html.
+ */
+declare function formatTextMarkup(message: string): string;
+
+declare function authenticateWithKey(accountOrigin: string, key: string, user: User): Promise<void>;
+
+type PlatformConfig = {
+    config: {
+        account: {
+            name: string;
+        };
+        platform: {
+            name: string;
+            hasSso: boolean;
+            authorizationUrl: string;
+        };
+    };
+};
+declare function fetchPlatformConfig(accountOrigin: string): Promise<PlatformConfig>;
+
+declare function escapeHTML(text: string): string;
+
+interface TargetFileOptions {
+    /**
+     * path to file
+     * eg: https://example.com/test.jpeg
+     */
+    url: string;
+    /**
+     * name of file
+     * eg: test.jpeg
+     */
+    name: string;
+    /**
+     * mime type of file
+     * default: image/jpeg
+     */
+    mimeType?: string;
+    /**
+     * optionally override default window.fetch
+     */
+    fetch?: typeof window.fetch;
+}
+declare function attachFile(fileInput: HTMLInputElement, target: TargetFileOptions): Promise<void>;
+
+declare function createRangeFromOffsets(rootElement: HTMLElement, startOffset: number, endOffset: number): Range;
+declare function getRangeOffsets(rootElement: HTMLElement, range: Range): {
+    start: number;
+    end: number;
+};
+declare function getRangeText(rootElement: Node, range: Range): string;
+
+interface Cancelable {
+    (): void;
+}
+/**
+ * Get notified when a specific element changes from visible or invisible in the DOM
+ */
+declare function waitForElementVisibilityChange(element: HTMLElement, callback: (change: {
+    isVisible: boolean;
+}) => void, interval?: number): Cancelable;
+
+type CSSModule = Record<string, string>;
+declare function useStyles<TStyles extends CSSModule>(componentName: string, defaultStyles: TStyles): TStyles;
+
+export { AgentInfo, Card, Chip, ContentEditableInput, Conversation, ConversationMessage, DeepdeskAPI, DeepdeskSDK, InputMediator, InputOverlayCustomStyles, InputType, KeyboardHint, Label, Locale, Logger, MountOptions, PinnedMessage, PlatformConfig, Section, SectionList, SelectionRange, Sources, Suggestion, SuggestionEventMetrics, SuggestionList, SuggestionMetrics, TextAreaInput, TextSuggestion, ToggleButton, UrlSuggestion, VisitorInfo, WidgetCustomStyles, WidgetOptions, attachFile, authenticateWithKey, createOverlayContainer, createRangeFromOffsets, escapeHTML, fetchPlatformConfig, formatTextMarkup, getRangeOffsets, getRangeText, isSupportedInputElement, updateContentEditable, updateTextArea, useStyles, waitForElementVisibilityChange };