@opencx/widget 2.6.0 → 2.6.2

package/dist/core/client/api.d.ts

@@ -1,5 +1,7 @@
-import { HttpChatInputSchema, WidgetHistorySchema, WidgetPreludeSchema, WidgetSessionSchema } from '../types/schemas-v2';
+import { User } from '../types';
+import { SendChatDto, WidgetVoteDto } from '../types/schemas-v2';
 import { NormalizedConfig } from './config';
+import { Dto } from '../sdk';
 export interface ApiCallerOptions {
     config: NormalizedConfig;
 }
@@ -7,44 +9,416 @@ export declare class ApiCaller {
     #private;
     private readonly options;
     constructor(options: ApiCallerOptions);
-    me(): Promise<{
-        contactId: string;
-        contactName: string;
-    }>;
-    widgetPrelude(): Promise<WidgetPreludeSchema>;
-    handleMessage(message: HttpChatInputSchema, abortSignal?: AbortSignal): Promise<{
-        success: true;
-        code?: string | undefined;
-        options?: {
-            type: "options";
-            value: string[];
-        } | undefined;
-        autopilotResponse?: {
-            type: "text";
-            value: {
-                content: string;
-                error: boolean;
-            };
-            id?: string | undefined;
-        } | undefined;
-        uiResponse?: {
-            type: "ui";
-            value: {
-                type: "ui_component";
+    createClient: (user: User) => import('openapi-fetch').Client<import('../sdk/schema').paths, `${string}/${string}`>;
+    setUser: (user: User) => void;
+    me: () => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["WidgetContactDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, import('openapi-fetch').FetchOptions<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["WidgetContactDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }> | undefined, `${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('../sdk/schema').components["schemas"]["WidgetPreludeDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        params: {
+            header: {
+                "X-Bot-Token": string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    handleMessage: (body: SendChatDto, abortSignal?: AbortSignal) => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": import('../sdk/schema').components["schemas"]["HttpChatInputDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["HandleContactMessageOutputDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        body: {
+            uuid: string;
+            content: string;
+            session_id: string;
+            headers?: {
+                [key: string]: string;
+            } | null;
+            bot_token: string;
+            query_params?: {
+                [key: string]: string;
+            } | null;
+            user?: {
+                email?: string;
+                name?: string;
+                phone?: string;
+                avatar?: string;
+                customData?: {
+                    [key: string]: string;
+                };
+            } | null;
+            language?: string | null;
+            attachments?: {
+                id: string;
                 name: string;
-                content?: string | undefined;
-                request_response?: unknown;
-            };
-        } | undefined;
-        sessionIsHandedOff?: boolean | undefined;
-    } | {
-        success: false;
-        error: {
-            code?: string | undefined;
-            message?: string | undefined;
-        };
-    }>;
-    getSessionHistory(sessionId: string, lastMessageTimestamp?: string): Promise<WidgetHistorySchema[]>;
-    createSession(): Promise<WidgetSessionSchema>;
-    getSession(sessionId: string): Promise<WidgetSessionSchema>;
+                size: number;
+                type: string;
+                url: string;
+            }[] | null;
+        };
+        signal: AbortSignal | undefined;
+    }, `${string}/${string}`>>;
+    getSessionHistory: (sessionId: string, lastMessageTimestamp?: string) => 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('../sdk/schema').components["schemas"]["WidgetHistoryDto"][];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                sessionId: string;
+            };
+            query: {
+                lastMessageTimestamp: string;
+            } | undefined;
+        };
+    }, `${string}/${string}`>>;
+    createContact: (body: Dto["CreateContactDto"]) => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query?: never;
+            header: {
+                "x-bot-token": string;
+            };
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": import('../sdk/schema').components["schemas"]["CreateContactDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["WidgetContactDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        params: {
+            header: {
+                "x-bot-token": string;
+            };
+        };
+        body: {
+            email: string;
+            name: string;
+        };
+    }, `${string}/${string}`>>;
+    createSession: () => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["WidgetSessionDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, import('openapi-fetch').FetchOptions<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["WidgetSessionDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }> | undefined, `${string}/${string}`>>;
+    getSession: (sessionId: string) => 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('../sdk/schema').components["schemas"]["WidgetSessionDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        params: {
+            path: {
+                sessionId: string;
+            };
+        };
+    }, `${string}/${string}`>>;
+    uploadFile: ({ file, abortSignal, }: {
+        file: {
+            id: string;
+            file: File;
+        };
+        abortSignal?: AbortSignal;
+    }) => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query: {
+                fileId: string;
+                sessionId: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "multipart/form-data": import('../sdk/schema').components["schemas"]["FileUploadDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["UploadWidgetFileDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        params: {
+            query: {
+                fileId: string;
+                sessionId: string;
+            };
+        };
+        body: Dto["FileUploadDto"];
+        signal: AbortSignal | undefined;
+        headers: {
+            "Content-Type": string;
+        };
+    }, `${string}/${string}`>>;
+    vote: (body: WidgetVoteDto) => Promise<import('openapi-fetch').FetchResponse<{
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": import('../sdk/schema').components["schemas"]["WidgetVoteDto"];
+            };
+        };
+        responses: {
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["WidgetVoteResponseDto"];
+                };
+            };
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": import('../sdk/schema').components["schemas"]["ErrorDto"];
+                };
+            };
+        };
+    }, {
+        body: {
+            action: "upvote" | "downvote";
+            sessionId: string;
+            messagePublicId: string;
+        };
+    }, `${string}/${string}`>>;
 }

package/dist/core/client/chat.d.ts

@@ -1,11 +1,11 @@
 import { PubSub } from '../types/pub-sub';
-import { MessageType } from '../types';
+import { BotMessageType, MessageType } from '../types';
 import { ApiCaller } from './api';
-import { HttpChatInputSchema } from '../types/schemas-v2';
-import { LoadingState, ErrorState, SomeOptional } from '../types/helpers';
+import { SendChatDto } from '../types/schemas-v2';
+import { LoadingState, ErrorState, SomeOptional, SafeOmit } from '../types/helpers';
 import { ConfigInstance } from './config';
 import { Platform } from '../platform';
-export type PollingType = 'session' | 'messages';
+export type PollingType = "session" | "messages";
 export type PollingState = {
     isPolling: boolean;
     lastPollTime: string | null;
@@ -30,20 +30,22 @@ type ChatOptions = {
     onSessionDestroy?: () => void;
     platform: Platform;
 };
-export type SendMessageInput = SomeOptional<Omit<HttpChatInputSchema, "bot_token">, "session_id" | "user">;
+export type SendMessageInput = SomeOptional<SafeOmit<SendChatDto, "bot_token" | "uuid">, "session_id" | "user">;
 export declare function createChat(options: ChatOptions): {
     chatState: PubSub<ChatState>;
     sessionState: PubSub<{
         id: string;
-        createdAt: Date;
-        updatedAt: Date;
+        createdAt: string;
+        updatedAt: string;
         isHandedOff: boolean;
         isOpened: boolean;
         assignee: {
+            kind: "human" | "ai" | "none" | "unknown";
             name: string | null;
-            kind: "unknown" | "ai" | "none" | "human";
+            avatarUrl: string | null;
         };
         channel: string;
+        isVerified: boolean;
     } | null>;
     sendMessage: (input: SendMessageInput, abort?: AbortSignal) => Promise<{
         success: boolean;
@@ -53,13 +55,7 @@ export declare function createChat(options: ChatOptions): {
     } | {
         success: boolean;
         createdSession: boolean;
-        botMessage: {
-            type: "FROM_BOT";
-            id: string;
-            timestamp: string;
-            component: string;
-            data: unknown;
-        } | null;
+        botMessage: BotMessageType | null;
         error?: undefined;
     } | {
         success: boolean;
@@ -69,19 +65,37 @@ export declare function createChat(options: ChatOptions): {
     }>;
     createSession: () => Promise<{
         id: string;
-        createdAt: Date;
-        updatedAt: Date;
+        createdAt: string;
+        updatedAt: string;
         isHandedOff: boolean;
         isOpened: boolean;
         assignee: {
+            kind: "human" | "ai" | "none" | "unknown";
             name: string | null;
-            kind: "unknown" | "ai" | "none" | "human";
+            avatarUrl: string | null;
         };
         channel: string;
+        isVerified: boolean;
     } | null>;
     clearSession: () => Promise<void>;
-    cleanup: (removeSession?: boolean) => void;
+    cleanup: () => void;
     initialState: ChatState;
     sessionStorageKey: string;
+    recreateSession: () => Promise<void>;
+    contactState: PubSub<{
+        contact: import('../types/contact').Contact | null;
+        loading: LoadingState;
+        error: ErrorState;
+    }>;
+    contactManager: {
+        shouldCollectData: () => {
+            should: boolean;
+            reason: string;
+        } | {
+            should: boolean;
+            reason?: undefined;
+        };
+        createUnauthenticatedContact: (payload: import('../sdk').Dto["CreateContactDto"]) => Promise<import('../sdk').Dto["WidgetContactDto"] | null>;
+    };
 };
 export {};

package/dist/core/client/config.d.ts

@@ -1,6 +1,8 @@
+import { Platform } from '../platform';
 import { CoreOptions } from '../types';
-export type NormalizedConfig = Required<Omit<CoreOptions, 'contactToken'>> & {
+export type NormalizedConfig = Required<Omit<CoreOptions, 'contactToken' | 'initialMessages'>> & {
     contactToken: string | undefined | null;
+    initialMessages: string[];
     soundEffectFiles: {
         messageArrived: string;
     };
@@ -12,8 +14,13 @@ export type NormalizedConfig = Required<Omit<CoreOptions, 'contactToken'>> & {
         persistSession: boolean;
         useSoundEffects: boolean;
     };
+    assets: {
+        organizationLogo: string;
+    };
 };
 export type ConfigInstance = {
+    config: NormalizedConfig;
+    updateSettings: (newSettings: Partial<WidgetSettings>) => void;
     getConfig: () => NormalizedConfig;
     getApiConfig: () => {
         apiUrl: string;
@@ -24,10 +31,13 @@ export type ConfigInstance = {
     };
     getBotConfig: () => NormalizedConfig['bot'];
     getThemeConfig: () => NormalizedConfig['theme'];
-    getSettings: () => NormalizedConfig['settings'];
     getSoundEffects: () => NormalizedConfig['soundEffectFiles'];
     getUser: () => NormalizedConfig['user'];
     getLanguage: () => string;
     getDebugMode: () => boolean;
 };
-export declare function createConfig(options: CoreOptions): ConfigInstance;
+export type WidgetSettings = {
+    persistSession: boolean;
+    useSoundEffects: boolean;
+};
+export declare function createConfig(options: CoreOptions, platform: Platform): ConfigInstance;

package/dist/core/client/contact.d.ts

@@ -3,31 +3,27 @@ import { ApiCaller } from './api';
 import { Platform } from '../platform';
 import { LoadingState, ErrorState } from '../types/helpers';
 import { ConfigInstance } from './config';
-import { ConsumerType } from '@core/types/schemas';
+import { Contact } from '../types/contact';
+import { Dto } from '../sdk';
 type ContactState = {
-    contact: ConsumerType | null;
+    contact: Contact | null;
     loading: LoadingState;
     error: ErrorState;
 };
 export type CreateContactOptions = {
     api: ApiCaller;
-    platform: Platform;
     config: ConfigInstance;
 };
-export declare function createContact(options: CreateContactOptions): {
+export declare function createContactHandler({ config, api }: CreateContactOptions, platform: Platform): {
     contactState: PubSub<ContactState>;
     shouldCollectData: () => {
         should: boolean;
-        reason?: string;
+        reason: string;
+    } | {
+        should: boolean;
+        reason?: undefined;
     };
-    loadContact: () => Promise<any>;
-    saveContact: (contactData: Partial<ConsumerType>) => Promise<{
-        id: string;
-        name: string | null;
-        email: string | null;
-        avatar_url: string | null;
-        created_at: string;
-    } | null>;
     cleanup: () => Promise<void>;
+    createUnauthenticatedContact: (payload: Dto["CreateContactDto"]) => Promise<Dto["WidgetContactDto"] | null>;
 };
 export {};

package/dist/core/client/index.d.ts

@@ -1,4 +1,4 @@
 export { createChat } from './chat';
-export { createContact } from './contact';
+export { createContactHandler } from './contact';
 export { ApiCaller, type ApiCallerOptions } from './api';
 export { createConfig } from './config';

package/dist/core/index.d.ts

@@ -2,7 +2,7 @@ export * from './errors';
 export * from './types';
 export * from './platform';
 export { createChat } from './client/chat';
-export { createContact } from './client/contact';
+export { createContactHandler } from './client/contact';
 export { createConfig } from './client/config';
 export { ApiCaller } from './client/api';
 export { createLogger } from './platform/logger';

package/dist/core/sdk/index.d.ts

@@ -0,0 +1,11 @@
+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 Dto = components['schemas'];
+export {};

package/dist/core/types/contact.d.ts

@@ -0,0 +1,2 @@
+import { components } from '../sdk/schema';
+export type Contact = components['schemas']['WidgetContactDto'];