@deepdesk/deepdesk-sdk 17.3.1-beta.1 → 18.0.1-beta.0

package/dist/index.d.mts

@@ -2059,7 +2059,7 @@ interface KnowledgeAssistantWidgetOptions extends KnowledgeAssistOptions {
 declare class DeepdeskSDK {
     static version: string;
     static count: number;
-    private deepdeskApi;
+    deepdeskApi: DeepdeskAPI;
     inputMediator: InputMediator<any> | null;
     private version;
     private broadcastEvents;
@@ -2077,6 +2077,37 @@ declare class DeepdeskSDK {
     private shouldRender;
     private ws;
     store: Store;
+    /**
+     * Creates a new DeepdeskSDK instance for managing a single conversation.
+     *
+     * Each SDK instance should be created for one conversation. The SDK handles
+     * authentication, rendering suggestions, and rendering a widget.
+     *
+     * @param options - Optional configuration options for the SDK
+     * @param options.deepdeskUrl - Base API URL for the Deepdesk backend (e.g., https://acme.deepdesk.com)
+     * @param options.version - Release version for analytics tracking (defaults to SDK version)
+     * @param options.locale - Language locale for UI labels (not for suggestions) (defaults to 'en-US')
+     * @param options.token - Optional JWT token for Authorization header (alternative to SSO)
+     * @param options.fetch - Custom fetch implementation (defaults to window.fetch)
+     * @param options.productName - Product name for whitelabelling purposes
+     * @param options.createCustomChannel - Custom channel creation function for broadcast events
+     * @param options.websocketClient - Custom WebSocket client implementation
+     *
+     * @example
+     * ```typescript
+     * const sdk = new DeepdeskSDK({
+     *   deepdeskUrl: 'https://acme.deepdesk.com',
+     *   locale: 'en-US',
+     *   productName: 'My Platform'
+     * });
+     *
+     * // With JWT token authentication
+     * const sdk = new DeepdeskSDK({
+     *   deepdeskUrl: 'https://acme.deepdesk.com',
+     *   token: 'your-jwt-token-here'
+     * });
+     * ```
+     */
     constructor({ deepdeskUrl, version, locale, token, fetch, productName, createCustomChannel, websocketClient, }: SDKOptions);
     get state(): {
         assistants: State$2;
@@ -2172,7 +2203,45 @@ declare class DeepdeskSDK {
         hasKeyboardInput: boolean;
     };
     get selectedTextSuggestion(): TextSuggestion;
+    /**
+     * Checks if a conversation is currently loaded in this SDK instance.
+     *
+     * This method returns true if a conversation has been successfully loaded
+     * via methods like `getConversationByExternalId()`, `createConversation()`,
+     * or `upsertConversation()`.
+     *
+     * @returns true if a conversation exists and is loaded, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (sdk.hasConversation()) {
+     *   console.log('Conversation loaded:', sdk.conversationId());
+     * } else {
+     *   console.log('No conversation loaded yet');
+     * }
+     * ```
+     */
     hasConversation(): boolean;
+    /**
+     * Gets the current conversation ID.
+     *
+     * Returns the unique identifier for the currently loaded conversation.
+     * This ID is used internally by Deepdesk for tracking and analytics.
+     *
+     * @returns The conversation ID as a string
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const id = sdk.conversationId();
+     *   console.log('Current conversation ID:', id);
+     * } catch (error) {
+     *   console.log('No conversation loaded yet');
+     * }
+     * ```
+     *
+     * @throws {Error} If no conversation is currently loaded
+     */
     conversationId(): string;
     private externalId;
     private shouldAbort;
@@ -2182,88 +2251,569 @@ declare class DeepdeskSDK {
      */
     private whenLoggedIn;
     /**
-     * This method checks if the user has a valid access token cookie or valid refresh token.
+     * Checks if the user is logged in and returns a promise that resolves when logged in.
+     *
+     * **Important Notes:**
+     * - If using this method, make sure to call `mount()` and/or `renderWidget()`
+     *   before waiting on the login promise to resolve.
+     * - The login promise only resolves after successful authentication and never throws.
      *
-     * @returns Return a promise that resolves when the user is logged in.
+     * @returns Promise that resolves when the user is logged in
+     *
+     * @example
+     * ```typescript
+     * // Mount first, then login
+     * sdk.mount(inputElement);
+     *
+     * sdk.login().then(() => {
+     *   console.log('User is logged in');
+     *   // Now safe to load conversation
+     *   return sdk.getConversationByExternalId('conversation-123');
+     * }).catch(() => {
+     *   console.log('Login failed or was cancelled');
+     *   sdk.unmount();
+     * });
+     * ```
      */
     login(): Promise<void>;
+    /**
+     * Checks if the user is currently logged in.
+     *
+     * This method performs an API call to verify the current authentication status.
+     * It checks for valid access tokens and refresh tokens.
+     *
+     * @returns Promise that resolves to true if user is logged in, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isLoggedIn = await sdk.isLoggedIn();
+     * if (isLoggedIn) {
+     *   console.log('User is authenticated');
+     *   // Proceed with conversation operations
+     * } else {
+     *   console.log('User needs to login');
+     *   await sdk.login();
+     * }
+     * ```
+     */
     isLoggedIn(): Promise<boolean>;
     /**
-     * Check if conversation is supported by Deepdesk
-     * @param externalId - A string with the conversation external ID.
-     *  A external ID is local to the customer service platform, and identifies a
-     *  conversation that takes place within a certain time frame.
+     * Checks if a conversation is supported by Deepdesk.
+     *
+     * This method verifies whether a conversation with the given external ID
+     * is supported by the Deepdesk platform. This check does not require
+     * the user to be logged in.
+     *
+     * @param externalId - The conversation external ID to check
+     * @param options - Optional retry parameters for the check
+     * @param options.attempts - Number of attempts if conversation is not created yet via webhook (default: 1)
+     * @param options.retryDelay - Delay between attempts in milliseconds (default: 1000)
+     * @returns Promise that resolves to true if conversation is supported, false otherwise
+     *
+     * @example
+     * ```typescript
+     * const isSupported = await sdk.isConversationSupported('conversation-123');
+     * if (isSupported) {
+     *   console.log('Conversation is supported by Deepdesk');
+     *   // Proceed with loading the conversation
+     * } else {
+     *   console.log('Conversation is not supported');
+     * }
+     *
+     * // With polling options for webhook delays
+     * const isSupported = await sdk.isConversationSupported('conversation-123', {
+     *   attempts: 5,
+     *   retryDelay: 500
+     * });
+     * ```
      */
     isConversationSupported(externalId: 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
+     * Creates a new conversation in Deepdesk.
+     *
+     * **Important:** This method should only be used when backend ingestion (via webhooks)
+     * is not possible. The preferred approach is to implement Deepdesk backend webhooks
+     * for notifying Deepdesk of new messages, which automatically creates conversations
+     * in the backend, and then use `getConversationByExternalId()` in the frontend.
+     *
+     * If a conversation with a different external ID is already loaded, this method
+     * will reset the current conversation before creating the new one.
+     *
+     * @param data - Conversation creation data
+     * @param data.externalId - The platform's conversation/thread/case ID
+     * @param data.platform - The messaging platform (e.g., 'liveengage', 'zendesk')
+     * @param data.agentId - The platform's agent ID
+     * @param data.agentName - The platform's agent name (optional)
+     * @param data.agentNickname - The platform's agent nickname (optional)
+     * @param data.agentEmail - The platform's agent email (optional)
+     * @param data.profileCode - Optional client profile code (e.g., 'b2b', 'b2c')
+     * @param data.metadata - Optional conversation metadata for matching the right profile.
+     * @returns Promise that resolves to the created conversation
+     *
+     * @example
+     * ```typescript
+     * const conversation = await sdk.createConversation({
+     *   externalId: 'conversation-123',
+     *   platform: 'zendesk',
+     *   agentId: 'agent-456',
+     *   agentName: 'John Doe',
+     *   agentEmail: 'john@company.com',
+     *   metadata: {
+     *     team: 'support',
+     *     channel: 'web-chat'
+     *   }
+     * });
+     *
+     * console.log('Created conversation:', conversation.id);
+     * ```
      */
     createConversation(data: CreateConversation): Promise<Conversation>;
     /**
-     * Get a conversation by session ID
-     * @param externalId - 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.
+     * Retrieves a conversation by its external ID.
+     *
+     * This method fetches a conversation that was created by the Deepdesk backend
+     * via webhooks. It's the preferred method for loading conversations when
+     * backend integration is implemented.
+     *
+     * If a conversation with a different external ID is already loaded, this method
+     * will reset the current conversation before loading the new one.
+     *
+     * @param externalId - The conversation external ID to retrieve
+     * @param options - Optional retry parameters for webhook delays
+     * @param options.attempts - Number of attempts if conversation is not created yet via webhook (default: 1)
+     * @param options.retryDelay - Delay between attempts in milliseconds (default: 1000)
+     * @returns Promise that resolves to the conversation
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   const conversation = await sdk.getConversationByExternalId('conversation-123');
+     *   console.log('Loaded conversation:', conversation.id);
+     * } catch (error) {
+     *   console.log('Conversation not found or not supported');
+     * }
+     *
+     * // With retry options for webhook delays
+     * const conversation = await sdk.getConversationByExternalId('conversation-123', {
+     *   attempts: 5,
+     *   retryDelay: 500
+     * });
+     * ```
      */
     getConversationByExternalId(externalId: string, options?: Parameters<typeof DeepdeskAPI.prototype.getConversationByExternalId>[1]): Promise<Conversation>;
     /**
-     * Upsert a conversation: Get and update conversation or create it if it does not exist yet.
+     * Creates or updates a conversation based on unique externalId/agentId/platform signature.
+     *
+     * **Important:** Only use this method when there is no backend integration possible.
+     * The preferred route is to implement Deepdesk backend webhooks for notifying Deepdesk
+     * of new messages (thus creating the conversation in the backend) and using
+     * `getConversationByExternalId()` in the frontend to get the correct conversation.
+     *
+     * This method will create a new conversation if one doesn't exist, or update
+     * an existing conversation if it does. If a conversation with a different external ID
+     * is already loaded, this method will reset the current conversation first.
+     *
+     * @param data - Conversation data for creation or update
+     * @param data.externalId - The platform's conversation/thread/case ID
+     * @param data.platform - The messaging platform (e.g., 'liveengage', 'zendesk')
+     * @param data.agentId - The platform's agent ID
+     * @param data.agentName - The platform's agent name (optional)
+     * @param data.agentNickname - The platform's agent nickname (optional)
+     * @param data.agentEmail - The platform's agent email (optional)
+     * @param data.profileCode - Optional client profile code (e.g., 'b2b', 'b2c')
+     * @param data.metadata - Optional conversation metadata for distinguishing conversation types
+     * @returns Promise that resolves to the conversation (created or updated)
+     *
+     * @example
+     * ```typescript
+     * const conversation = await sdk.upsertConversation({
+     *   externalId: 'conversation-123',
+     *   platform: 'zendesk',
+     *   agentId: 'agent-456',
+     *   agentName: 'John Doe',
+     *   agentEmail: 'john@company.com',
+     *   metadata: {
+     *     team: 'support',
+     *     channel: 'web-chat'
+     *   }
+     * });
+     *
+     * console.log('Conversation upserted:', conversation.id);
+     * ```
      */
     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.
+     * Posts messages to the current conversation.
+     *
+     * **Important:** Only use this method when there is no backend integration possible.
+     * The preferred route is to implement Deepdesk backend webhooks for notifying Deepdesk
+     * of new messages, which automatically handles message ingestion.
+     *
+     * This method allows you to manually post visitor, agent, or bot messages to Deepdesk.
+     * Messages are deduplicated based on their external ID, so if a message with the same
+     * ID already exists, the new message will be ignored.
+     *
+     * @param messages - Array of conversation messages to post
+     * @param messages[].externalId - The message ID (used for deduplication)
+     * @param messages[].source - The type of entity who wrote the message ('agent', 'visitor', 'bot', 'system')
+     * @param messages[].text - The message text content
+     * @param messages[].time - The message timestamp (ISO 8601 format, e.g., '2023-07-25T11:43:55.308+00:00')
+     * @param messages[].authorId - The platform's native author ID
+     * @param messages[].authorName - The message author name (optional)
+     * @param messages[].authorEmail - The message author email (optional)
+     * @param messages[].metadata - Optional message metadata for distinguishing message types
+     * @returns Promise that resolves when messages are posted
+     *
+     * @example
+     * ```typescript
+     * await sdk.postMessages([
+     *   {
+     *     externalId: 'msg-123',
+     *     source: 'visitor',
+     *     text: 'Hello, I need help with my order',
+     *     time: '2023-07-25T11:43:55.308+00:00',
+     *     authorId: 'visitor-456',
+     *     authorName: 'John Smith',
+     *     authorEmail: 'john@example.com',
+     *     metadata: {
+     *       channel: 'web-chat',
+     *       priority: 'normal'
+     *     }
+     *   },
+     *   {
+     *     externalId: 'msg-124',
+     *     source: 'agent',
+     *     text: 'Hi John, I\'d be happy to help you with your order',
+     *     time: '2023-07-25T11:44:00.000+00:00',
+     *     authorId: 'agent-789',
+     *     authorName: 'Support Agent',
+     *     metadata: {
+     *       team: 'customer-service'
+     *     }
+     *   }
+     * ]);
+     * ```
      */
     postMessages(messages: ConversationMessage[]): Promise<void>;
     /**
-     * Update converstation meta data
+     * Updates conversation metadata.
+     *
+     * This method allows you to update various properties of the current conversation,
+     * such as metadata, status, or other conversation-specific information.
+     *
+     * @param conversation - Partial conversation data to update
+     * @param conversation.metadata - Optional metadata to update
+     * @param conversation.status - Optional conversation status to update
+     * @param conversation.externalId - Optional external ID to update
+     * @param conversation.platform - Optional platform to update
+     * @param conversation.agentId - Optional agent ID to update
+     * @param conversation.agentName - Optional agent name to update
+     * @param conversation.agentEmail - Optional agent email to update
+     * @returns Promise that resolves to the updated conversation
+     *
+     * @example
+     * ```typescript
+     * const updatedConversation = await sdk.updateConversation({
+     *   metadata: {
+     *     priority: 'high',
+     *     category: 'technical-support',
+     *     assignedTeam: 'level-2'
+     *   }
+     * });
+     *
+     * console.log('Updated conversation:', updatedConversation.id);
+     * ```
      */
     updateConversation(conversation: Partial<Conversation>): Promise<Conversation>;
     /**
-     * Reset conversation
+     * Resets the current conversation state.
+     *
+     * This method clears the currently loaded conversation and resets all
+     * conversation-related state, including profile configuration and conversation
+     * query functions. This is useful when switching between conversations or
+     * when you need to start fresh.
+     *
+     * After calling this method, you'll need to load a new conversation using
+     * methods like `getConversationByExternalId()`, `createConversation()`, or
+     * `upsertConversation()`.
+     *
+     * **Note:** It's safer to use a different DeepdeskSDK instance for each conversation.
+     *
+     * @example
+     * ```typescript
+     * // Reset current conversation
+     * sdk.resetConversation();
+     *
+     * // Load a different conversation
+     * await sdk.getConversationByExternalId('new-conversation-123');
+     *
+     * // Or create a new conversation
+     * await sdk.createConversation({
+     *   externalId: 'new-conversation-456',
+     *   platform: 'zendesk',
+     *   agentId: 'agent-789'
+     * });
+     * ```
      */
     resetConversation(): void;
     /**
-     * Change settings value
+     * Updates SDK configuration settings.
+     *
+     * This method allows you to dynamically update various SDK settings at runtime.
+     * Settings include locale, visibility, suggestion preferences, and other
+     * configuration options.
+     *
+     * @param settings - Optional settings object to update SDK configuration.
+     * @param settings.locale: Language locale for UI labels (default: 'en-US')
+     * @param settings.deanonymize: Whether to deanonymize messages (default: false)
+     * @param settings.fallbackImage: Whether to use a fallback image (default: false)
+     * @param settings.showImages: Show images in suggestions (default: false)
+     * @param settings.showSearch: Show search UI (default: false)
+     * @param settings.showImageSearch: Show image search UI (default: false)
+     * @param settings.showStyleSuggestions: Show style suggestions (default: false)
+     * @param settings.showMidSentenceSuggestions: Show mid-sentence suggestions (default: false)
+     * @param settings.showSuggestionsBeforePattern: Pattern for showing suggestions before (default: false)
+     * @param settings.showSuggestionsAfterPattern: Pattern for showing suggestions after (default: false)
+     * @param settings.showTabCompletion: Enable tab completion (default: true)
+     * @param settings.showTextSuggestions: Show text suggestions (default: true)
+     * @param settings.showEntitiesCommand: Show entities command (default: false)
+     * @param settings.showSummaryCommand: Show summary command (default: false)
+     * @param settings.showKnowledgeSearch: Show knowledge search (default: false)
+     * @param settings.textSuggestionsCount: Number of text suggestions to show (default: 3)
+     * @param settings.recommendTextSuggestions: Recommend text suggestions (default: true)
+     * @param settings.searchTriggerKey: Key to trigger search (default: 'k')
+     * @param settings.insertLink: Enable insert link (default: false)
+     * @param settings.automaticHandlingTime: Enable automatic handling time (default: false)
+     * @param settings.enableSuggestionFeedback: Enable suggestion feedback (default: false)
+     * @param settings.enableFeedbackForm: Enable feedback form (default: true)
+     * @param settings.adminUrl: Admin URL (default: deepdeskUrl provided by DeepdeskSDK constructor)
+     * @param settings.productName: Product name (default: 'Deepdesk')
+     * @param settings.hasKeyboardInput: Whether keyboard input is enabled (default: true)
+     *
+     * @example
+     * ```typescript
+     * // Update locale
+     * sdk.configure({ locale: 'nl-NL' });
+     * ```
      */
     configure(settings: Parameters<typeof set>[0]): void;
     /**
-     * Store the visitor information in memory
+     * Sets visitor information for placeholder interpolation in suggestions.
+     *
+     * This method allows you to provide visitor information that can be used
+     * in suggestion templates. The information is used for placeholder replacement
+     * in suggestion text, making suggestions more personalized and contextual.
+     *
+     * @param visitorInfo - Visitor data to store
+     * @param visitorInfo.visitorId - Optional Platform's visitor ID
+     * @param visitorInfo.visitorName - Optional Visitor name (first name is often preferred for suggestions)
+     * @param visitorInfo.visitorTimeZone - Optional Visitor time zone
+     *
+     * @example
+     * ```typescript
+     * sdk.setVisitorInfo({
+     *   visitorId: 'visitor-123',
+     *   visitorName: 'John Smith',
+     *   visitorTimeZone: 'Europe/Amsterdam'
+     * });
+     *
+     * // This enables placeholders in suggestions like:
+     * // "Hello {visitor_name}, I can help you with your order"
+     * ```
      */
     setVisitorInfo(visitorInfo: VisitorInfo): void;
     /**
-     * Set custom data to show in the widget
+     * Sets custom data to display in the widget.
+     *
+     * This method allows you to provide custom data that will be displayed
+     * in the Deepdesk widget. This can include any information you want
+     * to show to agents, such as customer details, order information,
+     * or other contextual data.
+     *
+     * **Important:** The actual UI configuration of the widget is done in the Deepdesk Studio.
+     *
+     * @param data - Custom data object to injest for display in the widget
+     *
+     * @example
+     * ```typescript
+     * sdk.setCustomData({
+     *   customer_id: 'CUST-12345',
+     *   order_number: 'ORD-67890',
+     * });
+     * ```
      */
     setCustomData(data: CustomData): void;
     /**
-     * Store the agent information in memory and on the server.
-     * Pass `skipPatch` as option to skip saving on the server.
+     * Sets agent information for placeholder interpolation in suggestions.
+     *
+     * This method allows you to provide agent information that can be used
+     * in suggestion templates. The information is used for placeholder replacement
+     * in suggestion text, making suggestions more personalized for the agent.
+     *
+     * @param agentInfo - Agent data to store
+     * @param agentInfo.agentId - Platform's agent ID
+     * @param agentInfo.agentNickname - Agent's nickname or first name (preferred for suggestions)
+     * @param agentInfo.agentName - Optional Agent's first name or full name
+     * @param agentInfo.agentEmail - Optional Agent's email address
+     * @param options - Optional configuration
+     * @param options.skipSync - Whether to skip syncing with the backend (default: false)
+     *
+     * @example
+     * ```typescript
+     * sdk.setAgentInfo({
+     *   agentId: 'agent-123',
+     *   agentNickname: 'John',
+     *   agentName: 'John Doe',
+     *   agentEmail: 'john.doe@company.com'
+     * });
+     *
+     * // This enables placeholders in suggestions like:
+     * // "Hi {agent_name}, here's a suggestion for your response"
+     * ```
+     *
+     * **Available Placeholders:**
+     * - agentNickname or agentName → `{agent_name}`
      */
     setAgentInfo(agentInfo: AgentInfo, options?: {
         skipSync?: boolean;
     }): Promise<void>;
     /**
-     * Store the agent settings
+     * Updates agent settings.
+     *
+     * This method allows you to update various agent-specific settings for your
+     * custom integration that are stored in the Deepdesk backend. These settings
+     * can be retrieved later using `getAgentSettings()`.
+     *
+     * @param patch - Settings to update (partial object)
+     * @returns Promise that resolves when settings are updated
+     *
+     * @example
+     * ```typescript
+     * // Update agent preferences
+     * await sdk.setAgentSettings({
+     *   theme: 'dark'
+     * });
+     * ```
      */
     setAgentSettings<T = unknown>(patch: Partial<T>): Promise<void>;
     /**
-     * Get the agent settings
+     * Retrieves agent settings.
+     *
+     * This method fetches the current agent settings from the Deepdesk backend.
+     * These settings can be updated using `setAgentSettings()`.
+     *
+     * @returns Promise that resolves to agent settings
+     *
+     * @example
+     * ```typescript
+     * // Get all agent settings
+     * const settings = await sdk.getAgentSettings();
+     * console.log('Agent settings:', settings);
+     *
+     * // Get settings with specific type
+     * interface AgentPreferences {
+     *   theme: 'light' | 'dark';
+     * }
+     *
+     * const preferences = await sdk.getAgentSettings<AgentPreferences>();
+     * console.log('Preferred language:', preferences.theme);
+     * ```
      */
     getAgentSettings<T = unknown>(): Promise<T>;
     /**
-     * Refresh suggestions based on the current conversation.
-     * Only refresh text suggestions when the agent is not typing.
+     * Refreshes suggestions based on the current conversation.
+     *
+     * This method triggers a refresh of both text suggestions and widget suggestions
+     * based on the current conversation context. Use this when the agent or visitor
+     * has submitted a message and the Deepdesk webhook has been notified.
+     *
+     * **Important:** Be careful not to refresh suggestions when the agent is already
+     * typing, as this could interfere with the user experience.
+     *
+     * @returns Promise that resolves when refresh is complete
+     *
+     * @example
+     * ```typescript
+     * // Refresh after a new message is received
+     * // ---handle sending a message in the integration---
+     * await sdk.refresh();
+     * console.log('Suggestions refreshed');
+     * ```
      */
     refresh(): Promise<void>;
     private syncInputMediator;
+    /**
+     * Adds an external suggestion to the current input.
+     *
+     * This method allows you to programmatically commit a suggestion to the
+     * current input field. This is useful when you want to add suggestions
+     * from external sources or custom logic.
+     *
+     * @param suggestion - Suggestion to commit
+     * @param suggestion.text - The text to insert
+     * @param suggestion.suggestion - The suggestion object
+     * @param suggestion.eventMetrics - Metrics for tracking the suggestion usage
+     * @param suggestion.replace - Range to replace ('selection' or 'until-selection-end')
+     *
+     * @example
+     * ```typescript
+     * // Add a custom suggestion from external system
+     * sdk.notifyExternalSuggestion({
+     *   text: 'Thank you for contacting us!',
+     *   suggestion: {
+     *     id: 'custom-1',
+     *     text: 'Thank you for contacting us!',
+     *     type: 'template'
+     *   },
+     *   eventMetrics: {
+     *     inputType: 'mouse'
+     *   },
+     *   replace: 'until-selection-end'
+     * });
+     * ```
+     */
     notifyExternalSuggestion(suggestion: StageSuggestion): void;
     /**
-     * Evaluate assistant
-     * By default will expect cues and show them in the widget.
-     * Disable cues in widget by providing `showCuesInWidget: false`-option.
-     * `expectFormat` could be 'text', 'json-object', 'json-schema:cues' or 'json-schema:knowledge-assist'
+     * Evaluates an assistant with the given code.
+     *
+     * This is a low-level method that allows you to evaluate an assistant.
+     * You are probably better off using `evaluateConversationAssistant()` for conversation lifecycle events.
+     *
+     * @param assistantCode - The assistant code to evaluate
+     * @param options - Evaluation options
+     * @param options.expectFormat - Expected response format ('json-schema:cues', 'json-schema:knowledge-assist', 'text', 'json-object')
+     * @param options.input - Additional input data for the assistant
+     * @param options.transcript - Transcript option ('in-memory-transcript' or custom transcript)
+     * @param options.includeMetadata - Whether to include metadata in the response
+     * @param options.showCuesInWidget - Whether to show cues in the widget (default: true)
+     * @returns Promise that resolves to evaluation output or string
+     *
+     * @example
+     * ```typescript
+     * // Evaluate assistant with cues format
+     * const result = await sdk.evaluateAssistant('assistant-code-123', {
+     *   expectFormat: 'json-schema:cues',
+     *   input: {
+     *     customerType: 'premium',
+     *     issueType: 'technical'
+     *   }
+     * });
+     *
+     * // Evaluate with custom transcript
+     * const result = await sdk.evaluateAssistant('assistant-code-456', {
+     *   expectFormat: 'text',
+     *   transcript: [
+     *     { source: 'visitor', text: 'I have a problem with my order' },
+     *     { source: 'agent', text: 'I can help you with that' }
+     *   ]
+     * });
+     *
+     * // Evaluate with in-memory transcript (requires setConversationQuery)
+     * const result = await sdk.evaluateAssistant('assistant-code-789', {
+     *   transcript: 'in-memory-transcript',
+     *   includeMetadata: true
+     * });
+     * ```
      */
     evaluateAssistant<T extends Server.ResponseFormat = 'json-schema:cues'>(assistantCode: string, options?: {
         expectFormat?: T;
@@ -2273,9 +2823,44 @@ declare class DeepdeskSDK {
         showCuesInWidget?: boolean;
     }): Promise<EvaluationOutput<T> | string>;
     /**
-     * Evaluate conversation lifecycle assistant
-     * Convenient wrapper around `evaluateAssistant`.
-     * By default includes the server transcript and 'metadata'.
+     * Evaluates conversation lifecycle assistants.
+     *
+     * This is a convenient wrapper around `evaluateAssistant()` that evaluates
+     * assistants based on conversation lifecycle events. It automatically loads
+     * the profile configuration and evaluates the appropriate assistants for
+     * the given event.
+     *
+     * @param event - The conversation event type 'accepted' | 'new-message' | 'ended'
+     * @param options - Evaluation options
+     * @param options.input - Additional input data for the assistant. Will be used as 'params' in the prompt.
+     * @param options.transcript - Transcript option ('in-memory-transcript' or custom transcript)
+     * @param options.includeMetadata - Whether to include metadata in the response
+     * @param options.showCuesInWidget - Whether to show cues in the widget (default: true)
+     * @returns Promise that resolves when evaluation is complete
+     *
+     * @example
+     * ```typescript
+     * // Evaluate when conversation is accepted
+     * await sdk.evaluateConversationAssistant('accepted', {
+     *   input: {
+     *     agentName: 'John Doe',
+     *     priority: 'high'
+     *   }
+     * });
+     *
+     * // Evaluate when new message is received
+     * await sdk.evaluateConversationAssistant('new-message', {
+     *   includeMetadata: true,
+     * });
+     *
+     * // Evaluate when conversation ends
+     * await sdk.evaluateConversationAssistant('ended', {
+     *   input: {
+     *     resolution: 'solved',
+     *     satisfaction: 'positive'
+     *   }
+     * });
+     * ```
      */
     evaluateConversationAssistant(event: 'accepted' | 'new-message' | 'ended', options?: {
         input?: Record<string, any>;
@@ -2284,44 +2869,287 @@ declare class DeepdeskSDK {
         showCuesInWidget?: boolean;
     }): Promise<void>;
     /**
-     * Get summary from conversation
+     * @deprecated Specific 'Summarizer' assistants are deprecated.
+     *
+     * Generates a summary of the current conversation.
+     *
+     * This method uses the summarizer assistant configured in the profile to
+     * generate a concise summary of the current conversation. It assumes that
+     * `setConversationQuery()` has been called before this method and will
+     * throw an error if this is not the case.
+     *
+     * @param args - Summary generation options
+     * @param args.includeMetadata - Whether to include metadata in the summary
+     * @param args.transcript - Custom transcript to use (optional)
+     * @returns Promise that resolves to the summary text or null if no summarizer is configured
+     *
+     * @example
+     * ```typescript
+     * // Set up conversation query first
+     * sdk.setConversationQuery(async () => {
+     *   return [
+     *     { source: 'visitor', text: 'I have a problem with my order' },
+     *     { source: 'agent', text: 'I can help you with that' },
+     *     { source: 'visitor', text: 'My order number is 12345' }
+     *   ];
+     * });
+     *
+     * // Generate summary
+     * const summary = await sdk.getSummary();
+     * console.log('Conversation summary:', summary);
+     *
+     * // Generate summary with metadata
+     * const summaryWithMetadata = await sdk.getSummary({
+     *   includeMetadata: true
+     * });
+     *
+     * // Generate summary with custom transcript
+     * const customSummary = await sdk.getSummary({
+     *   transcript: [
+     *     { source: 'visitor', text: 'Custom conversation data' },
+     *     { source: 'agent', text: 'Agent response' }
+     *   ]
+     * });
+     * ```
+     *
+     * @throws {Error} If `setConversationQuery()` has not been called
      */
     getSummary(args?: SummaryInput): Promise<string | null>;
     private handleKeyDown;
     private handleAfterSendMessage;
+    /**
+     * Starts or continues timing the interaction between agent and customer.
+     *
+     * This method is used to track the average handling time (AHT) for conversations.
+     * It starts timing when called and continues timing if already started.
+     * The timing is used for analytics and performance metrics.
+     *
+     * **Note:** For automatic handling time tracking, consider using the
+     * `automaticHandlingTime` setting instead of manually calling this method.
+     *
+     * @example
+     * ```typescript
+     * sdk.handlingTimeStart();
+     * ```
+     */
     handlingTimeStart(): void;
+    /**
+     * Stops or pauses timing the interaction between agent and customer.
+     *
+     * This method stops the current handling time tracking and sends an
+     * intermediate analytics event to Deepdesk with the accumulated timing data.
+     *
+     * **Note:** For automatic handling time tracking, consider using the
+     * `automaticHandlingTime` setting instead of manually calling this method.
+     *
+     * @example
+     * ```typescript
+     * sdk.handlingTimeStop();
+     * ```
+     */
     handlingTimeStop(): void;
     private logSendMessage;
     private logHandlingTime;
     /**
-     * Method to call when the agent has sent a message to the visitor
-     * Optionally pass the sent text
+     * Notifies the SDK that a message has been submitted.
+     *
+     * This method should be called when the agent has sent a message to the visitor.
+     * It sends an analytics event to Deepdesk containing the sent text and other metrics.
+     *
+     * **Important:** Call `notifySubmit` after the message is successfully sent by the platform,
+     * but before the agent input element is emptied. This ensures the correct text is captured
+     * for analytics.
+     *
+     * @param options - Submit options
+     * @param options.text - Optional text to use if the input field is already reset
+     *
+     * @example
+     * ```typescript
+     * // Call after message is sent but before input is cleared
+     * function sendMessage() {
+     *   const messageText = inputElement.value;
+     *
+     *   // Integration sends message
+     *   platformAPI.sendMessage(messageText).then(() => {
+     *     // Notify SDK before clearing input
+     *     sdk.notifySubmit();
+     *
+     *     // Now clear the input
+     *     inputElement.value = '';
+     *   });
+     * }
+     *
+     * // If input is already cleared, pass the text manually
+     * function sendMessageWithClearedInput() {
+     *   const messageText = inputElement.value;
+     *
+     *   // Integration sends message and clears input
+     *   platformAPI.sendMessage(messageText);
+     *   inputElement.value = '';
+     *
+     *   // Pass text manually since input is already cleared
+     *   sdk.notifySubmit({ text: messageText });
+     * }
+     * ```
      */
     notifySubmit(options?: {
         text?: string;
     }): void;
+    /**
+     * Emits an event to registered listeners
+     * @param type - Event type
+     * @param eventPayload - Event data
+     */
     emit<K extends keyof SDKEventMap>(type: K, eventPayload: SDKEventMap[K]): void;
     /**
-     * Attach listener to SDK event
-     * Returns removeListener
+     * Registers an event listener for SDK events.
+     *
+     * This method allows you to listen to various events that occur when the agent
+     * interacts with suggestions, messages are sent, or other SDK activities happen.
+     *
+     * The function returns a callback which allows you to remove the listener.
+     * An alternative to remove a listener is to use the `off()` method.
+     *
+     * @param type - Event type to listen for
+     * @param handler - Event handler function that receives the event payload
+     * @returns Function to remove the listener
+     *
+     * @example
+     * ```typescript
+     * // Listen for suggestion selection
+     * const removeListener = sdk.on('select-suggestion', (event) => {
+     *   console.log('Suggestion selected:', event.text);
+     *   console.log('Suggestion type:', event.type);
+     * });
+     *
+     * // Listen for message sending
+     * sdk.on('send-message', (message) => {
+     *   console.log('Message sent:', message);
+     * });
+     *
+     * // Listen for conversation events
+     * sdk.on('event', (event) => {
+     *   console.log('Event:', event.name, event.data);
+     * });
+     *
+     * // Remove listener using returned function
+     * removeListener();
+     *
+     * // Or remove using off method
+     * sdk.off('select-suggestion', handler);
+     * ```
      */
     on<K extends keyof SDKEventMap>(type: K, handler: SDKHandler<K>): () => void;
     /**
-     * Remove listener from SDK
-     * Similar to HTMLElement.removeListener
+     * Removes event listeners from the SDK.
+     *
+     * This method allows you to remove specific event listeners or all listeners
+     * for a particular event type. If no parameters are provided, all listeners
+     * are removed.
+     *
+     * @param type - Event type to remove listeners for (optional, removes all if not specified)
+     * @param handler - Specific handler function to remove (optional)
+     *
+     * @example
+     * ```typescript
+     * // Remove specific listener
+     * sdk.off('select-suggestion', myHandler);
+     *
+     * // Remove all listeners for a specific event type
+     * sdk.off('select-suggestion');
+     *
+     * // Remove all listeners (cleanup)
+     * sdk.off();
+     * ```
      */
-    off<K extends keyof SDKEventMap>(type: K, handler: SDKHandler<K>): void;
-    off(): void;
+    off<K extends keyof SDKEventMap>(type?: K, handler?: SDKHandler<K>): 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
+     * Sets a function to fetch a transcript for features that require an unanonymized transcript.
+     *
+     * This method allows you to provide a function that returns conversation data for features
+     * like extracting entities from the transcript or generating summaries. The transcript
+     * is used once and then discarded for privacy reasons.
+     *
+     * The conversation returned must be an array of objects, each containing a `text` and a `source`.
+     * The `source` should be either 'agent' or 'visitor'.
+     *
+     * @param fetchFn - Function that returns conversation data
+     * @param fetchFn.source - The source of the message ('agent' or 'visitor')
+     * @param fetchFn.text - The text content of the message
+     *
+     * @example
+     * ```typescript
+     * // Set up conversation query function
+     * sdk.setConversationQuery(async () => {
+     *   // Fetch conversation from your platform
+     *   const messages = await somePlatformSDK.getConversationMessages(conversationId);
+     *
+     *   return messages.map(msg => ({
+     *     source: msg.author === 'agent' ? 'agent' : 'visitor',
+     *     text: msg.content
+     *   }));
+     * });
+     *
+     * // Now you can use features that require setConversationQuery to be set
+     * const summary = await sdk.getSummary();
+     * ```
      */
     setConversationQuery(fetchFn: () => Promise<Array<{
         source: string;
         text: string;
     }>>): void;
+    /**
+     * Sets platform-specific variables for placeholder interpolation.
+     *
+     * This method allows you to provide platform-specific variables that can be used
+     * in suggestion templates. These variables are used for placeholder replacement
+     * in suggestion text, making suggestions more contextual to your platform.
+     *
+     * @param mapping - Variable mapping object
+     * @param mapping[key] - The value for the variable placeholder
+     *
+     * @example
+     * ```typescript
+     * // Set platform variables
+     * sdk.setPlatformVariables({
+     *   'platform_name': 'Zendesk',
+     *   'company_name': 'Acme Corp',
+     *   'support_email': 'support@acme.com',
+     *   'business_hours': '9 AM - 5 PM EST'
+     * });
+     *
+     * // This enables placeholders in suggestions like:
+     * // "Thank you for contacting {company_name} support"
+     * // "Our {platform_name} team is available {business_hours}"
+     *
+     * // Update variables dynamically
+     * sdk.setPlatformVariables({
+     *   'current_agent': 'John Doe',
+     *   'queue_length': '5'
+     * });
+     * ```
+     */
     setPlatformVariables(mapping: VariableMapping): void;
+    /**
+     * Registers a callback to be called when conversation is loaded.
+     *
+     * This method allows you to register a callback function that will be executed
+     * when a conversation is successfully loaded. The callback is called after
+     * the profile configuration has been loaded.
+     *
+     * If a conversation is already loaded when this method is called, the callback
+     * will be executed immediately.
+     *
+     * @param callback - Function to call when conversation loads
+     *
+     * @example
+     * ```typescript
+     * // Register callback for when conversation loads
+     * sdk.whenConversationLoaded(() => {
+     *   console.log('Conversation loaded, profile configured');
+     * });
+     * ```
+     */
     whenConversationLoaded(callback: () => void): void;
     private overlayContainerFactory;
     private createInlineContainer;
@@ -2329,12 +3157,99 @@ declare class DeepdeskSDK {
     private storeMetrics;
     private restoreMetrics;
     /**
-     * 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
+     * Mounts the tab completion and suggestions overlay to an input element.
+     *
+     * This method enhances a textarea or contentEditable div with Deepdesk's
+     * suggestion functionality, including text suggestions, tab completion,
+     * and floating menus. It sets up all necessary event listeners and renders
+     * the UI components.
+     *
+     * **Important:** This method can only be called once per SDK instance.
+     * If you need to remount, call `unmount()` first.
+     *
+     * @param inputElement - The input element to enhance (textarea or contentEditable div)
+     * @param options - Mount configuration options
+     * @param options.customStyles - Custom styling for overlays and components
+     * @param options.closestScrollSelector - CSS selector for closest scrollable parent
+     * @param options.floatingMenuParent - Parent element for floating menu
+     * @param options.appendOverlayTo - Element to append overlays to (default: inputElement.parentElement)
+     * @param options.inputMediator - Custom input mediator implementation
+     * @param options.xxx - All other options are passed to the configure method
+     *
+     * @example
+     * ```typescript
+     * // Basic mounting on a textarea
+     * const textarea = document.querySelector('textarea');
+     * sdk.mount(textarea);
+     *
+     * // Mount on contentEditable div
+     * const contentEditable = document.querySelector('[contenteditable="true"]');
+     * sdk.mount(contentEditable, {
+     *   customStyles: {
+     *     rootNode: 'my-custom-root-class'
+     *   },
+     *   appendOverlayTo: document.body
+     * });
+     *
+     * // Mount with custom input mediator
+     * class CustomInputMediator extends InputMediator<HTMLElement> {
+     *   // Custom implementation
+     * }
+     *
+     * sdk.mount(textarea, {
+     *   inputMediator: new CustomInputMediator(textarea)
+     * });
+     * ```
+     *
+     * @throws {Error} If the SDK instance is already mounted
+     * @throws {Error} If the input element is not a supported type (textarea or contentEditable div)
      */
     mount(inputElement: HTMLElement, options?: MountOptions): void;
+    /**
+     * Subscribes to internal state changes.
+     *
+     * This method allows you to subscribe to changes in the SDK's internal state.
+     * It uses a selector function to extract specific parts of the state and calls
+     * the callback function whenever that part of the state changes.
+     *
+     * The subscription only triggers when the selected value actually changes
+     * (reference equality check), preventing unnecessary callbacks.
+     *
+     * @param selector - Function to select a specific part of the state
+     * @param callback - Function called when the selected state changes
+     * @returns Function to unsubscribe from the state changes
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to input text changes
+     * const unsubscribe = sdk.subscribe(
+     *   (state) => state.input.text,
+     *   (text) => {
+     *     console.log('Input text changed:', text);
+     *   }
+     * );
+     *
+     * // Unsubscribe when done
+     * unsubscribe();
+     * ```
+     */
     subscribe<T>(selector: (state: RootState) => T, callback: (value: T) => void): Unsubscribe;
+    /**
+     * Unmounts the SDK and cleans up all resources.
+     *
+     * This method removes all UI components, event listeners, and cleans up
+     * internal resources. It should be called when you're done using the SDK
+     * or when you need to remount it on a different element.
+     *
+     * After calling this method, the SDK instance can be reused by calling
+     * `mount()` again on a new input element.
+     *
+     * @example
+     * ```typescript
+     * // Unmount when switching conversations
+     * sdk.unmount();
+     * ```
+     */
     unmount(): void;
     private renderSuggestions;
     private renderInlineSuggestions;
@@ -2342,12 +3257,121 @@ declare class DeepdeskSDK {
     private renderFloatingMenu;
     private renderOverlays;
     /**
-     * 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
+     * Renders the Deepdesk widget in a container element.
+     *
+     * This method renders the main Deepdesk widget that contains suggestions,
+     * pinned messages, and other content. The widget will expand to fit the
+     * full height and width of the container element.
+     *
+     * **Important:** Make sure to set the container element to a fixed or minimum size
+     * (height and width) as the widget will grow to fill the container.
+     *
+     * **Note:** Only one widget can be rendered per SDK instance.
+     *
+     * @param containerElement - Element to render widget in
+     * @param options - Optional options for widget configuration
+     * @param options.customStyles - Custom styling for the widget
+     * @param options.showImages - Whether to show images in suggestions (default: false)
+     * @param options.isEmbedded - Whether the widget is embedded in another application
+     * @param options.knowledgeAssist - Knowledge assistant configuration
+     * @param options.assistantOptions - Assistant evaluation options
+     *
+     * @example
+     * ```typescript
+     * // Basic widget rendering
+     * const container = document.getElementById('widget-container');
+     * container.style.width = '400px';
+     * container.style.height = '600px';
+     *
+     * sdk.renderWidget(container);
+     *
+     * // Widget with custom options
+     * sdk.renderWidget(container, {
+     *   showImages: true,
+     *   isEmbedded: true,
+     *   customStyles: {
+     *     // Custom CSS classes
+     *   }
+     * });
+     *
+     * // Widget with knowledge assistant options
+     * sdk.renderWidget(container, {
+     *   knowledgeAssist: {
+     *     initialQuestion: 'How can I help you today?',
+     *     emptyState: {
+     *       title: 'No knowledge base available',
+     *       description: 'Please contact support for assistance.'
+     *     }
+     *   }
+     * });
+     * ```
      */
     renderWidget(containerElement: HTMLElement, options?: WidgetOptions): void;
+    /**
+     * Unmounts the widget and cleans up resources.
+     *
+     * This method removes the rendered widget from the DOM and cleans up
+     * all associated resources. It should be called when you're done using
+     * the widget.
+     *
+     * @example
+     * ```typescript
+     * // Unmount widget when switching views
+     * function switchToDifferentView() {
+     *   sdk.unmountWidget();
+     *   // Render different content in the container
+     * }
+     * ```
+     */
     unmountWidget(): void;
+    /**
+     * Renders a knowledge assistant widget.
+     *
+     * This method renders a specialized widget for knowledge assistant functionality,
+     * which allows users to ask questions and get responses about a knowledge base.
+     * The widget includes a feed for displaying responses and an input field for
+     * asking questions.
+     *
+     * Unlike the main widget, this creates a standalone knowledge assistant that
+     * can be used independently of a conversation.
+     *
+     * @param assistantCode - The assistant code to use for knowledge assistance
+     * @param containerElement - Element to render the knowledge assistant widget in
+     * @param options - Optional widget configuration options
+     * @param options.customStyles - Custom styling for the widget
+     * @param options.initialQuestion - Initial question to display
+     * @param options.emptyState - Custom empty state configuration
+     * @param options.isLegacyKnowledgeAssist - Whether to use legacy knowledge assistant (default: false)
+     * @param options.title - Custom title for the widget
+     * @returns Object with unmount function to clean up the widget
+     *
+     * @example
+     * ```typescript
+     * // Basic knowledge assistant widget
+     * const container = document.getElementById('knowledge-container');
+     * const widget = sdk.renderKnowledgeAssistantWidget(
+     *   'knowledge-assistant-123',
+     *   container
+     * );
+     *
+     * // Knowledge assistant with custom options
+     * const widget = sdk.renderKnowledgeAssistantWidget(
+     *   'knowledge-assistant-456',
+     *   container,
+     *   {
+     *     initialQuestion: 'How can I help you today?',
+     *     title: 'Support Knowledge Base',
+     *     emptyState: {
+     *       title: 'No knowledge available',
+     *       description: 'Please contact support for assistance.'
+     *     },
+     *     customStyles: {
+     *       // Custom styling
+     *     }
+     *   }
+     * );
+     * ```
+     */
     renderKnowledgeAssistantWidget(assistantCode: string, containerElement: HTMLElement, options?: KnowledgeAssistantWidgetOptions): {
         unmount(): void;
     };
@@ -2355,11 +3379,71 @@ declare class DeepdeskSDK {
     private handleError;
     private loadProfileConfigPromise;
     private loadProfileConfig;
+    /**
+     * Authenticates user via popup window.
+     *
+     * This method opens a popup window that goes through a configured SSO (Single Sign-On)
+     * flow. The popup window will handle the authentication process and automatically
+     * close itself when the user is successfully logged in.
+     *
+     * This is typically used when you want to provide a more seamless authentication experience without
+     * redirecting the entire page.
+     *
+     * **Note:** The platform url must be correctly configured in the account settings.
+     *
+     * @param options - Optional authentication options
+     * @param options.url - Custom URL for the SSO flow (optional, uses default if not provided)
+     * @returns Promise that resolves when authentication is complete
+     *
+     * @example
+     * ```typescript
+     * // Basic popup login
+     * try {
+     *   await sdk.loginViaPopup();
+     *   console.log('User logged in successfully');
+     * } catch (error) {
+     *   console.log('Login failed or was cancelled:', error.message);
+     * }
+     * ```
+     *
+     * @throws {Error} 'Popup blocked by browser' if popup is blocked by browser
+     * @throws {Error} 'Popup closed by user' if popup is closed by user
+     * @throws {Error} 'Timeout' If authentication fails or times out
+     */
     loginViaPopup(options?: {
         url?: string;
     }): Promise<void>;
+    /**
+     * Translates messages
+     *
+     * This method allows you to translate text messages using Deepdesk's
+     * translation service. It's useful for translating messages between
+     * different languages in multi-language support scenarios.
+     *
+     * @param params - Translation request parameters
+     * @param params.targetLanguage - The target language code (e.g., 'en', 'es', 'fr')
+     * @param params.messages - A list of strings to translate. Each string will be translated to the target language.
+     * @returns Promise that resolves to translation response.
+     *          Each response will have the original (detected) language and the target language.
+     *          And the translated text.
+     *
+     * @example
+     * ```typescript
+     * // Translate a message from English to Spanish
+     * const translations = await sdk.translateMessages({
+     *   messages: ['Hello, how can I help you?', 'I have a problem with my order'],
+     *   targetLanguage: 'es'
+     * });
+     *
+     * console.log('Translation:', translations[0]);
+     * // {
+     * //   translation: 'Hola, ¿cómo puedo ayudarte?'
+     * //   originalLanguage: 'en',
+     * //   targetLanguage: 'es',
+     * // }
+     * ```
+     */
     translateMessages(params: TranslationRequest): Promise<TranslationResponse>;
-    checkForTrialMode(agentId: string): Promise<void>;
     private refreshTextSuggestions;
     private refreshWidgetSuggestions;
 }