@sendbird/ai-agent-messenger-react-native 1.8.0 → 1.9.0

package/dist/index.d.ts

@@ -1,10 +1,13 @@
 import { Action } from '@sendbird/uikit-message-template';
 import { AIAgentChannelFilter } from '@sendbird/chat/aiAgent';
+import { AIAgentGroupChannelListQuery } from '@sendbird/chat/aiAgent';
 import { AIAgentModule } from '@sendbird/chat/aiAgent';
+import { BaseChannel } from '@sendbird/chat';
 import { BaseMessage } from '@sendbird/chat/message';
 import type * as CommunityDocumentPicker from '@react-native-documents/picker';
 import type * as CommunityImagePicker from 'react-native-image-picker';
 import { ComponentType } from 'react';
+import { ConnectionHandler } from '@sendbird/chat';
 import { Context } from 'react';
 import { Conversation as Conversation_2 } from '@sendbird/chat/aiAgent';
 import { ConversationStatus } from '@sendbird/chat/aiAgent';
@@ -17,6 +20,9 @@ import { FlatList } from 'react-native';
 import { FlatListProps } from 'react-native';
 import { ForwardRefExoticComponent } from 'react';
 import { GroupChannel } from '@sendbird/chat/groupChannel';
+import { GroupChannelChangelogs } from '@sendbird/chat/aiAgent';
+import { GroupChannelHandler } from '@sendbird/chat/groupChannel';
+import { GroupChannelListOrder } from '@sendbird/chat/groupChannel';
 import { GroupChannelModule } from '@sendbird/chat/groupChannel';
 import { JSX } from 'react/jsx-runtime';
 import { LayoutChangeEvent } from 'react-native';
