@aikaara/chat-sdk 0.2.0 → 0.3.3

package/dist/index.d.ts

@@ -41,14 +41,45 @@ export declare class AikaaraChatBubble extends HTMLElement {
 
 export declare class AikaaraChatClient extends EventEmitter<ChatEvents> {
     private connection;
+    private tiledesk;
     private api;
     private messageStore;
     private conversationManager;
     private subscription;
     private config;
-    constructor(config: ChatClientConfig);
+    private mode;
+    private uploadAdapter;
+    private historyAdapter;
+    private tiledeskUnsubs;
+    constructor(config: ChatClientConfig, opts?: {
+        uploadAdapter?: UploadAdapter;
+        historyAdapter?: ConversationHistoryAdapter;
+    });
+    private usesAikaara;
+    private usesTiledesk;
+    private initTiledeskTransport;
     connect(): Promise<void>;
-    sendMessage(content: string): Promise<void>;
+    private hydrateTiledeskHistory;
+    sendMessage(content: string, opts?: {
+        attributes?: Record<string, unknown>;
+        metadata?: Record<string, unknown>;
+    }): Promise<void>;
+    /**
+     * Upload a file via the configured UploadAdapter (client-side: file goes
+     * to the tenant's own backend, never through Aikaara). Then publish the
+     * Tiledesk file-message envelope so hooks_controller picks it up.
+     */
+    sendFile(file: File | Blob, opts?: {
+        caption?: string;
+    }): Promise<void>;
+    /**
+     * Trigger Tiledesk's CHAT_INITIATED event — required to kick off a bot flow
+     * for newly-created Tiledesk request groups.
+     */
+    initiateTiledeskChat(extraAttributes?: Record<string, unknown>): void;
+    /** Mark a Tiledesk message as read (publishes status=300 update). */
+    markTiledeskRead(messageId: string): void;
+    setUploadAdapter(adapter: UploadAdapter): void;
     sendUserEvent(eventKey: string, value?: object, source?: string): Promise<void>;
     loadHistory(): Promise<Message[]>;
     get messages(): Message[];
@@ -73,6 +104,8 @@ export declare class AikaaraChatClient extends EventEmitter<ChatEvents> {
      */
     setContext(context: AppContext): Promise<void>;
     disconnect(): Promise<void>;
+    private handleTiledeskMessage;
+    private handleTiledeskStatusUpdate;
     /**
      * Parse structured action results from tool execution output.
      * When the agent calls tools like `edit_current_entity`, `save_current_entity`,
@@ -94,17 +127,38 @@ export declare class AikaaraChatHeader extends HTMLElement {
     setStatus(status: string): void;
 }
 
+/**
+ * Chat input box. Composes a textarea + send button + optional attach button.
+ *
+ * Events fired (composed:true so they cross shadow boundaries):
+ *   - `send`      `{ content: string }`           — user pressed enter / clicked send
+ *   - `file-pick` `{ file: File }`                — user selected a file to upload
+ *
+ * Attributes:
+ *   - `placeholder`     placeholder text
+ *   - `disable-attach`  hides the attach button (set when host has no uploadAdapter)
+ *   - `accept`          forwarded to the hidden <input type="file">
+ *   - `multiple`        allow selecting multiple files
+ */
 export declare class AikaaraChatInput extends HTMLElement {
     private shadow;
     private textarea;
     private sendBtn;
+    private attachBtn;
+    private fileInput;
     private _disabled;
+    private _uploading;
     constructor();
+    static get observedAttributes(): string[];
     connectedCallback(): void;
     set disabled(val: boolean);
     get disabled(): boolean;
+    /** Toggle the attach button into a "uploading…" spinner state. */
+    set uploading(val: boolean);
+    get uploading(): boolean;
     focus(): void;
     clear(): void;
+    private refreshSendDisabled;
     private handleSend;
     private autoGrow;
 }
@@ -120,6 +174,8 @@ export declare class AikaaraChatWidget extends HTMLElement {
     attributeChangedCallback(_name: string, oldVal: string, newVal: string): void;
     configure(config: Partial<WidgetConfig>): void;
     private getConfig;
+    setUploadAdapter(adapter: UploadAdapter): void;
+    setHistoryAdapter(adapter: ConversationHistoryAdapter): void;
     private render;
     private initController;
     sendUserEvent(eventKey: string, value?: Record<string, unknown>, source?: string): void;
@@ -139,11 +195,19 @@ export declare class AikaaraErrorBanner extends HTMLElement {
 
 export declare class AikaaraMessageBubble extends HTMLElement {
     private shadow;
+    private templatePayload;
+    private attachments;
     static get observedAttributes(): string[];
     constructor();
     connectedCallback(): void;
     attributeChangedCallback(): void;
+    setTemplatePayload(payload: unknown): void;
+    setAttachments(attachments: Array<{
+        fileName: string;
+        fileUrl: string;
+    }>): void;
     private render;
+    private renderAttachments;
 }
 
 export declare class AikaaraMessageList extends HTMLElement {
@@ -162,6 +226,13 @@ export declare class AikaaraMessageList extends HTMLElement {
     showTypingIndicator(): void;
     removeTypingIndicator(): void;
     private appendMessageElement;
+    /**
+     * Replace an existing rendered message (matched by id or externalId) in place.
+     * Used when a Tiledesk self-echo reconciles with an optimistic bubble or when
+     * a status update flips delivered → read.
+     */
+    upsertMessage(message: Message): void;
+    private findRenderedMessage;
     private scrollToBottom;
     private formatTime;
 }
@@ -239,11 +310,37 @@ export declare interface ChatClientConfig extends ConnectionConfig {
     conversationId?: string;
     systemPromptId?: number;
     channel?: 'widget' | 'api' | 'sidekick';
+    /**
+     * Transport selection.
+     * - `aikaara` (default): ActionCable to Aikaara Rails (AI streaming).
+     * - `tiledesk`: MQTT direct to a self-hosted Tiledesk + chat21 stack.
+     * - `dual`: both — Aikaara cable for AI, Tiledesk MQTT for live-agent + file events.
+     */
+    transport?: TransportMode;
+    /**
+     * Tiledesk-side identity. Required when `transport` is `tiledesk` or `dual`.
+     * `userId` here is the Tiledesk user `_id` and is also used as the SDK conversation
+     * subject — Aikaara conversations bound to this user via ext_uid mapping.
+     */
+    tiledeskIdentity?: {
+        userId: string;
+        userName?: string;
+        departmentId?: string;
+        senderFullname?: string;
+    };
+    /**
+     * Tenant-level defaults merged into the `action` object of every template
+     * postback (e.g. submit-action click). Useful for app-specific keys like
+     * `serviceType: 'ITR'` that the bot expects on every form submission.
+     * Per-submit values from the form take precedence over these defaults.
+     */
+    templateActionAttributes?: Record<string, unknown>;
     onMessage?: (message: Message) => void;
     onStatusChange?: (status: string) => void;
     onError?: (error: Error) => void;
     onStreamUpdate?: (delta: string, fullContent: string) => void;
     onConnectionStateChange?: (state: ConnectionState) => void;
+    onTemplateMessage?: (template: TemplateMessageEvent) => void;
 }
 
 export declare interface ChatEvents {
@@ -284,6 +381,8 @@ export declare interface ChatEvents {
     };
 }
 
+export declare function clearPersistedConversationId(userId: string, projectId: string): void;
+
 export declare interface ConnectionConfig {
     baseUrl: string;
     wsUrl?: string;
@@ -315,6 +414,19 @@ export declare class ConnectionManager extends EventEmitter<ChatEvents> {
 
 export declare type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting';
 
+/**
+ * Pluggable adapter that hydrates prior conversation messages on connect.
+ * The SDK calls this once after MQTT subscribes so the user sees existing
+ * history before any new live messages arrive.
+ */
+export declare interface ConversationHistoryAdapter {
+    fetchMessages(conversationId: string, ctx: {
+        userId: string;
+        appId?: string;
+        projectId?: string;
+    }): Promise<TiledeskMessage[]>;
+}
+
 export declare class ConversationManager {
     private _conversationId;
     private persist;
@@ -331,6 +443,10 @@ declare interface CreateConversationResponse {
     status: string;
 }
 
+export declare function createFetchUploadAdapter(config: FetchUploadAdapterConfig): UploadAdapter;
+
+export declare function createTiledeskHistoryAdapter(config: TiledeskHistoryAdapterConfig): ConversationHistoryAdapter;
+
 export declare interface EditEntityAction {
     action: 'edit_entity';
     entity_type: string;
@@ -346,6 +462,18 @@ export declare class EventEmitter<Events extends Record<string, any>> {
     removeAllListeners(): void;
 }
 
+export declare function extractTiledeskFileEnvelope(message: TiledeskMessage): TiledeskFileEnvelope | null;
+
+export declare interface FetchUploadAdapterConfig {
+    endpoint: string;
+    method?: 'POST' | 'PUT';
+    fieldName?: string;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    credentials?: RequestCredentials;
+    extraFields?: Record<string, string> | ((ctx: UploadAdapterContext) => Record<string, string>);
+    parseResponse?: (raw: unknown, ctx: UploadAdapterContext) => UploadAdapterResult;
+}
+
 export declare interface FieldUpdate {
     field: string;
     value: unknown;
@@ -468,10 +596,19 @@ export declare interface FormRegistration {
     getCurrentValues: () => Record<string, unknown>;
 }
 
+export declare function inferTiledeskRole(message: TiledeskMessage, cfg: TiledeskRoleConfig): TiledeskRole;
+
+/**
+ * Self-echo detector — Tiledesk fans the user's outgoing publish back
+ * as a `clientadded` event on the same connection. UI must dedupe against
+ * the optimistic local message rather than rendering twice.
+ */
+export declare function isTiledeskSelfEcho(message: TiledeskMessage, userId: string): boolean;
+
 export declare interface Message {
     id: string;
     conversationId: string;
-    role: 'user' | 'assistant' | 'system' | 'tool';
+    role: 'user' | 'assistant' | 'system' | 'tool' | 'agent';
     content: string;
     toolCalls?: ToolCall[];
     toolCallResults?: ToolCallResult;
@@ -479,7 +616,19 @@ export declare interface Message {
     tokensOutput?: number;
     metadata?: Record<string, unknown>;
     createdAt: string;
-    status?: 'sending' | 'sent' | 'streaming' | 'complete' | 'error';
+    status?: 'sending' | 'sent' | 'delivered' | 'read' | 'streaming' | 'complete' | 'error';
+    externalId?: string;
+    template?: {
+        contentType?: string;
+        templateId?: string;
+        payload?: unknown;
+    };
+    attachments?: Array<{
+        fileName: string;
+        fileUrl: string;
+        cloudFileId?: string;
+        contentType?: string;
+    }>;
 }
 
 export declare class MessageStore {
@@ -487,6 +636,22 @@ export declare class MessageStore {
     private optimisticCounter;
     get messages(): Message[];
     addOptimistic(role: 'user', content: string, conversationId: string): Message;
+    /**
+     * Reconcile a remote message against an outstanding optimistic message.
+     * Tiledesk fans the user's outgoing publish back as an inbound clientadded —
+     * dedupe by exact content + recency window so the optimistic bubble keeps
+     * its position and we don't render duplicates.
+     */
+    reconcileOptimistic(remote: Message, recencyMs?: number): Message | null;
+    /**
+     * Append a remote-originated message (e.g. from Tiledesk MQTT). If a matching
+     * optimistic message exists it is reconciled in place; otherwise appended.
+     */
+    upsertRemoteMessage(remote: Message): {
+        message: Message;
+        deduped: boolean;
+    };
+    updateMessageStatus(externalId: string, status: Message['status']): Message | undefined;
     confirmOptimistic(tempId: string): void;
     addStreamingMessage(conversationId: string): Message;
     updateStreaming(content: string): void;
@@ -503,10 +668,26 @@ export declare class MessageStore {
 
 export declare function mount(config: WidgetConfig): AikaaraChatWidget;
 
+export declare interface MountedTenantWidget {
+    widget: AikaaraChatWidget;
+    requestId: string;
+    config: WidgetConfig;
+    destroy: () => void;
+}
+
+/**
+ * Standard tenant mount. Fetches the descriptor (when `configUrl` is set),
+ * merges per-mount overrides, builds default adapters from the descriptor's
+ * endpoint URLs (when no override is supplied), and mounts the widget.
+ */
+export declare function mountTenantWidget(opts: TenantMountOptions): Promise<MountedTenantWidget>;
+
 export declare interface NavigateAction {
     navigate_to: string;
 }
 
+export declare function parseTiledeskTemplate(message: TiledeskMessage): TiledeskParsedTemplate;
+
 export declare function registerComponents(): void;
 
 export declare interface SaveEntityAction {
@@ -515,44 +696,231 @@ export declare interface SaveEntityAction {
 
 declare type SubscriptionCallback = (data: unknown) => void;
 
+declare interface TemplateMessageEvent {
+    messageId: string;
+    conversationId: string;
+    role: 'user' | 'assistant' | 'system' | 'agent';
+    contentType?: string;
+    templateId?: string;
+    payload?: unknown;
+    innerMessage?: string;
+    raw: unknown;
+}
+
+export declare interface TenantMountOptions {
+    container: HTMLElement;
+    /** Fetched from this URL when `config` is omitted. */
+    configUrl?: string;
+    /** Pre-resolved descriptor — skip the fetch. */
+    config?: WidgetConfigDescriptor;
+    /** Headers attached when fetching `configUrl` (e.g. tenant-API auth). */
+    configHeaders?: Record<string, string>;
+    identity: {
+        userId: string;
+        userName?: string;
+        departmentId?: string;
+        senderFullname?: string;
+    };
+    /** Returns a raw Tiledesk JWT (no Bearer/JWT prefix) for MQTT password. */
+    tokenProvider: () => Promise<string>;
+    /** Authorization value for the history fetch. Defaults to `tokenProvider()`. */
+    historyTokenProvider?: () => Promise<string>;
+    /**
+     * Optional override adapters. If omitted and the descriptor specifies the
+     * matching endpoint, the SDK builds default fetch-based adapters.
+     */
+    uploadAdapter?: UploadAdapter;
+    historyAdapter?: ConversationHistoryAdapter;
+    /**
+     * Pin a conversationId. When omitted we look up
+     * `aikaara_chat:requestId:{userId}:{projectId}` in localStorage and reuse
+     * any persisted value; only mint a fresh `requestId` when nothing is stored.
+     */
+    conversationId?: string;
+    forceNewConversation?: boolean;
+    /** Per-mount overrides that take precedence over the descriptor. */
+    overrides?: Partial<WidgetConfigDescriptor>;
+    /** Surfaced from the SDK. */
+    onError?: (err: Error) => void;
+}
+
 export declare interface TestToolAction {
     action: 'test_tool';
     tool_id: number;
     parameters: Record<string, unknown>;
 }
 
+export declare interface TiledeskFileEnvelope {
+    fileName?: string;
+    fileUrl?: string;
+    cloudFileId?: string;
+    templateId?: string;
+}
+
+export declare interface TiledeskFileMessageInput {
+    fileName: string;
+    fileUrl: string;
+    cloudFileId?: string;
+    templateId?: string;
+    headerImgSrc?: string;
+    type?: 'link' | 'image';
+    isDeepLink?: boolean;
+    description?: string;
+    attributes?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+}
+
+export declare interface TiledeskFileTemplateConfig {
+    templateId: string;
+    headerImgSrc?: string;
+    type?: 'link' | 'image';
+    isDeepLink?: boolean;
+}
+
+export declare interface TiledeskHistoryAdapterConfig {
+    /**
+     * Base URL of the Tiledesk chat API, e.g. `https://uat-tiledesk.taxbuddy.com/chatapi/api`
+     * (no trailing slash). Final URL is composed as
+     *   `{apiBase}/tilechat/{userId}/conversations/{conversationId}/messages?pageSize={pageSize}`
+     */
+    apiBase: string;
+    pageSize?: number;
+    /**
+     * Async getter for the bearer token. Most Tiledesk-fronted gateways accept
+     * the same JWT used for the MQTT connection. Return `null` to omit the
+     * `Authorization` header.
+     */
+    getToken?: () => string | null | Promise<string | null>;
+    /** Override the path template. Default mirrors bandhan's chatapi route. */
+    pathTemplate?: string;
+    /** Extra static headers to attach (e.g. `partnerid`, `environment`). */
+    extraHeaders?: Record<string, string>;
+    /**
+     * Optional response shape mapper. Default expects
+     *   `{ success: true, result: TiledeskMessage[] }`
+     * which matches the bandhan `/chatapi/api/tilechat/.../messages` response.
+     */
+    parseResponse?: (raw: unknown) => TiledeskMessage[];
+}
+
 export declare interface TiledeskMessage {
     text?: string;
     type?: string;
     sender?: string;
     senderFullname?: string;
+    sender_fullname?: string;
     recipient?: string;
+    recipient_fullname?: string;
+    channel_type?: string;
     timestamp?: number;
+    app_id?: string;
+    message_id?: string;
+    status?: number;
     attributes?: Record<string, unknown>;
     metadata?: Record<string, unknown>;
     [key: string]: unknown;
 }
 
+export declare interface TiledeskMessageContext {
+    topic: string;
+    conversationId?: string;
+    messageId?: string;
+    kind: 'clientadded' | 'update' | 'unknown';
+}
+
+export declare interface TiledeskMessageDefaults {
+    channelType?: string;
+    channel?: string;
+    requestChannel?: string;
+    platform?: string;
+    medium?: string;
+    departmentId?: string;
+    attributes?: Record<string, unknown>;
+}
+
+export declare interface TiledeskParsedTemplate {
+    contentType?: string;
+    templateId?: string;
+    payload?: unknown;
+    innerMessage?: string;
+    raw: TiledeskMessage;
+}
+
+export declare type TiledeskRole = 'user' | 'assistant' | 'system' | 'agent';
+
+export declare interface TiledeskRoleConfig {
+    userId: string;
+    systemSenders?: string[];
+    botSenderPrefix?: string;
+}
+
+export declare interface TiledeskStatusUpdate {
+    conversationId: string;
+    messageId: string;
+    status: number;
+    raw: Record<string, unknown>;
+}
+
+export declare interface TiledeskTopicTemplates {
+    inbound?: string;
+    inboundUpdate?: string;
+    outbound?: string;
+    presence?: string;
+    wildcardSubscribe?: string;
+}
+
 export declare class TiledeskTransport {
     private client;
     private config;
+    private currentToken;
+    private clientId;
+    private appId;
+    private topics;
     private messageHandlers;
     private stateHandlers;
+    private statusUpdateHandlers;
     private subscribedTopics;
     private reconnectAttempt;
     private maxReconnectAttempts;
+    private reconnectMaxDelayMs;
     private disposed;
+    private reconnectTimer;
+    private inboundRegex;
+    private inboundUpdateRegex;
     constructor(config: TiledeskTransportConfig);
     connect(): Promise<void>;
+    private debugLog;
+    subscribeWildcard(): void;
     subscribeToConversation(conversationId: string): void;
     unsubscribeFromConversation(conversationId: string): void;
-    publishMessage(conversationId: string, text: string): void;
+    publishMessage(conversationId: string, text: string, overrides?: Partial<TiledeskMessage>): void;
+    publishFileMessage(conversationId: string, file: TiledeskFileMessageInput): void;
+    publishRaw(conversationId: string, message: TiledeskMessage): void;
+    /**
+     * Send a read receipt for a message. Tiledesk widgets publish
+     * `{"status":300}` to apps/{appId}/users/{userId}/messages/{convId}/{msgId}/update.
+     */
+    publishReadReceipt(conversationId: string, messageId: string, status?: number): void;
+    /**
+     * Trigger conversation kickoff. Tiledesk bot routing waits for the
+     * widget to publish a CHAT_INITIATED event before the bot replies.
+     */
+    publishChatInitiated(conversationId: string, extraAttributes?: Record<string, unknown>): void;
     onMessage(handler: TransportMessageHandler): () => void;
     onStateChange(handler: TransportStateHandler): () => void;
+    onStatusUpdate(handler: TransportStatusUpdateHandler): () => void;
     disconnect(): void;
     get isConnected(): boolean;
     private scheduleReconnect;
     private notifyStateChange;
+    private dispatchInbound;
+    private buildOutgoingEnvelope;
+    private publishEnvelope;
+    private renderInboundTopic;
+    private renderOutboundTopic;
+    private renderPresenceTopic;
+    private renderTemplate;
+    private buildTopicRegex;
 }
 
 export declare interface TiledeskTransportConfig {
@@ -561,6 +929,42 @@ export declare interface TiledeskTransportConfig {
     userId: string;
     userName?: string;
     projectId: string;
+    appId?: string;
+    clientId?: string;
+    protocolVersion?: 3 | 4 | 5;
+    protocolId?: 'MQIsdp' | 'MQTT';
+    mqttUsername?: string;
+    connectTimeoutMs?: number;
+    keepAliveSec?: number;
+    maxReconnectAttempts?: number;
+    reconnectMaxDelayMs?: number;
+    tokenProvider?: () => Promise<string>;
+    wildcardSubscribe?: boolean;
+    subscribeQos?: 0 | 1 | 2;
+    publishQos?: 0 | 1 | 2;
+    publishRetain?: boolean;
+    enablePresence?: boolean;
+    presencePayloadConnected?: Record<string, unknown>;
+    presencePayloadDisconnected?: Record<string, unknown>;
+    topicTemplates?: TiledeskTopicTemplates;
+    messageDefaults?: TiledeskMessageDefaults;
+    fileTemplate?: TiledeskFileTemplateConfig;
+    recipientFullnameResolver?: (conversationId: string) => string | undefined;
+    senderFullname?: string;
+    /**
+     * If true (default), AikaaraChatClient publishes a `CHAT_INITIATED` event
+     * to the conversation's outbound topic on first connect — but only when
+     * the conversation history is empty (so reload of an in-flight chat
+     * doesn't replay the kickoff).
+     */
+    autoInitiateOnEmpty?: boolean;
+    /** Extra attributes merged into the auto-fired CHAT_INITIATED envelope. */
+    chatInitiatedAttributes?: Record<string, unknown>;
+    /**
+     * Log decoded MQTT frames to console as they're sent/received.
+     * Off by default — set true for debugging Tiledesk wire traffic.
+     */
+    debug?: boolean;
 }
 
 export declare interface ToolCall {
@@ -577,12 +981,37 @@ export declare interface ToolCallResult {
     content: string;
 }
 
-export declare type TransportMessageHandler = (message: TiledeskMessage) => void;
+export declare type TransportMessageHandler = (message: TiledeskMessage, ctx: TiledeskMessageContext) => void;
+
+declare type TransportMode = 'aikaara' | 'tiledesk' | 'dual';
 
 export declare type TransportStateHandler = (connected: boolean) => void;
 
+export declare type TransportStatusUpdateHandler = (update: TiledeskStatusUpdate) => void;
+
 export declare function unmount(): void;
 
+export declare interface UploadAdapter {
+    upload(file: File | Blob, ctx: UploadAdapterContext): Promise<UploadAdapterResult>;
+}
+
+export declare interface UploadAdapterContext {
+    conversationId: string;
+    userId: string;
+    projectId?: string;
+    appId?: string;
+}
+
+export declare interface UploadAdapterResult {
+    url: string;
+    fileName: string;
+    cloudFileId?: string;
+    relativePath?: string;
+    contentType?: string;
+    byteSize?: number;
+    meta?: Record<string, unknown>;
+}
+
 export declare interface WidgetConfig extends ChatClientConfig {
     position?: 'bottom-right' | 'bottom-left';
     offset?: {
@@ -605,6 +1034,71 @@ export declare interface WidgetConfig extends ChatClientConfig {
     showBubble?: boolean;
     bubbleText?: string;
     bubbleIcon?: string;
+    uploadAdapter?: UploadAdapter;
+    historyAdapter?: ConversationHistoryAdapter;
+    /**
+     * Display mode:
+     *   - `popup` (default): floating bubble in the corner, click to open panel.
+     *   - `embed`: render the chat panel inline at the host element's location,
+     *     filling its container. Bubble + open/close animation are skipped.
+     */
+    display?: 'popup' | 'embed';
+}
+
+export declare interface WidgetConfigDescriptor {
+    /** Visuals */
+    display?: 'popup' | 'embed';
+    position?: 'bottom-right' | 'bottom-left';
+    primaryColor?: string;
+    title?: string;
+    subtitle?: string;
+    avatarUrl?: string;
+    width?: number;
+    height?: number;
+    borderRadius?: number;
+    fontFamily?: string;
+    welcomeMessage?: string;
+    placeholder?: string;
+    showTimestamps?: boolean;
+    persistConversation?: boolean;
+    /** Transport selection */
+    transport?: TransportMode;
+    /** Tiledesk wire config (JSON-serializable subset of TiledeskTransportConfig) */
+    tiledesk?: {
+        mqttEndpoint: string;
+        appId?: string;
+        projectId: string;
+        mqttUsername?: string;
+        protocolId?: 'MQIsdp' | 'MQTT';
+        protocolVersion?: 3 | 4 | 5;
+        keepAliveSec?: number;
+        connectTimeoutMs?: number;
+        maxReconnectAttempts?: number;
+        reconnectMaxDelayMs?: number;
+        wildcardSubscribe?: boolean;
+        enablePresence?: boolean;
+        autoInitiateOnEmpty?: boolean;
+        chatInitiatedAttributes?: Record<string, unknown>;
+        messageDefaults?: TiledeskMessageDefaults;
+        fileTemplate?: TiledeskFileTemplateConfig;
+        topicTemplates?: TiledeskTopicTemplates;
+        debug?: boolean;
+        /**
+         * Pattern for `support-group-…` requestId minted on first chat. Use
+         * `{projectId}` and `{uuid}` placeholders. Defaults to bandhan's
+         * `support-group-{projectId}-{uuid}`.
+         */
+        requestIdTemplate?: string;
+    };
+    /** Defaults merged into every form-action postback */
+    templateActionAttributes?: Record<string, unknown>;
+    /** Adapter endpoints — SDK builds the actual fetch calls */
+    uploadEndpoint?: string;
+    uploadFieldName?: string;
+    uploadExtraFields?: Record<string, string>;
+    historyApiBase?: string;
+    historyPageSize?: number;
+    historyPathTemplate?: string;
 }
 
 export { }