@opencx/widget-core 4.0.0

package/dist/api/api-caller.d.ts

@@ -0,0 +1,437 @@
+import { Dto } from './client';
+import { WidgetConfig } from '../types/widget-config';
+import { ResolveSessionDto, SendMessageDto, VoteInputDto } from '../types/dtos';
+export declare class ApiCaller {
+    private client;
+    private config;
+    private userToken;
+    constructor({ config }: {
+        config: WidgetConfig;
+    });
+    private constructClientOptions;
+    private createOpenAPIClient;
+    setAuthToken: (token: string) => void;
+    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"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('./schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        params: {
+            header: {
+                'X-Bot-Token': string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    widgetPrelude: () => 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"]["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?: {
+                id: string;
+                name: string;
+                size: number;
+                type: string;
+                url: string;
+            }[] | null;
+            clientContext?: {
+                [key: string]: unknown;
+            } | null;
+            custom_data?: {
+                [key: string]: unknown;
+            } | null;
+            exit_mode_prompt?: 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;
+            non_verified_name?: string;
+            non_verified_custom_data?: {
+                [key: string]: string | number | boolean;
+            };
+        };
+    }, `${string}/${string}`>>;
+    createSession: (body: Dto["CreateWidgetSessionDto"]) => 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 | unknown | unknown;
+            };
+        };
+    }, `${string}/${string}`>>;
+    pollSessionAndHistory: ({ sessionId, lastMessageTimestamp, abortSignal, }: {
+        sessionId: string;
+        lastMessageTimestamp?: string;
+        abortSignal: AbortSignal;
+    }) => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query?: {
+                lastMessageTimestamp?: string;
+            };
+            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;
+            };
+            query: {
+                lastMessageTimestamp: string;
+            } | undefined;
+        };
+        signal: AbortSignal;
+    }, `${string}/${string}`>>;
+    getSessions: ({ cursor, filters, abortSignal, }: {
+        cursor: string | undefined;
+        filters: Record<string, string>;
+        abortSignal?: AbortSignal;
+    }) => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query: {
+                filters: string;
+                cursor?: 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: {
+                cursor: 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}`>>;
+}

package/dist/api/client.d.ts

@@ -0,0 +1,12 @@
+import { Middleware } from 'openapi-fetch';
+import { paths, components } from './schema';
+type Options = {
+    baseUrl: string;
+    onRequest?: Middleware['onRequest'];
+    onResponse?: Middleware['onResponse'];
+    onError?: Middleware['onError'];
+};
+export declare const basicClient: (options: Options) => import('openapi-fetch').Client<paths, `${string}/${string}`>;
+export type Endpoint = keyof paths;
+export type Dto = components['schemas'];
+export {};