@@ -262,7 +268,11 @@ declare interface AIAgentConfig {
 declare interface AIAgentContextValue {
     appId: string;
     aiAgentId: string;
+
+    /** @internal Do not use directly. This is an internal SDK instance. */
+    _aiAgentSDK: AIAgentInterface;
     chatSDK: SendbirdChatWith<[GroupChannelModule, AIAgentModule]>;
+    deskClient: DeskClientInterface;
 
     language: string;
     countryCode?: string;
@@ -374,6 +384,80 @@ declare interface AIAgentInfo {
     isUserFeedbackCommentOptionEnabled: boolean;
 }
 
+/**
+ * Public interface for AIAgent SDK instance.
+ * This interface exposes the public API of the AIAgent class.
+ */
+declare interface AIAgentInterface {
+    /** Sendbird application ID */
+    readonly appId: string;
+    /** AI Agent ID */
+    readonly aiAgentId: string;
+
+    /** The underlying Sendbird Chat SDK instance */
+    readonly chatSDK: ChatSDKType;
+    /** The current authenticated session. `null` if not authenticated */
+    readonly session: AIAgentSession | null;
+    /** The Desk client. Available after authenticate(). */
+    readonly deskClient: DeskClientInterface;
+    // TODO: Change to `AIAgentConfig` (non-optional) once the context migration lands and all usages are updated
+    /** The AI Agent configuration */
+    config: AIAgentConfig | undefined;
+    /** The query parameters for AI Agent */
+    queryParams?: AIAgentQueryParams;
+    /** The adapter for detecting online/offline network state */
+    readonly networkStateAdapter: NetworkStateAdapter | undefined;
+    /** The logger instance */
+    readonly logger: Loggable;
+    /** The event dispatcher */
+    readonly dispatcher: Dispatcher;
+    /** The cache instance */
+    readonly cache: AIAgentCache;
+    /** The language setting */
+    language: string;
+    /** The country code setting */
+    countryCode?: string;
+    /** The context object for AI Agent */
+    context?: Record<string, string>;
+
+    /** @internal Stats trackers for performance monitoring */
+    readonly statsTrackers: {
+        initialRender: ConversationInitialRenderStatsTracker;
+    };
+
+    /** Authenticates with the AI Agent server and establishes a session */
+    authenticate: (sessionInfo: ManualSessionInfo | AnonymousSessionInfo) => Promise<MessengerSettingsResponse>;
+    /** Disconnects from the AI Agent server and clears the session */
+    deauthenticate: () => Promise<void>;
+    /** Creates a new conversation with the AI Agent */
+    createConversation: (params: ConversationCreateParams) => Promise<string>;
+    /** Searches for open conversations that match the specified context */
+    searchConversation: (params: SearchConversationParams) => Promise<string[]>;
+    /** Closes an open conversation */
+    closeConversation: (channelUrl: string) => Promise<void>;
+    /** Creates a collection for paginating through conversations */
+    createConversationListCollection: (params?: ConversationListCollectionParams) => ConversationListCollection;
+    /** Patches (merges) context data for the specified channel */
+    patchContext: (channelUrl: string, context: Record<string, string>) => Promise<ContextObject>;
+    /** Replaces the entire context data for the specified channel */
+    updateContext: (channelUrl: string, context: Record<string, string>) => Promise<ContextObject>;
+    /** Retrieves the context data for the specified channel */
+    getContextObject: (channelUrl: string) => Promise<ContextObject>;
+
+    /** @internal Refreshes the active channel by re-requesting messenger settings */
+    refreshActiveChannel: (options?: { useKnownActiveChannelUrl?: boolean }) => Promise<string>;
+
+    /** Disposes all resources held by this instance (WebSocket, desk auth, event handlers). */
+    dispose: () => void;
+
+    /** Registers a handler for messenger settings updates */
+    onMessengerSettingsUpdated: (handler: (params: MessengerSettingsUpdatedParams) => void) => () => void;
+    /** Registers a handler for active channel updates */
+    onActiveChannelUpdated: (handler: (params: ActiveChannelUpdatedParams) => void) => () => void;
+    /** Registers a handler for auth token refresh events */
+    onAuthTokenRefreshed: (handler: (params: AuthTokenRefreshedParams) => void) => () => void;
+}
+
 declare interface AIAgentMessengerSessionContextValue {
     userSessionInfo?: UserSessionInfo | ManualSessionInfo | AnonymousSessionInfo;
 
@@ -500,6 +584,68 @@ declare interface AIAgentQueryParams {
     conversationListParams?: ConversationListCollectionParams;
 }
 
+/**
+ * @description Represents an authenticated session state. Created after successful authentication.
+ */
+declare class AIAgentSession {
+    private readonly _sdkUser: User;
+    private readonly _userSession: UserSession;
+    private readonly _dispatcher: Dispatcher;
+    private _activeChannel: ActiveChannel;
+
+    constructor(params: AIAgentSessionParams) {
+        this._sdkUser = params.sdkUser;
+        this._userSession = params.userSession;
+        this._dispatcher = params.dispatcher;
+        this._activeChannel = params.activeChannel;
+    }
+
+    /**
+     * The authenticated Sendbird user.
+     */
+    get sdkUser(): User {
+        return this._sdkUser;
+    }
+
+    /**
+     * The current user session containing userId and authToken.
+     */
+    get userSession(): UserSession {
+        return this._userSession;
+    }
+
+    /**
+     * The currently active channel.
+     */
+    get activeChannel(): ActiveChannel {
+        return this._activeChannel;
+    }
+
+    /**
+     * Updates the active channel and dispatches ActiveChannelUpdated event.
+     * @internal
+     */
+    _updateActiveChannel = (channel: ActiveChannel): void => {
+        this._activeChannel = channel;
+        this._dispatcher.send(
+        DispatcherCommands.ActiveChannelUpdated({
+            channelUrl: channel.url,
+            status: channel.status,
+            conversationStatus: channel.conversationStatus,
+        }),
+        );
+    };
+
+    /**
+     * Updates the auth token when session is refreshed.
+     * @internal
+     */
+    _updateAuthToken = (authToken: string): void => {
+        this._userSession.authToken = authToken;
+        this._dispatcher.send(DispatcherCommands.AuthTokenRefreshed());
+    };
+}
+
 /**
  * AI Agent session handler.
  * */
@@ -507,6 +653,13 @@ declare interface AIAgentSessionHandler extends SessionHandler {
     onExternalAuthTokenExpired?: (data: ExternalAuthTokenExpiredData) => void;
 }
 
+declare interface AIAgentSessionParams {
+    sdkUser: User;
+    userSession: UserSession;
+    activeChannel: ActiveChannel;
+    dispatcher: Dispatcher;
+}
+
 declare interface AIAgentStatPayload {
     key: string;
     value?: string;
@@ -623,6 +776,8 @@ declare interface AttachmentRules {
     getUploadSizeLimitInMB: (mimeType: string) => number;
 }
 
+declare interface AuthTokenRefreshedParams {}
+
 declare abstract class BaseCommand {
     abstract type: CommandType;
     payload: any;
@@ -699,6 +854,8 @@ export declare interface BottomSheetTemplateProps {
 declare interface CameraOptions {
 }
 
+declare type ChatSDKType = SendbirdChatWith<[GroupChannelModule, AIAgentModule]>;
+
 declare interface CitationInfo {
     embedding_id: number;
     source_type: string;
@@ -716,6 +873,7 @@ declare interface CommandPayloads {
     [CommandType.MessengerSettingsUpdated]: MessengerSettingsUpdatedParams;
     [CommandType.ActiveChannelUpdated]: ActiveChannelUpdatedParams;
     [CommandType.AnonymousSessionTokenExpired]: undefined;
+    [CommandType.AuthTokenRefreshed]: AuthTokenRefreshedParams;
 }
 
 declare enum CommandType {
@@ -723,6 +881,7 @@ declare enum CommandType {
     MessengerSettingsUpdated = 'messenger.settings.updated',
     ActiveChannelUpdated = 'active.channel.updated',
     AnonymousSessionTokenExpired = 'anon.token.expired',
+    AuthTokenRefreshed = 'auth.token.refreshed',
 }
 
 declare type CommunityDocumentPickerModule = typeof CommunityDocumentPicker;
@@ -1018,6 +1177,385 @@ export declare const ConversationLayout: {
 
 export declare const ConversationList: ({ children, ...props }: ConversationListContextProps) => JSX.Element;
 
+/**
+ * A collection for managing AI agent group channels with real-time updates and pagination.
+ * Automatically separates pinned and non-pinned channels, with pinned channels prioritized at the top.
+ */
+declare class ConversationListCollection {
+    /** The filter configuration used for this collection */
+    readonly filter?: AIAgentGroupChannelFilter;
+
+    private _sdk: ChatSDKType;
+    private _pinnedChannels: GroupChannel[];
+    private _channels: GroupChannel[];
+
+    private _isDisposed = false;
+    private _handlerId = `handler-id-${Date.now()}`;
+    private _order: GroupChannelListOrder = GroupChannelListOrder.LATEST_LAST_MESSAGE;
+
+    private _limit: number;
+    private _query: AIAgentGroupChannelListQuery;
+
+    private _token: string;
+    private _timestamp: number;
+    private _isSyncing: boolean;
+
+    private _channelHandler: GroupChannelHandler;
+    private _connectionHandler: ConnectionHandler;
+    private _collectionEventHandler?: ConversationListCollectionEventHandler;
+    private _throttledOnChannelChanged: ThrottledFunction<(channel: BaseChannel) => void>;
+
+    /**
+     * Creates a new ConversationListCollection instance.
+     * @param sdk - The Sendbird Chat SDK instance
+     * @param params - Configuration parameters for the collection
+     */
+    constructor(sdk: ChatSDKType, { filter, limit = 20 }: ConversationListCollectionParams) {
+        this.filter = filter;
+
+        this._sdk = sdk;
+        this._pinnedChannels = [];
+        this._channels = [];
+
+        this._limit = limit;
+        this._query = this._sdk.aiAgent.createMyGroupChannelListQuery({
+            aiAgentChannelFilter: this.filter?.aiAgentChannelFilter,
+            aiAgentConversationStatusFilter: this.filter?.aiAgentConversationStatusFilter,
+            aiAgentIds: this.filter?.aiAgentIds,
+            deskChannelFilter: this.filter?.deskChannelFilter,
+            pinnedChannelUrls: this.filter?.pinnedChannelUrls,
+            copilotConversationOnly: this.filter?.copilotConversationOnly,
+            copilotSupportChannelUrl: this.filter?.copilotSupportChannelUrl,
+            limit: this._limit,
+        });
+
+        this._token = '';
+        this._timestamp = Number.MAX_SAFE_INTEGER;
+        this._isSyncing = false;
+
+        this._throttledOnChannelChanged = throttle(
+        (channel: GroupChannel) => {
+            if (this._query.belongsTo(channel)) {
+                this._addChannelsToView([channel], false);
+            } else {
+                this._removeChannelsFromView([channel.url]);
+            }
+        },
+        250,
+            { trailing: false, leading: true },
+        );
+
+        this._channelHandler = new GroupChannelHandler({
+            onChannelChanged: (channel) => {
+                if (!channel.isGroupChannel()) return;
+                this._throttledOnChannelChanged(channel);
+            },
+            onChannelDeleted: (channelUrl) => {
+                this._removeChannelsFromView([channelUrl]);
+            },
+        });
+
+        this._connectionHandler = new ConnectionHandler({
+            onReconnectSucceeded: () => {
+                if (this._isDefaultChangelogSyncTimestampUpdated) this._syncChannelChangelogs();
+            },
+        });
+
+        this._sdk.addConnectionHandler(this._handlerId, this._connectionHandler);
+        this._sdk.groupChannel.addGroupChannelHandler(this._handlerId, this._channelHandler);
+    }
+
+    /**
+     * Checks if the default changelog sync timestamp has been updated.
+     */
+    private get _isDefaultChangelogSyncTimestampUpdated() {
+        return this._timestamp !== Number.MAX_SAFE_INTEGER;
+    }
+
+    /**
+     * Sets the default changelog sync timestamp based on the first non-pinned channel.
+     * @param channels - Array of channels to analyze
+     */
+    private _setDefaultChangelogsSyncTimestamp(channels: GroupChannel[]) {
+        const pinnedUrlsSet = new Set(this.filter?.pinnedChannelUrls ?? []);
+        const firstChannel = channels.find((it) => {
+            return !pinnedUrlsSet.has(it.url);
+        });
+
+        let candidate: number;
+        if (firstChannel) {
+            candidate = firstChannel.lastMessage?.createdAt ?? firstChannel.createdAt;
+        } else {
+            candidate = this._query.lastResponseAt;
+        }
+
+        if (this._timestamp > candidate) {
+            this._timestamp = candidate;
+        }
+    }
+
+    /**
+     * Synchronizes channel changelogs to keep the collection up-to-date.
+     * @returns Promise that resolves to an empty array
+     */
+    private async _syncChannelChangelogs(): Promise<GroupChannel[]> {
+        if (this._isDisposed) return [];
+        if (this._isSyncing) return [];
+
+        try {
+            this._isSyncing = true;
+            let response: GroupChannelChangelogs;
+
+            if (this._token) {
+                response = await this._sdk.aiAgent.getMyGroupChannelChangeLogsByToken(this._token, this.filter);
+            } else {
+                response = await this._sdk.aiAgent.getMyGroupChannelChangeLogsByTimestamp(this._timestamp, this.filter);
+            }
+            this._token = response.token;
+            this._addChannelsToView(response.updatedChannels);
+            this._removeChannelsFromView(response.deletedChannelUrls);
+
+            while (response.hasMore && !!response.token) {
+                response = await this._sdk.aiAgent.getMyGroupChannelChangeLogsByToken(this._token, this.filter);
+                this._token = response.token;
+                this._addChannelsToView(response.updatedChannels);
+                this._removeChannelsFromView(response.deletedChannelUrls);
+            }
+        } catch (error) {
+            // Silently handle changelog sync errors to prevent disrupting the collection
+            // The collection will continue to work with existing data
+        } finally {
+            this._isSyncing = false;
+        }
+        return [];
+    }
+
+    /**
+     * Upserts pinned channels maintaining the order specified in pinnedChannelUrls.
+     * @param channels - Pinned channels to upsert
+     * @returns Object containing added, updated channels and unmatched URLs
+     */
+    private _upsertPinnedChannelsToArray(channels: GroupChannel[]): {
+        addedChannels: GroupChannel[];
+        updatedChannels: GroupChannel[];
+        unmatchedChannelUrls: string[];
+    } {
+        const pinnedUrls = this.filter?.pinnedChannelUrls ?? [];
+        const pinnedIndexMap = new Map(pinnedUrls.map((url, index) => [url, index]));
+
+        const addedChannels: GroupChannel[] = [];
+        const updatedChannels: GroupChannel[] = [];
+        const unmatchedChannelUrls: string[] = [];
+
+        for (const channel of channels) {
+            if (!this._query.belongsTo(channel)) {
+                unmatchedChannelUrls.push(channel.url);
+                continue;
+            }
+
+            const targetIndex = pinnedIndexMap.get(channel.url);
+            if (targetIndex === undefined) continue;
+
+            const existingPosition = indexOfChannel(this._pinnedChannels, channel);
+            const isExisting = existingPosition >= 0;
+
+            if (isExisting) {
+                this._pinnedChannels.splice(existingPosition, 1);
+                updatedChannels.push(channel);
+            } else {
+                addedChannels.push(channel);
+            }
+
+            const insertPosition = this._pinnedChannels.findIndex((existingChannel) => {
+                const existingIndex = pinnedIndexMap.get(existingChannel.url) ?? Infinity;
+                return existingIndex > targetIndex;
+            });
+
+            const finalPosition = insertPosition === -1 ? this._pinnedChannels.length : insertPosition;
+            this._pinnedChannels.splice(finalPosition, 0, channel);
+        }
+
+        return { addedChannels, updatedChannels, unmatchedChannelUrls };
+    }
+
+    /**
+     * Upserts regular (non-pinned) channels with time-based sorting.
+     * @param channels - Regular channels to upsert
+     * @param forceAppend - Whether to force append channels at the end regardless of hasMore status
+     * @returns Object containing added, updated channels and unmatched URLs
+     */
+    private _upsertRegularChannelsToArray(
+    channels: GroupChannel[],
+    forceAppend = false,
+    ): { addedChannels: GroupChannel[]; updatedChannels: GroupChannel[]; unmatchedChannelUrls: string[] } {
+        const unmatchedChannelUrls: string[] = [];
+
+        const addedChannels: GroupChannel[] = [];
+        const updatedChannels: GroupChannel[] = [];
+
+        for (const channel of channels) {
+            if (!this._query.belongsTo(channel)) {
+                unmatchedChannelUrls.push(channel.url);
+                continue;
+            }
+
+            const oldPosition = indexOfChannel(this._channels, channel);
+            const isNewChannel = oldPosition < 0;
+            const shouldRemoveBeforeInsert = !isNewChannel;
+
+            if (shouldRemoveBeforeInsert) {
+                this._channels.splice(oldPosition, 1);
+            }
+
+            const insertionIndex = placeOfChannel(this._channels, channel, this._order).place;
+            const isAtEnd = insertionIndex === this._channels.length;
+
+            if (isNewChannel) {
+                if (isAtEnd) {
+                    if (forceAppend || !this.hasMore) {
+                        this._channels.push(channel);
+                        addedChannels.push(channel);
+                    }
+                } else {
+                    this._channels.splice(insertionIndex, 0, channel);
+                    addedChannels.push(channel);
+                }
+            } else {
+                this._channels.splice(insertionIndex, 0, channel);
+                updatedChannels.push(channel);
+            }
+        }
+
+        return { addedChannels, updatedChannels, unmatchedChannelUrls };
+    }
+
+    /**
+     * Adds or updates channels in the collection, separating pinned and non-pinned channels.
+     * @param channels - Channels to add or update
+     * @param forceAppend - Whether to force append channels at the end
+     */
+    private _addChannelsToView(channels: GroupChannel[], forceAppend = false): void {
+        const pinnedUrlsSet = new Set(this.filter?.pinnedChannelUrls ?? []);
+
+        const pinnedChannels: GroupChannel[] = [];
+        const regularChannels: GroupChannel[] = [];
+
+        for (const channel of channels) {
+            if (pinnedUrlsSet.has(channel.url)) {
+                pinnedChannels.push(channel);
+            } else {
+                regularChannels.push(channel);
+            }
+        }
+
+        const pinnedResult = this._upsertPinnedChannelsToArray(pinnedChannels);
+        const regularResult = this._upsertRegularChannelsToArray(regularChannels, forceAppend);
+
+        const addedChannels = pinnedResult.addedChannels.concat(regularResult.addedChannels);
+        const updatedChannels = pinnedResult.updatedChannels.concat(regularResult.updatedChannels);
+        const unmatchedChannelUrls = pinnedResult.unmatchedChannelUrls.concat(regularResult.unmatchedChannelUrls);
+
+        if (addedChannels.length > 0) this._collectionEventHandler?.onChannelsAdded?.({}, addedChannels);
+        if (updatedChannels.length > 0) this._collectionEventHandler?.onChannelsUpdated?.({}, updatedChannels);
+        if (unmatchedChannelUrls.length > 0) this._removeChannelsFromView(unmatchedChannelUrls);
+    }
+
+    /**
+     * Removes channels from the collection by their URLs.
+     * @param channelUrls - Array of channel URLs to remove
+     */
+    private _removeChannelsFromView(channelUrls: string[]) {
+        const pinnedUrlsSet = new Set(this.filter?.pinnedChannelUrls ?? []);
+        const removedChannelUrls: string[] = [];
+
+        for (const channelUrl of channelUrls) {
+            if (pinnedUrlsSet.has(channelUrl)) {
+                const index = this._pinnedChannels.findIndex((channel) => channel.url === channelUrl);
+                if (index >= 0) {
+                    removedChannelUrls.push(channelUrl);
+                    this._pinnedChannels.splice(index, 1);
+                }
+            } else {
+                const index = this._channels.findIndex((channel) => channel.url === channelUrl);
+                if (index >= 0) {
+                    removedChannelUrls.push(channelUrl);
+                    this._channels.splice(index, 1);
+                }
+            }
+        }
+
+        if (removedChannelUrls.length > 0) this._collectionEventHandler?.onChannelsDeleted?.({}, removedChannelUrls);
+    }
+
+    /**
+     * Gets all channels in the collection.
+     * Pinned channels are always returned first, followed by non-pinned channels.
+     * @returns Array of GroupChannel objects
+     */
+    public get channels(): GroupChannel[] {
+        return this._isDisposed ? [] : [...this._pinnedChannels, ...this._channels];
+    }
+
+    /**
+     * Indicates whether the collection has more channels to load.
+     * @returns True if more channels can be loaded, false otherwise
+     */
+    public get hasMore(): boolean {
+        return this._isDisposed ? false : this._query.hasNext;
+    }
+
+    /**
+     * Loads the next batch of channels from the server.
+     * @returns Promise that resolves to an array of newly loaded channels
+     */
+    public async loadMore(): Promise<GroupChannel[]> {
+        if (this._isDisposed) return [];
+
+        if (this.hasMore) {
+            const channels = await this._query.next();
+
+            this._setDefaultChangelogsSyncTimestamp(channels);
+            this._addChannelsToView(channels, true);
+            return channels;
+        }
+
+        return [];
+    }
+
+    /**
+     * Sets the event handler for collection updates.
+     * @param handler - Event handler for channel collection changes
+     */
+    public setConversationListCollectionHandler(handler: ConversationListCollectionEventHandler): void {
+        this._collectionEventHandler = handler;
+    }
+
+    /**
+     * Disposes the collection and cleans up all resources.
+     * Stops all event handlers and clears all channels.
+     */
+    public dispose(): void {
+        if (this._isDisposed) return;
+
+        this._isDisposed = true;
+        this._throttledOnChannelChanged.cancel();
+        this._collectionEventHandler = undefined;
+        this._sdk.removeConnectionHandler(this._handlerId);
+        this._sdk.groupChannel.removeGroupChannelHandler(this._handlerId);
+        this._pinnedChannels.length = 0;
+        this._channels.length = 0;
+    }
+}
+
+declare interface ConversationListCollectionEventHandler {
+    /** Called when there are newly added {@link GroupChannel}s. */
+    onChannelsAdded?: (context: ConversationListContext_2, channels: GroupChannel[]) => void;
+    /** Called when there's an update in one or more of the {@link GroupChannel}s that `GroupChannelCollection` holds. */
+    onChannelsUpdated?: (context: ConversationListContext_2, channels: GroupChannel[]) => void;
+    /** Called when one or more of the {@link GroupChannel}s that `GroupChannelCollection` holds has been deleted. */
+    onChannelsDeleted?: (context: ConversationListContext_2, channelUrls: string[]) => void;
+}
+
 /**
  * Parameters for creating a ConversationListCollection instance.
  */
@@ -1030,6 +1568,8 @@ declare interface ConversationListCollectionParams {
 
 export declare const ConversationListContext: Context<ConversationListContextValue | null>;
 
+declare interface ConversationListContext_2 {}
+
 declare interface ConversationListContextProps extends PropsWithChildren {
     conversationListLimit?: number;
     conversationListFilter?: Partial<AIAgentGroupChannelFilter>;
@@ -1216,6 +1756,68 @@ export declare interface DateSeparatorProps extends ViewProps {
     date?: Date | number;
 }
 
+export declare interface DeskClientInterface {
+    /** Gets a ticket by its ID. */
+    getTicket(id: number): Promise<DeskTicketInterface>;
+}
+
+export declare interface DeskTicketAgent {
+    /** The agent's user ID. */
+    readonly userId: string;
+    /** The agent's display name. */
+    readonly name: string;
+    /** The agent's profile image URL. */
+    readonly profileUrl: string;
+}
+
+export declare interface DeskTicketInterface {
+    /** The ticket ID. */
+    readonly id: number;
+    /** The ticket title. */
+    readonly title: string | null;
+    /** The ticket status. Corresponds to the Desk Ticket's `status2` value. */
+    readonly status: DeskTicketStatus;
+    /** The agent assigned to this ticket. */
+    readonly agent: DeskTicketAgent | null;
+    /** The ticket priority. */
+    readonly priority: DeskTicketPriority;
+    /** The ticket group. */
+    readonly group: number;
+    /** The first response time in seconds. Returns -1 if there is no response. */
+    readonly firstResponseTime: number;
+    /** The timestamp when the ticket was issued. */
+    readonly issuedAt: string | null;
+    /** Custom fields set on this ticket. */
+    readonly customFields: Record<string, string>;
+    /** Refreshes all the data of this ticket from the server. */
+    refresh(): Promise<DeskTicketInterface>;
+}
+
+export declare enum DeskTicketPriority {
+    URGENT = 'URGENT',
+    HIGH = 'HIGH',
+    /** This is the default. */
+    MEDIUM = 'MEDIUM',
+    LOW = 'LOW',
+}
+
+export declare enum DeskTicketStatus {
+    /** Ticket has been created, but the customer has not started chatting yet. */
+    INITIALIZED = 'INITIALIZED',
+    /** Ticket created via proactive chat. */
+    PROACTIVE = 'PROACTIVE',
+    /** No agent has been assigned yet. */
+    PENDING = 'PENDING',
+    /** An agent has been assigned and the ticket is being handled. */
+    ACTIVE = 'ACTIVE',
+    /** The ticket has been closed. */
+    CLOSED = 'CLOSED',
+    /** The ticket is in progress. */
+    WORK_IN_PROGRESS = 'WORK_IN_PROGRESS',
+    /** The assignment is in an idle state. */
+    IDLE = 'IDLE',
+}
+
 declare interface Dispatcher {
     send(command: BaseCommand): Promise<void>;
     subscribe<E extends CommandType>(eventType: E, callback: (payload: CommandPayloads[E]) => void | Promise<void>): void;
@@ -2767,6 +3369,8 @@ declare interface MessengerSettingsResponse {
         supported_file_mime_types: string[];
         max_attachment_count?: number;
     };
+    language: string | null;
+    country: string | null;
 }
 
 declare interface MessengerSettingsUpdatedParams {
@@ -3216,6 +3820,11 @@ declare type TextField = {
     };
 };
 
+declare interface ThrottledFunction<T extends (...args: any[]) => any> {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+}
+
 declare interface TimerData {
     startTime: number | null;
     endTime: number | null;
@@ -3268,10 +3877,13 @@ export declare const useNativeAdapterContext: {
     displayName: string;
 };
 
-declare type UserSession = {
+/**
+ * User session containing authentication credentials.
+ */
+declare interface UserSession {
     userId: string;
     authToken: string;
-};
+}
 
 /**
  * @deprecated Please use `ManualSessionInfo` or `AnonymousSessionInfo` instead.