@opencx/widget 2.5.1 → 2.6.1

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

@@ -1,5 +1,6 @@
-import { HttpChatInputSchema, WidgetHistorySchema, WidgetPreludeSchema, WidgetSessionSchema } from '../types/schemas-v2';
+import { SendChatDto, WidgetVoteDto } from '../types/schemas-v2';
 import { NormalizedConfig } from './config';
+import { Dto } from '../sdk';
 export interface ApiCallerOptions {
     config: NormalizedConfig;
 }
@@ -7,44 +8,371 @@ export declare class ApiCaller {
     #private;
     private readonly options;
     constructor(options: ApiCallerOptions);
-    me(): Promise<{
-        contactId: string;
-        contactName: string;
-    }>;
-    widgetPrelude(): Promise<WidgetPreludeSchema>;
-    handleMessage(message: HttpChatInputSchema): 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";
+    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}`>>;
+    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,17 +1,28 @@
 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';
-type ChatState = {
+export type PollingType = "session" | "messages";
+export type PollingState = {
+    isPolling: boolean;
+    lastPollTime: string | null;
+    nextPollTime: string | null;
+    error: ErrorState;
+};
+export type PollingStates = {
+    [K in PollingType]: PollingState;
+};
+export type ChatState = {
     messages: MessageType[];
     keyboard: {
         options: string[];
     } | null;
     loading: LoadingState;
     error: ErrorState;
+    polling: PollingStates;
 };
 type ChatOptions = {
     api: ApiCaller;
@@ -19,34 +30,66 @@ type ChatOptions = {
     onSessionDestroy?: () => void;
     platform: Platform;
 };
+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: SomeOptional<Omit<HttpChatInputSchema, "bot_token">, "session_id" | "user">) => Promise<boolean>;
+    sendMessage: (input: SendMessageInput, abort?: AbortSignal) => Promise<{
+        success: boolean;
+        createdSession: boolean;
+        botMessage?: undefined;
+        error?: undefined;
+    } | {
+        success: boolean;
+        createdSession: boolean;
+        botMessage: BotMessageType | null;
+        error?: undefined;
+    } | {
+        success: boolean;
+        createdSession: boolean;
+        error: unknown;
+        botMessage?: undefined;
+    }>;
     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: any | null;
+        loading: LoadingState;
+        error: ErrorState;
+    }>;
+    shouldCollectData: () => {
+        should: boolean;
+        reason?: string;
+    };
 };
 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,21 @@ import { ApiCaller } from './api';
 import { Platform } from '../platform';
 import { LoadingState, ErrorState } from '../types/helpers';
 import { ConfigInstance } from './config';
-import { ConsumerType } from '@core/types/schemas';
 type ContactState = {
-    contact: ConsumerType | null;
+    contact: any | null;
     loading: LoadingState;
     error: ErrorState;
 };
-type ContactOptions = {
+export type CreateContactOptions = {
     api: ApiCaller;
-    platform: Platform;
     config: ConfigInstance;
 };
-export declare function createContact(options: ContactOptions): {
+export declare function createContact({ config }: CreateContactOptions, platform: Platform): {
     contactState: PubSub<ContactState>;
     shouldCollectData: () => {
         should: boolean;
         reason?: string;
     };
-    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>;
 };
 export {};

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

@@ -19,3 +19,9 @@ export declare class TransportError extends OpenCXError {
 export declare class FileUploadError extends OpenCXError {
     constructor(message?: string);
 }
+export declare class StorageNotAvailableError extends OpenCXError {
+    constructor(message?: string);
+}
+export declare class ExternalIdNotDefinedError extends OpenCXError {
+    constructor(message?: string);
+}

package/dist/core/platform/audio.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Platform-agnostic audio interface that can be implemented
+ * for different environments (web, mobile, desktop, etc.)
+ */
+export interface Audio {
+    /**
+     * Plays a notification sound
+     * @returns Promise that resolves when the sound finishes playing or rejects on error
+     */
+    playNotification(): Promise<void>;
+    /**
+     * Checks if audio playback is available and working
+     * @returns true if audio is available and working
+     */
+    isAvailable?(): boolean;
+}
+/**
+ * Helper function to check if audio is available and working
+ */
+export declare function isAudioAvailable(audio: Audio | undefined): audio is Audio;
+/**
+ * Type for the result of a safe audio operation
+ */
+export type AudioOperationResult = {
+    success: true;
+    error: null;
+} | {
+    success: false;
+    error: {
+        message: string;
+        code: string;
+        context: string;
+    };
+};
+/**
+ * Helper function to safely perform audio operations
+ */
+export declare function safeAudioOperation(operation: () => Promise<void>, errorContext: string): Promise<AudioOperationResult>;

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

@@ -1,11 +1,15 @@
-import { Logger } from './logger';
 import { Storage } from './storage';
+import { Audio } from './audio';
+import { Logger } from './logger';
 export * from './storage';
-export type { Storage };
+export * from './logger';
+export * from './audio';
+export type { Storage, Audio, Logger };
 export interface Platform {
     storage?: Storage;
     logger?: Logger;
     env: {
         platform: string;
     };
+    audio?: Audio;
 }

package/dist/core/platform/storage.d.ts

@@ -36,11 +36,17 @@ export declare function isStorageAvailable(storage: Storage | undefined): storag
 export type StorageOperationResult<T> = {
     success: true;
     result: T;
+    error: null;
 } | {
     success: false;
-    error: Error;
+    result: null;
+    error: {
+        message: string;
+        code: string;
+        context: string;
+    };
 };
 /**
  * Helper function to safely perform storage operations
  */
-export declare function safeStorageOperation<T>(operation: () => Promise<T>, errorMessage: string): Promise<StorageOperationResult<T>>;
+export declare function safeStorageOperation<T>(operation: () => Promise<T>, errorContext: string): Promise<StorageOperationResult<T>>;