import { CometChatCardAction, CometChatCardThemeMode, CometChatCardThemeOverride } from '@cometchat/cards-react'; import * as React$1 from 'react'; import React__default, { ReactNode, ButtonHTMLAttributes, InputHTMLAttributes, Ref, CSSProperties, RefObject } from 'react'; import * as react_jsx_runtime from 'react/jsx-runtime'; import { FlagReason } from '@cometchat/chat-sdk-javascript'; type CometChatPresenceSubscription = 'ALL_USERS' | 'FRIENDS' | 'ROLES'; /** * Represents the settings required to initialize the CometChat UIKit. * This class holds various configuration options, such as app credentials, * socket connection settings, and feature toggles. * * @class UIKitSettings */ declare class UIKitSettings { /** * Unique ID for the app, available on the CometChat dashboard. * @type {string} */ readonly appId: string; /** * Region for the app, such as "us" or "eu". * @type {string} */ readonly region: string; /** * Sets the subscription type for presence. * @type {CometChatPresenceSubscription} */ readonly subscriptionType: CometChatPresenceSubscription; /** * Subscribes to user presence for users having the specified roles. * @type {string[]} */ readonly roles: string[]; /** * Configures WebSocket connections. When set to true, establishes connection * automatically on app initialization. * @type {boolean} * @default true */ readonly autoEstablishSocketConnection: boolean; /** * Authentication key for the app, available on the CometChat dashboard. * @type {string} */ readonly authKey?: string; /** * Custom admin URL, used instead of the default admin URL for dedicated deployments. * @type {string} */ readonly adminHost?: string; /** * Custom client URL, used instead of the default client URL for dedicated deployments. * @type {string} */ readonly clientHost?: string; /** * Storage mode for persisting data. * @type {CometChat.StorageMode} */ readonly storageMode: CometChat.StorageMode; /** * Whether calling functionality is enabled. * When true, the Calls SDK is initialized after login. * When false (default), call buttons are hidden across all components. * @type {boolean} * @default false */ readonly callingEnabled: boolean; /** * Custom CallAppSettings to use when initializing the Calls SDK. * If not provided, the UIKit builds default settings from appId and region. * Pass a plain object: `{ appId: 'APP_ID', region: 'us' }`. * @type {any} */ readonly callAppSettings?: any; /** * Private constructor to initialize the settings using the provided builder. * @param {UIKitSettingsBuilder} builder - The builder instance containing the settings configuration. */ private constructor(); /** * Creates an instance of UIKitSettings from the provided builder. * @param {UIKitSettingsBuilder} builder - The builder instance containing the settings configuration. * @returns {UIKitSettings} A new instance of UIKitSettings. */ static fromBuilder(builder: UIKitSettingsBuilder): UIKitSettings; /** * Retrieves the app ID. * @returns {string} The unique ID of the app. */ getAppId(): string; /** * Retrieves the region. * @returns {string} The region of the app. */ getRegion(): string; /** * Retrieves the subscription type for presence. * @returns {CometChatPresenceSubscription} The subscription type. */ getSubscriptionType(): CometChatPresenceSubscription; /** * Retrieves the roles for presence subscription. * @returns {string[]} The list of roles subscribed to presence. */ getRoles(): string[]; /** * Checks if auto-establish socket connection is enabled. * @returns {boolean} True if auto-establish is enabled, otherwise false. */ isAutoEstablishSocketConnection(): boolean; /** * Retrieves the authentication key. * @returns {string | undefined} The authentication key. */ getAuthKey(): string | undefined; /** * Retrieves the custom admin host URL. * @returns {string | undefined} The admin host URL. */ getAdminHost(): string | undefined; /** * Retrieves the custom client host URL. * @returns {string | undefined} The client host URL. */ getClientHost(): string | undefined; /** * Retrieves the storage mode. * @returns {CometChat.StorageMode} The storage mode. */ getStorageMode(): CometChat.StorageMode; /** * Checks if calling functionality is enabled. * @returns {boolean} True if calling is enabled, otherwise false. */ isCallingEnabled(): boolean; /** * Retrieves the custom CallAppSettings for Calls SDK initialization. * @returns {any | undefined} The custom CallAppSettings, or undefined if not set. */ getCallAppSettings(): any; } /** * Builder class for constructing UIKitSettings instances. * Provides a fluent API for configuring the UIKit initialization settings. * * @class UIKitSettingsBuilder */ declare class UIKitSettingsBuilder { /** * Unique ID for the app, available on the CometChat dashboard. * @type {string} */ appId?: string; /** * Region for the app, such as "us" or "eu". * @type {string} */ region?: string; /** * Sets the subscription type for presence. * @type {CometChatPresenceSubscription} */ subscriptionType?: CometChatPresenceSubscription; /** * Subscribes to user presence for users having the specified roles. * @type {string[]} */ roles?: string[]; /** * Configures WebSocket connections. * @type {boolean} */ autoEstablishSocketConnection?: boolean; /** * Authentication key for the app, available on the CometChat dashboard. * @type {string} */ authKey?: string; /** * Custom admin URL, used instead of the default admin URL for dedicated deployments. * @type {string} */ adminHost?: string; /** * Custom client URL, used instead of the default client URL for dedicated deployments. * @type {string} */ clientHost?: string; /** * Storage mode for persisting data. * @type {CometChat.StorageMode} */ storageMode?: CometChat.StorageMode; /** * Whether calling functionality is enabled. * @type {boolean} * @default false */ callingEnabled?: boolean; /** * Custom CallAppSettings for Calls SDK initialization. * @type {any} */ callAppSettings?: any; /** * Builds and returns an instance of UIKitSettings. * @returns {UIKitSettings} A new instance of UIKitSettings with the specified configuration. */ build(): UIKitSettings; /** * Sets the app ID. * @param {string} appId - The unique ID of the app. * @returns {UIKitSettingsBuilder} The builder instance. */ setAppId(appId: string): this; /** * Sets the region. * @param {string} region - The region of the app. * @returns {UIKitSettingsBuilder} The builder instance. */ setRegion(region: string): this; /** * Sets the authentication key. * @param {string} authKey - The authentication key. * @returns {UIKitSettingsBuilder} The builder instance. */ setAuthKey(authKey: string): this; /** * Subscribes to presence updates for all users. * @returns {UIKitSettingsBuilder} The builder instance. */ subscribePresenceForAllUsers(): this; /** * Subscribes to presence updates for friends. * @returns {UIKitSettingsBuilder} The builder instance. */ subscribePresenceForFriends(): this; /** * Subscribes to presence updates for specific roles. * @param {string[]} roles - The roles to subscribe to. * @returns {UIKitSettingsBuilder} The builder instance. */ subscribePresenceForRoles(roles: string[]): this; /** * Sets the roles for presence subscription. * @param {string[]} roles - The roles to subscribe to. * @returns {UIKitSettingsBuilder} The builder instance. */ setRoles(roles: string[]): this; /** * Enables or disables the auto-establish socket connection. * @param {boolean} value - True to enable, false to disable. * @returns {UIKitSettingsBuilder} The builder instance. */ setAutoEstablishSocketConnection(value: boolean): this; /** * Sets the custom admin host URL. * @param {string} host - The admin host URL. * @returns {UIKitSettingsBuilder} The builder instance. */ setAdminHost(host: string): this; /** * Sets the custom client host URL. * @param {string} host - The client host URL. * @returns {UIKitSettingsBuilder} The builder instance. */ setClientHost(host: string): this; /** * Sets the storage mode. * @param {CometChat.StorageMode} mode - The storage mode. * @returns {UIKitSettingsBuilder} The builder instance. */ setStorageMode(mode: CometChat.StorageMode): this; /** * Enables or disables calling functionality. * @param {boolean} enabled - True to enable, false to disable. * @returns {UIKitSettingsBuilder} The builder instance. */ setCallingEnabled(enabled: boolean): this; /** * Sets custom CallAppSettings for Calls SDK initialization. * If not set, the UIKit builds default settings from appId and region. * * @example * ```typescript * new UIKitSettingsBuilder() * .setCallingEnabled(true) * .setCallAppSettings({ appId: 'APP_ID', region: 'us' }) * .build(); * ``` * * @param {any} callAppSettings - The CallAppSettings object. * @returns {UIKitSettingsBuilder} The builder instance. */ setCallAppSettings(callAppSettings: any): this; } /** * Status values for message lifecycle UI events. * Matches Angular's MessageStatus enum. */ declare enum CometChatMessageStatus { /** Message is being sent (optimistic, before SDK confirmation). */ inprogress = "inprogress", /** Message was sent and confirmed by the SDK. */ success = "success", /** Message send/edit failed. */ error = "error", /** Operation was cancelled by the user (e.g., closed edit/reply preview). */ cancelled = "cancelled" } /** * Discriminated union of all SDK events emitted by the CometChat SDK listeners. * These events originate from the network (other users, other tabs/devices). */ type CometChatSDKEvent = { type: 'message/text-received'; message: CometChat.TextMessage; } | { type: 'message/media-received'; message: CometChat.MediaMessage; } | { type: 'message/custom-received'; message: CometChat.CustomMessage; } | { type: 'message/interactive-received'; message: CometChat.InteractiveMessage; } | { type: 'message/card-received'; message: CometChat.BaseMessage; } | { type: 'message/ai-assistant-received'; message: CometChat.BaseMessage; } | { type: 'message/edited'; message: CometChat.BaseMessage; } | { type: 'message/deleted'; message: CometChat.BaseMessage; } | { type: 'message/moderated'; message: CometChat.BaseMessage; } | { type: 'receipt/delivered'; receipt: CometChat.MessageReceipt; } | { type: 'receipt/read'; receipt: CometChat.MessageReceipt; } | { type: 'receipt/delivered-to-all'; receipt: CometChat.MessageReceipt; } | { type: 'receipt/read-by-all'; receipt: CometChat.MessageReceipt; } | { type: 'reaction/added'; event: CometChat.ReactionEvent; } | { type: 'reaction/removed'; event: CometChat.ReactionEvent; } | { type: 'typing/started'; indicator: CometChat.TypingIndicator; } | { type: 'typing/ended'; indicator: CometChat.TypingIndicator; } | { type: 'user/online'; user: CometChat.User; } | { type: 'user/offline'; user: CometChat.User; } | { type: 'group/member-joined'; action: CometChat.Action; joinedUser: CometChat.User; joinedGroup: CometChat.Group; } | { type: 'group/member-left'; action: CometChat.Action; leftUser: CometChat.User; leftGroup: CometChat.Group; } | { type: 'group/member-kicked'; action: CometChat.Action; kickedUser: CometChat.User; kickedBy: CometChat.User; kickedFrom: CometChat.Group; } | { type: 'group/member-banned'; action: CometChat.Action; bannedUser: CometChat.User; bannedBy: CometChat.User; bannedFrom: CometChat.Group; } | { type: 'group/member-unbanned'; action: CometChat.Action; unbannedUser: CometChat.User; unbannedBy: CometChat.User; unbannedFrom: CometChat.Group; } | { type: 'group/member-added'; action: CometChat.Action; addedBy: CometChat.User; addedUser: CometChat.User; addedTo: CometChat.Group; } | { type: 'group/member-scope-changed'; action: CometChat.Action; changedUser: CometChat.User; newScope: string; oldScope: string; changedGroup: CometChat.Group; } | { type: 'call/incoming'; call: CometChat.Call; } | { type: 'call/accepted'; call: CometChat.Call; } | { type: 'call/rejected'; call: CometChat.Call; } | { type: 'call/cancelled'; call: CometChat.Call; } | { type: 'call/ended'; call: CometChat.Call; } | { type: 'connection/connected'; } | { type: 'connection/disconnected'; }; /** * Discriminated union of UI events published by components for local * cross-component communication. Prefixed with `ui:` to distinguish * from SDK events. * */ type CometChatUIEvent = { type: 'ui:message/sent'; message: CometChat.BaseMessage; status: CometChatMessageStatus.inprogress | CometChatMessageStatus.success | CometChatMessageStatus.error; } | { type: 'ui:message/deleted'; message: CometChat.BaseMessage; } | { type: 'ui:message/read'; message: CometChat.BaseMessage; } | { type: 'ui:conversation/read'; conversationId: string; } | { type: 'ui:conversation/updated'; conversation: CometChat.Conversation; } | { type: 'ui:active-chat/changed'; user?: CometChat.User; group?: CometChat.Group; message?: CometChat.BaseMessage; unreadMessageCount?: number; } | { type: 'ui:compose/edit'; message: CometChat.BaseMessage; status: CometChatMessageStatus; parentMessageId?: number | null | undefined; } | { type: 'ui:compose/reply'; message: CometChat.BaseMessage; status: CometChatMessageStatus.inprogress | CometChatMessageStatus.success | CometChatMessageStatus.cancelled; parentMessageId?: number | null | undefined; } | { type: 'ui:compose/text'; text: string; } | { type: 'ui:compose/recording-started'; composerInstanceId: string; } | { type: 'ui:user/blocked'; user: CometChat.User; } | { type: 'ui:user/unblocked'; user: CometChat.User; } | { type: 'ui:group/created'; group: CometChat.Group; } | { type: 'ui:group/left'; group: CometChat.Group; } | { type: 'ui:group/deleted'; group: CometChat.Group; } | { type: 'ui:group/member-joined'; joinedUser: CometChat.User; joinedGroup: CometChat.Group; } | { type: 'ui:group/member-added'; messages: CometChat.Action[]; group: CometChat.Group; } | { type: 'ui:group/member-kicked'; message: CometChat.Action; user: CometChat.User; group: CometChat.Group; } | { type: 'ui:group/member-banned'; message: CometChat.Action; user: CometChat.User; group: CometChat.Group; } | { type: 'ui:group/member-unbanned'; message?: CometChat.Action; user: CometChat.User; group: CometChat.Group; } | { type: 'ui:group/member-scope-changed'; message: CometChat.Action; user: CometChat.User; group: CometChat.Group; newScope: string; } | { type: 'ui:group/ownership-changed'; group: CometChat.Group; newOwner: CometChat.User; previousOwnerUid: string; } | { type: 'ui:thread/opened'; parentMessage: CometChat.BaseMessage; } | { type: 'ui:thread/closed'; } | { type: 'ui:call/outgoing'; call: CometChat.Call; } | { type: 'ui:call/rejected'; call: CometChat.Call; } | { type: 'ui:call/ended'; call?: CometChat.Call; } | { type: 'ui:call/accepted'; call: CometChat.Call; } | { type: 'ui:call/join'; sessionId: string; message: CometChat.BaseMessage; } | { type: 'ui:conversation/deleted'; conversation: CometChat.Conversation; } | { type: 'ui:card/action'; message: CometChat.BaseMessage; action: CometChatCardAction; } | { type: 'ui:open-chat'; user?: CometChat.User; group?: CometChat.Group; } | { type: 'ui:panel/show'; position: 'messageListFooter' | 'messageListHeader'; panel: 'smartReplies' | 'conversationSummary' | 'conversationStarters'; } | { type: 'ui:panel/hide'; position: 'messageListFooter' | 'messageListHeader'; }; /** All CometChat events — SDK (from network) + UI (from local actions). */ type CometChatEvent = CometChatSDKEvent | CometChatUIEvent; /** * CometChatUIKit — static facade for initializing and interacting with the UIKit. * * Provides a single entry point for: * - SDK initialization (with UIKit-specific configuration) * - User login/logout with session resumption * - Plugin registry management * - Calling SDK initialization * - Convenience send methods (for non-React usage) * * Usage: * ```typescript * import { CometChatUIKit, UIKitSettingsBuilder } from '@cometchat/chat-uikit-react'; * * const settings = new UIKitSettingsBuilder() * .setAppId('APP_ID') * .setRegion('us') * .setAuthKey('AUTH_KEY') * .subscribePresenceForAllUsers() * .setCallingEnabled(true) * .build(); * * await CometChatUIKit.init(settings); * const user = await CometChatUIKit.login('superhero1'); * ``` */ declare class CometChatUIKit { private static _settings; private static _loggedInUser; private static _initialized; /** Settings from the initFromSettings() (ai-agent) path; routes the Calls SDK through initFromSettings too. Null on plain init(). */ private static _callsInitSettings; private static _callingReady; private static _loginListenerId; private static _conversationUpdateSettings; private static _emit; /** * Register the emit function from CometChatEventsProvider. * Called internally by the provider on mount/unmount. */ static _setEmit(fn: ((event: CometChatEvent) => void) | null): void; /** Returns the UIKit settings used during initialization. */ static getSettings(): UIKitSettings | null; /** Returns the currently logged-in user (synchronous). */ static getLoggedInUser(): CometChat.User | null; /** Returns whether the SDK has been initialized. */ static isInitialized(): boolean; /** Returns whether the Calls SDK is ready. */ static isCallingReady(): boolean; /** Returns the conversation update settings fetched from the dashboard. */ static getConversationUpdateSettings(): CometChat.ConversationUpdateSettings | null; /** * Initialize the CometChat SDK and UIKit. * * This: * 1. Validates settings * 2. Builds AppSettings from UIKitSettings * 3. Calls CometChat.init() * 4. Sets source metadata for analytics * 5. Sets up plugin registry * 6. Resumes existing session (if any) * 7. Initializes Calls SDK (if enabled) */ static init(settings: UIKitSettings): Promise; /** * @internal * File-based init for AI agent skills. * Calls CometChat.initFromSettings(settings) which sets * integrationSource = "ai-agent" in persistent storage. * * This method is completely independent of init() — new→new, old→old. * Regular init(uikitSettings) does NOT set the integrationSource flag. */ static initFromSettings(settings: CometChat.CometChatSettings): Promise; /** * Log in a user by UID. * Requires authKey to be set in UIKitSettings. */ static login(uid: string): Promise; /** * Log in a user with an auth token. */ static loginWithAuthToken(authToken: string): Promise; /** * Log out the current user. */ static logout(): Promise; /** * Create a new user. * Requires authKey in UIKitSettings. */ static createUser(user: CometChat.User): Promise; /** * Update an existing user. * Requires authKey in UIKitSettings. */ static updateUser(user: CometChat.User): Promise; /** * Send a text message with optimistic UI updates. * Emits 'ui:message/sent' at each stage (inprogress → success/error). */ static sendTextMessage(message: CometChat.TextMessage): Promise; /** * Send a media message with optimistic UI updates. * Emits 'ui:message/sent' at each stage (inprogress → success/error). */ static sendMediaMessage(message: CometChat.MediaMessage): Promise; /** * Send a custom message with optimistic UI updates. * Emits 'ui:message/sent' at each stage (inprogress → success/error). */ static sendCustomMessage(message: CometChat.CustomMessage): Promise; /** Post-login initialization: calls SDK, conversation settings, login listener. */ private static _postLogin; /** Attach SDK login listener to track login/logout from other tabs or direct SDK calls. */ private static _attachLoginListener; /** Initialize the Calls SDK. */ private static _initCalling; /** Prepare a message for sending (set muid, sentAt, sender). */ private static _prepareMessage; /** Throw if not initialized. */ private static _checkInitialized; } /** * CometChatCalls — dynamic import wrapper for the optional Calls SDK. * * The Calls SDK (`@cometchat/calls-sdk-javascript`) is an optional peer dependency. * This module attempts to import it. If unavailable (not installed, * test environment, SSR), `CometChatUIKitCalls` will be `null`. * * In ESM/Vite environments, `require()` is not available. The SDK is loaded * asynchronously via `loadCallsSDK()` called from `CometChatUIKit._initCalling()` * or `CometChatProvider`'s calling init effect. * * Usage: * ```typescript * import { CometChatUIKitCalls } from '@cometchat/chat-uikit-react'; * * if (CometChatUIKitCalls) { * // Initialize with plain object * await CometChatUIKitCalls.init({ appId: 'APP_ID', region: 'us' }); * * // Login (after Chat SDK login) * await CometChatUIKitCalls.loginWithAuthToken(authToken); * * // Generate token and join session * const { token } = await CometChatUIKitCalls.generateToken(sessionId); * CometChatUIKitCalls.joinSession(token, callSettings, element); * * // Register event listeners * const unsub = CometChatUIKitCalls.addEventListener('onSessionLeft', () => { }); * * // Leave session * CometChatUIKitCalls.leaveSession(); * } * ``` */ /** * The Calls SDK reference. Starts as `null` and is populated either: * 1. Synchronously via `require()` in CJS/webpack environments * 2. Asynchronously via `loadCallsSDK()` after dynamic import in ESM/Vite environments */ declare let CometChatUIKitCalls: any; /** * Dynamically load the Calls SDK in ESM/Vite environments. * * Uses a literal specifier so Vite's dev server and bundler resolve it * correctly when the package is installed. When not installed, the * `optionalPeerDependency` Vite plugin (in vite.config.ts) intercepts the * import and returns a virtual empty module instead of throwing a build error. * The null-check below handles that case at runtime. * * Returns the resolved CometChatCalls object, or null if not installed. */ declare function loadCallsSDK(): Promise; /** * Initialize the Calls SDK reference. * Call this after the SDK is loaded asynchronously (e.g., via dynamic import). * The CometChatUIKit class and CometChatProvider call this during initialization. */ declare function initCallsSDK(sdk: any): void; /** Supported theme values. */ type CometChatTheme = 'light' | 'dark'; /** Context value for theme. */ interface CometChatThemeContextValue { /** Current theme. */ theme: CometChatTheme; /** Toggle or set theme programmatically. */ setTheme: (theme: CometChatTheme) => void; } /** Props for CometChatThemeProvider. */ interface CometChatThemeProviderProps { /** * The active theme. Controls the `data-theme` attribute on the wrapper. * CSS custom properties in css-variables.css respond to this attribute. * Default: 'light'. */ theme?: CometChatTheme; /** Children. */ children: ReactNode; } /** * Cross-cutting display settings used by multiple components. * * Set once at the provider level, read by any component via `useGlobalConfig()`. * Individual component props override these values when explicitly set. */ interface CometChatGlobalConfig { /** Hide read receipt indicators across all components. Default: false. */ hideReceipts?: boolean; /** Hide user online/offline status across all components. Default: false. */ hideUserStatus?: boolean; /** Disable sound for incoming/outgoing calls. Default: false. */ disableSoundForCalls?: boolean; /** Custom sound URL for calls. */ customSoundForCalls?: string; /** Disable sound for incoming messages across all components. Default: false. */ disableSoundForMessages?: boolean; /** Custom sound URL for incoming messages. */ customSoundForMessages?: string; /** * Custom call settings builder for ongoing call sessions. * Passed to OngoingCall component when a call is started. * If not set, the component creates default settings internally. */ callSettingsBuilder?: any; } /** * Abstract base class for text formatters. * * Formatters detect patterns in text and apply formatting transformations. * They can be chained together — each formatter receives the output of the * previous one. Formatters are applied in order of their `priority` property * (lower = earlier in pipeline). * * Formatters handle ONLY bubble display (text → HTML). Composer input * handling and message metadata are separate concerns. * * @example * ```typescript * class HashtagFormatter extends CometChatTextFormatter { * readonly id = 'hashtag-formatter'; * priority = 50; * getRegex() { return /(#\w+)/g; } * format(text: string): string { * this.originalText = text; * this.formattedText = text.replace(this.getRegex(), '$1'); * return this.formattedText; * } * } * ``` */ declare abstract class CometChatTextFormatter { /** Formatter priority (lower = earlier in pipeline). Default is 100. */ priority: number; /** Unique identifier for this formatter. */ abstract readonly id: string; /** The original unformatted text. */ protected originalText: string; /** The formatted text after applying transformations. */ protected formattedText: string; /** Metadata extracted during formatting (e.g., mentions, URLs). */ protected metadata: Record; /** Get the regex pattern for detecting formattable content. */ abstract getRegex(): RegExp; /** * Format the input text by applying transformations. * Must store originalText, apply transformations, store formattedText, and return it. */ abstract format(text: string): string; /** Get the formatted text after format() has been called. */ getFormattedText(): string; /** Get the original unformatted text. */ getOriginalText(): string; /** Get metadata extracted during formatting. */ getMetadata(): Record; /** Reset the formatter state. */ reset(): void; /** * Check if this formatter should process the given text. * Override to conditionally skip formatting. Default: always format. */ shouldFormat(_text: string, // eslint-disable-line @typescript-eslint/no-unused-vars _message?: CometChat.BaseMessage): boolean; } /** Alignment of a message bubble in the message list. */ type CometChatMessageBubbleAlignment = 'left' | 'right' | 'center'; /** A single option in the message context menu (long-press / hover menu). */ interface CometChatMessageOption { /** Unique identifier (e.g., 'react', 'reply', 'copy', 'edit', 'delete'). */ id: string; /** Display title (localized). */ title: string; /** Icon URL or inline SVG string. */ iconURL?: string; /** Callback when the option is selected. */ onClick: (message: CometChat.BaseMessage) => void; /** Show only for messages sent by the logged-in user. */ senderOnly?: boolean; /** Show only for messages NOT sent by the logged-in user. */ receiverOnly?: boolean; /** Show only in group conversations. */ groupOnly?: boolean; } /** Context passed to every plugin method. Contains the current user, conversation, and UI state. */ interface CometChatMessagePluginContext { /** The currently logged-in user. */ loggedInUser: CometChat.User; /** The group (if the conversation is a group chat). Undefined for 1:1 chats. */ group?: CometChat.Group; /** Bubble alignment for the current message. */ alignment: CometChatMessageBubbleAlignment; /** Batch position within a multi-attachment batch group ('first'|'middle'|'last'|'single'). */ batchPosition?: 'first' | 'middle' | 'last' | 'single'; /** Current theme. */ theme: 'light' | 'dark'; /** Localization function. Returns the translated string for a given key. */ getLocalizedString?: (key: string) => string; /** Delete a message. Shows confirm dialog, then calls SDK. */ onDeleteMessage?: (message: CometChat.BaseMessage) => void; /** Open the flag/report dialog for a message. */ onFlagMessage?: (message: CometChat.BaseMessage) => void; /** Open thread view for a message. */ onThreadClick?: (message: CometChat.BaseMessage) => void; /** Mark a message as unread. Updates conversation unread count and last read ID. */ onMarkAsUnread?: (message: CometChat.BaseMessage) => void; /** Show a toast notification with the given text. */ showToast?: (text: string) => void; /** Disable text truncation (read more / show less) in text bubbles. */ disableTruncation?: boolean; /** Disable interaction (click handlers, options) on the bubble. Used in thread header parent bubble. */ disableInteraction?: boolean; /** Set a message into edit mode in the composer. */ onEditMessage?: (message: CometChat.BaseMessage) => void; /** Set a message as the reply-to target in the composer. */ onReplyMessage?: (message: CometChat.BaseMessage) => void; /** Open the emoji picker to react to a message. */ onReactToMessage?: (message: CometChat.BaseMessage) => void; /** Open the message information panel for a message. */ onMessageInfo?: (message: CometChat.BaseMessage) => void; /** Publish a UI event for cross-component communication. */ publish?: (event: CometChatUIEvent) => void; /** Get text formatters from the plugin registry (for caption rendering in media bubbles). */ getTextFormatters?: () => CometChatTextFormatter[]; hideReplyOption?: boolean; hideReplyInThreadOption?: boolean; hideEditMessageOption?: boolean; hideDeleteMessageOption?: boolean; hideCopyMessageOption?: boolean; hideReactionOption?: boolean; hideMessageInfoOption?: boolean; hideFlagMessageOption?: boolean; hideMessagePrivatelyOption?: boolean; hideTranslateMessageOption?: boolean; showMarkAsUnreadOption?: boolean; } /** * The core plugin interface. Every message type plugin implements this. * * A plugin owns one or more message types within one or more categories. * It provides bubble rendering, context menu options, conversation list preview, * text formatters, and composer attachment options. */ interface CometChatMessagePlugin { /** Unique plugin identifier (e.g., 'text', 'image', 'polls'). */ id: string; /** SDK message types this plugin handles (e.g., ['text'], ['image'], ['groupMember']). */ messageTypes: string[]; /** SDK message categories this plugin handles (e.g., ['message'], ['action']). */ messageCategories: string[]; /** * Render the bubble content for a message. * Returns only the inner content — the outer bubble wrapper is handled by CometChatMessageBubble. */ renderBubble(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; /** * Return context menu options for a message. * Return an empty array for messages that have no options (e.g., group actions, deleted). */ getOptions?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): CometChatMessageOption[]; /** * Return a plain-text preview for the conversation list subtitle. * Must return plain text — no HTML, no markdown. Truncate to ~100 chars. * @param t - Optional localization function. Use it to translate preview strings. */ getLastMessagePreview?(message: CometChat.BaseMessage, loggedInUser: CometChat.User, t?: (key: string) => string): string; /** * Return text formatters this plugin provides. * Only relevant for the text plugin. Other plugins return undefined or []. */ getTextFormatters?(): CometChatTextFormatter[]; /** * Render the leading view (avatar area) for a message bubble. * Default: avatar for incoming messages in group chats. */ renderLeadingView?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; /** * Render the header view (sender name area) for a message bubble. * Default: sender name for incoming messages in group chats. */ renderHeaderView?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; /** * Render the footer view (below content, e.g., reactions) for a message bubble. * Default: CometChatReactions when the message has reactions. */ renderFooterView?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; /** * Render the bottom view (moderation/error footer) for a message bubble. * Default: CometChatModerationView for disapproved or permission-denied messages. */ renderBottomView?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; /** * Render the status info view (timestamp, receipts, "edited") for a message bubble. * Default: timestamp + delivery/read receipts + "edited" indicator. */ renderStatusInfoView?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; /** * Render the reply view (quoted message preview) for a message bubble. * Default: CometChatMessageReplyPreview when the message has a quoted message. */ renderReplyView?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; /** * Render the thread view (reply count indicator) for a message bubble. * Default: CometChatThreadView with reply count. */ renderThreadView?(message: CometChat.BaseMessage, context: CometChatMessagePluginContext): ReactNode; } /** * Types for the CometChatProvider — context composition for the UIKit. */ /** Props for the root CometChatProvider. */ interface CometChatProviderProps { /** Additional plugins beyond the default set. Merged with defaultPlugins internally. */ plugins?: CometChatMessagePlugin[]; /** * Plugins to exclude — including defaults. Each entry is matched against every * plugin's `messageTypes`/`messageCategories`: a plugin is removed when its * `messageTypes` includes `text` AND its `messageCategories` includes `category`. * * ```tsx * * ``` */ removePlugins?: { text: string; category: string; }[]; /** Global config overrides (hideReceipts, hideUserStatus, etc.). */ config?: CometChatGlobalConfig; /** Theme: 'light' or 'dark'. Default: 'light'. */ theme?: CometChatTheme; /** Locale override (e.g., 'en', 'fr', 'de'). Default: browser language. */ locale?: string; children: ReactNode; } declare const CometChatProvider: React__default.FC; /** * useLoggedInUser — get the logged-in user. * * Reads synchronously from CometChatUIKit first (instant if init+login was done via UIKit class). * Falls back to async CometChat.getLoggedinUser() for cases where the SDK was initialized directly. * SSR-safe: returns null if no user is available. * * Use this in components that can render without a user (graceful degradation). * For components that REQUIRE a user, check the return value and handle null. */ declare function useLoggedInUser(): CometChat.User | null; interface CometChatFrameContextValue { iframeDocument: Document | null; iframeWindow: Window | null; iframe: HTMLIFrameElement | null; } interface CometChatFrameProviderProps { children: ReactNode; iframeId: string; } declare const useCometChatFrameContext: () => CometChatFrameContextValue; declare const CometChatFrameProvider: React__default.FC; /** * Log level enum defining verbosity levels. * Ordered from least verbose (none) to most verbose (debug). */ declare enum LogLevel { none = 0, error = 1, warn = 2, info = 3, debug = 4 } /** Sets the active log level. Only messages at this level or below are output. */ declare function setLogLevel(level: LogLevel): void; /** Returns the current log level. */ declare function getLogLevel(): LogLevel; /** Logs an error message if the current level permits. */ declare function error(tag: string, message: string, ...args: unknown[]): void; /** Logs a warning message if the current level permits. */ declare function warn(tag: string, message: string, ...args: unknown[]): void; /** Logs an informational message if the current level permits. */ declare function info(tag: string, message: string, ...args: unknown[]): void; /** Logs a debug message if the current level permits. */ declare function debug(tag: string, message: string, ...args: unknown[]): void; /** * Centralized logging utility for the CometChat UIKit. * All internal logging goes through this object so consumers can control verbosity. * * @example * ```ts * import { CometChatLogger, LogLevel } from '@cometchat/chat-uikit-react'; * CometChatLogger.setLogLevel(LogLevel.debug); * ``` */ declare const CometChatLogger: { readonly setLogLevel: typeof setLogLevel; readonly getLogLevel: typeof getLogLevel; readonly error: typeof error; readonly warn: typeof warn; readonly info: typeof info; readonly debug: typeof debug; }; /** * CometChatUIKitUtility — utility class providing helper methods * such as deep cloning, ID generation, and Unix timestamp retrieval. * */ /** * Creates a deep copy of the value provided. * * @remarks * This function cannot copy truly private properties (those that start with a "#" symbol inside a class block). * Functions are copied by reference and additional properties on array objects are ignored. * * @param arg - Any value * @returns A deep copy of `arg` */ declare function clone(arg: T): T; /** * Generates a unique ID. * @returns A unique string identifier. */ declare function generateId(): string; /** * Retrieves the current Unix timestamp (seconds). * @returns The Unix timestamp. */ declare function getUnixTimestamp(): number; /** * Creates a CometChat.Action message for group member actions. * * @param actionOn - The group member the action is performed on * @param action - The action string (e.g., 'kicked', 'banned', 'added', 'scopeChanged') * @param group - The group where the action occurred * @param loggedInUser - The user performing the action * @returns A properly constructed CometChat.Action message */ declare function createActionMessage(actionOn: CometChat.GroupMember | CometChat.User, action: string, group: CometChat.Group, loggedInUser: CometChat.User): CometChat.Action; declare const CometChatUIKitUtility: { clone: typeof clone; ID: typeof generateId; getUnixTimestamp: typeof getUnixTimestamp; createActionMessage: typeof createActionMessage; }; /** Batch position within a multi-attachment batch group. */ type BatchPosition = 'first' | 'middle' | 'last' | 'single'; /** * Reads the `batchId` from a message's metadata, null-guarded. * Returns `undefined` if the message has no batchId. */ declare function getMessageBatchId(message: CometChat.BaseMessage | undefined | null): string | undefined; /** * Computes the batch position of a message given its immediate neighbors. * * Groups consecutive messages by comparing each message's `batchId` to only its * immediate previous and next neighbors (R6.1). The result drives chrome * suppression in the renderer: * * | Position | Avatar+Name | StatusInfo | * |----------|-------------|------------| * | first | show | suppress | * | middle | suppress | suppress | * | last | suppress | show | * | single | show | show | * * Voice notes have no batchId → always 'single'. */ declare function computeBatchPosition(prev: CometChat.BaseMessage | undefined | null, current: CometChat.BaseMessage | undefined | null, next: CometChat.BaseMessage | undefined | null): BatchPosition; /** A single action item rendered inside the sheet. */ interface CometChatActionSheetItemData { /** Unique identifier. */ id: string; /** Display title. */ title: string; /** Icon element (SVG or ReactNode). */ icon?: ReactNode; /** Callback when item is selected. */ onClick: () => void; /** Optional secondary text. */ subtitle?: string; /** Whether the item is disabled. */ disabled?: boolean; /** Optional custom className. */ className?: string; } /** Layout mode for the action sheet. */ type CometChatActionSheetLayoutMode = 'list' | 'grid'; /** Props for ActionSheetRoot. */ interface CometChatActionSheetRootProps { /** Whether the sheet is open. */ isOpen: boolean; /** Callback when the sheet requests to close (backdrop click, Escape key). */ onClose: () => void; /** Layout mode. Defaults to 'list'. */ layoutMode?: CometChatActionSheetLayoutMode; /** Optional title displayed in the header. */ title?: string; /** Children (ActionSheet.Item elements or custom content). */ children: ReactNode; /** Optional custom className for the root container. */ className?: string; } /** Props for ActionSheetItem. */ interface CometChatActionSheetItemProps { /** The action item data. */ item: CometChatActionSheetItemData; /** Optional custom className. */ className?: string; } /** Props for ActionSheetHeader. */ interface CometChatActionSheetHeaderProps { /** Title text. */ title?: string; /** Optional close button callback. */ onClose?: () => void; /** Children for custom header content. */ children?: ReactNode; } /** Props for ActionSheetLayout. */ interface CometChatActionSheetLayoutProps { /** Layout mode: list (vertical) or grid (icon grid). Defaults to 'list'. */ mode?: CometChatActionSheetLayoutMode; /** Children (ActionSheet.Item elements). */ children: ReactNode; } /** Context value for ActionSheet. */ interface CometChatActionSheetContextValue { isOpen: boolean; onClose: () => void; layoutMode: CometChatActionSheetLayoutMode; } /** * Flat API props for CometChatActionSheet. * Renders Root + Header + Layout with Items in one call. */ interface CometChatActionSheetProps extends Omit { /** Header title. */ title?: string; /** Callback for the header close button. Defaults to onClose. */ onHeaderClose?: () => void; /** Items to render in the sheet layout. */ items?: CometChatActionSheetItemData[]; } declare const CometChatActionSheet: React__default.FC & { Root: React__default.FC; Item: React__default.FC; Header: React__default.FC; Layout: React__default.FC; }; declare function useCometChatActionSheetContext(): CometChatActionSheetContextValue; /** Visual variant of the button. */ type CometChatButtonVariant = 'primary' | 'secondary' | 'ghost'; /** Size variant of the button. */ type CometChatButtonSize = 'sm' | 'md' | 'lg'; /** Props for CometChatButton.Root. */ interface CometChatButtonRootProps extends Omit, 'children'> { /** Visual variant. Defaults to 'primary'. */ variant?: CometChatButtonVariant; /** Size variant. Defaults to 'md'. */ size?: CometChatButtonSize; /** Whether the button is in a loading state. */ isLoading?: boolean; /** Accessible label for the loading state. */ loadingLabel?: string; /** Tooltip text shown on hover (maps to native title attribute). */ hoverText?: string; /** Children (CometChatButton.Icon, CometChatButton.Text, or custom content). */ children: ReactNode; /** Optional custom className. */ className?: string; } /** Props for CometChatButton.Icon. */ interface CometChatButtonIconProps { /** Icon content — accepts ReactNode (SVG component, img, etc.). */ children: ReactNode; /** Optional custom className. */ className?: string; } /** Props for CometChatButton.Text. */ interface CometChatButtonTextProps { /** Text content. */ children: ReactNode; /** Optional custom className. */ className?: string; } /** Context value for CometChatButton. */ interface CometChatButtonContextValue { variant: CometChatButtonVariant; size: CometChatButtonSize; isLoading: boolean; disabled: boolean; } /** * Flat API props for CometChatButton. * Renders Root + optional Icon + optional Text in one call. */ interface CometChatButtonProps extends Omit { /** Icon content (SVG component, img, etc.). Rendered inside CometChatButton.Icon. */ icon?: React__default.ReactNode; /** Text content. Rendered inside CometChatButton.Text. */ text?: React__default.ReactNode; } declare const CometChatButton: React__default.ForwardRefExoticComponent> & { Root: React__default.ForwardRefExoticComponent>; Icon: React__default.FC; Text: React__default.FC; }; declare function useCometChatButtonContext(): CometChatButtonContextValue; /** Event payload emitted on checkbox state change. */ interface CometChatCheckboxChangeEvent { /** Whether the checkbox is now checked. */ checked: boolean; /** The label text, if provided. */ label?: string; /** Whether the Shift key was held during the click. */ shiftKey?: boolean; /** Whether the Meta/Cmd key was held during the click. */ metaKey?: boolean; } /** Props for CometChatCheckbox. */ interface CometChatCheckboxProps extends Omit, 'onChange' | 'type' | 'children'> { /** Whether the checkbox is checked (controlled mode). */ checked?: boolean; /** Default checked state (uncontrolled mode). */ defaultChecked?: boolean; /** Label text displayed next to the checkbox. */ label?: string; /** Whether the checkbox is disabled. */ disabled?: boolean; /** Callback fired when the checkbox value changes. */ onChange?: (event: CometChatCheckboxChangeEvent) => void; /** Optional custom className. */ className?: string; } /** * CometChatCheckbox — a controlled/uncontrolled checkbox with support * for shift/meta key detection (used for range-select in list components). * * Usage: * ```tsx * handleSelect(checked, shiftKey)} * /> * ``` */ declare const CometChatCheckbox: React__default.ForwardRefExoticComponent>; /** Event payload emitted on radio button state change. */ interface CometChatRadioButtonChangeEvent { /** Whether the radio button is now checked. */ checked: boolean; /** The label text, if provided. */ label?: string | undefined; /** The value of the radio button. */ value?: string | undefined; } /** Props for CometChatRadioButton. */ interface CometChatRadioButtonProps extends Omit, 'onChange' | 'type' | 'children'> { /** Whether the radio button is checked (controlled mode). */ checked?: boolean; /** Default checked state (uncontrolled mode). */ defaultChecked?: boolean; /** Label text displayed next to the radio button. */ label?: string; /** Whether the radio button is disabled. */ disabled?: boolean; /** Name for grouping radio buttons — only one in a group can be selected. */ name?: string; /** Value of the radio button submitted with the form. */ value?: string; /** Custom aria-label that overrides label for accessibility. */ ariaLabel?: string; /** Callback fired when the radio button value changes. */ onChange?: (event: CometChatRadioButtonChangeEvent) => void; /** Optional custom className. */ className?: string; } /** * CometChatRadioButton — a controlled/uncontrolled radio button with label, * grouping via `name`, and full keyboard accessibility. * * Radio group behavior (single-selection) is handled natively by the browser * when multiple radio inputs share the same `name` attribute. * * Usage: * ```tsx * setSelected(value)} * /> * ``` */ declare const CometChatRadioButton: React__default.ForwardRefExoticComponent>; /** Media type supported by the fullscreen viewer. */ type CometChatFullScreenViewerMediaType = 'image' | 'video' | 'audio' | 'file'; /** A single media attachment for gallery mode. */ interface CometChatMediaAttachment { /** Media URL. */ url: string; /** Type of media. */ type: CometChatFullScreenViewerMediaType; /** File name (displayed in header and file preview). */ name?: string; /** File size in bytes (displayed in header and file preview). */ size?: number; } /** Props for CometChatFullScreenViewer.Root. */ interface CometChatFullScreenViewerRootProps { /** Callback when the viewer requests to close. */ onClose: () => void; /** Media URL (single mode). */ url?: string; /** Media type (single mode). Defaults to 'image'. */ mediaType?: CometChatFullScreenViewerMediaType; /** File name (single mode). */ fileName?: string; /** File size in bytes (single mode). */ fileSize?: number; /** Array of media attachments (gallery mode). */ attachments?: CometChatMediaAttachment[]; /** Starting index for gallery mode. Defaults to 0. */ startIndex?: number; /** Sender name displayed in header. */ senderName?: string; /** Sender avatar URL displayed in header. */ senderAvatar?: string; /** Sender status text. */ senderStatus?: string; /** Formatted timestamp string displayed in header. */ sentAt?: string; /** Callback when the gallery index changes. */ onIndexChange?: (index: number) => void; /** Callback when the download button is clicked. */ onDownload?: (attachment: CometChatMediaAttachment | string) => void; /** Children (sub-components or custom content). */ children?: ReactNode; /** Optional custom className. */ className?: string; } /** Props for CometChatFullScreenViewer.Header. */ interface CometChatFullScreenViewerHeaderProps { /** Override default header content. */ children?: ReactNode; /** Optional custom className. */ className?: string; } /** Props for CometChatFullScreenViewer.Body. */ interface CometChatFullScreenViewerBodyProps { /** Override default body content. */ children?: ReactNode; /** Optional custom className. */ className?: string; } /** Props for CometChatFullScreenViewer.Navigation. */ interface CometChatFullScreenViewerNavigationProps { /** Optional custom className. */ className?: string; } /** Context value for CometChatFullScreenViewer. */ interface CometChatFullScreenViewerContextValue { onClose: () => void; mediaType: CometChatFullScreenViewerMediaType; currentUrl: string; currentIndex: number; attachments: CometChatMediaAttachment[]; isGalleryMode: boolean; canNavigatePrev: boolean; canNavigateNext: boolean; navigatePrev: () => void; navigateNext: () => void; senderName: string | undefined; senderAvatar: string | undefined; senderStatus: string | undefined; sentAt: string | undefined; fileName: string | undefined; fileSize: number | undefined; onDownload: ((attachment: CometChatMediaAttachment | string) => void) | undefined; } /** * Flat API props for CometChatFullScreenViewer. * Same as Root props but without children (always renders default layout). */ type CometChatFullScreenViewerProps = Omit; declare const CometChatFullScreenViewer: React__default.FC & { Root: React__default.FC; Header: React__default.FC; Body: React__default.FC; Navigation: React__default.FC; }; declare function useCometChatFullScreenViewerContext(): CometChatFullScreenViewerContextValue; /** Size variants for the avatar. */ type CometChatAvatarSize = 'small' | 'medium' | 'large'; /** Props for AvatarRoot. */ interface CometChatAvatarRootProps { /** Name used for initials fallback and alt text. */ name?: string; /** URL of the avatar image. */ image?: string; /** Size variant. Defaults to 'medium'. */ size?: CometChatAvatarSize; /** Optional custom className. */ className?: string; children?: ReactNode; } /** Props for AvatarImage. */ interface CometChatAvatarImageProps { /** Optional custom className. */ className?: string; } /** Props for AvatarInitials. */ interface CometChatAvatarInitialsProps { /** Optional custom className. */ className?: string; } /** Status indicator state. */ type CometChatAvatarStatus = 'online' | 'offline'; /** Props for AvatarStatusIndicator. */ interface CometChatAvatarStatusIndicatorProps { /** Online/offline status. */ status: CometChatAvatarStatus; /** Optional custom className. */ className?: string; } /** Context value exposed by AvatarRoot. */ interface CometChatAvatarContextValue { name: string; image: string; size: CometChatAvatarSize; /** Whether the image has loaded successfully. */ imageLoaded: boolean; /** Whether the image failed to load. */ imageError: boolean; } declare function CometChatAvatarRoot({ name, image, size, className, children, }: CometChatAvatarRootProps): react_jsx_runtime.JSX.Element; declare function CometChatAvatarImage({ className }: CometChatAvatarImageProps): react_jsx_runtime.JSX.Element | null; declare function CometChatAvatarInitials({ className }: CometChatAvatarInitialsProps): react_jsx_runtime.JSX.Element | null; declare function CometChatAvatarStatusIndicator({ status, className, }: CometChatAvatarStatusIndicatorProps): react_jsx_runtime.JSX.Element; /** * Flat API props for CometChatAvatar. * Renders Root + Image + Initials + optional StatusIndicator in one call. */ interface CometChatAvatarProps extends Omit { /** Optional online/offline status indicator. Omit to hide. */ status?: CometChatAvatarStatus; } declare const CometChatAvatar: React__default.FC & { Root: typeof CometChatAvatarRoot; Image: typeof CometChatAvatarImage; Initials: typeof CometChatAvatarInitials; StatusIndicator: typeof CometChatAvatarStatusIndicator; }; /** Placement of the dropdown relative to the trigger. */ type CometChatContextMenuPlacement = 'top' | 'right' | 'bottom' | 'left'; /** A single menu item. */ interface CometChatContextMenuItemData { /** Unique identifier. */ id: string; /** Display title. */ title: string; /** Icon element (SVG component or ReactNode). */ icon?: ReactNode; /** Icon URL (for mask-image rendering). */ iconURL?: string; /** Callback when item is selected. */ onClick: () => void; /** Whether the item is disabled. */ disabled?: boolean; /** Optional custom className. */ className?: string; } /** Props for CometChatContextMenuRoot. */ interface CometChatContextMenuRootProps { /** All menu items. */ items?: CometChatContextMenuItemData[]; /** Number of items to show in the top row. Remaining go to the dropdown. Defaults to 2. */ topMenuSize?: number; /** Callback when any menu item is clicked. Overrides individual item.onClick if provided. */ onOptionClicked?: (item: CometChatContextMenuItemData) => void; /** Placement of the dropdown popover. Defaults to 'left'. */ placement?: CometChatContextMenuPlacement; /** Tooltip text for the "more" button. */ moreButtonTooltip?: string; /** Whether clicking outside closes the dropdown. Defaults to true. */ closeOnOutsideClick?: boolean; /** * When true, renders a transparent overlay behind the dropdown that blocks * scroll and pointer events on the background. Also closes the dropdown on scroll. */ disableBackgroundInteraction?: boolean; /** * Callback fired when the dropdown closes. Useful for the parent to hide * the entire options toolbar when the menu dismisses. */ onDropdownClose?: () => void; /** * When true, uses the nearest scrollable ancestor as the boundary for dropdown positioning. * Useful for iframe or constrained container scenarios. */ useParentContainer?: boolean; /** * When true (and useParentContainer is true), clamps the dropdown vertically * within the parent container's bounds. */ useParentHeight?: boolean; /** * When true, disables dynamic flip/reposition logic for the dropdown. */ forceStaticPlacement?: boolean; /** Children for fully custom rendering (overrides items-based rendering). */ children?: ReactNode; /** Optional custom className for the root container. */ className?: string; } /** Props for CometChatContextMenuItem. */ interface CometChatContextMenuItemProps { /** The menu item data. */ item: CometChatContextMenuItemData; /** Display variant: 'icon' for top-row (icon only) or 'full' for dropdown (icon + title). */ variant?: 'icon' | 'full'; /** Optional custom className. */ className?: string; } /** Props for CometChatContextMenuTrigger (the "more" button). */ interface CometChatContextMenuTriggerProps { /** Tooltip text. */ tooltip?: string; /** Optional custom className. */ className?: string; /** Custom trigger content (replaces default "more" icon). */ children?: ReactNode; } /** Props for CometChatContextMenuDropdown. */ interface CometChatContextMenuDropdownProps { /** Placement relative to the trigger. */ placement?: CometChatContextMenuPlacement; /** * When true, uses the nearest scrollable ancestor (or `.cometchat` container) * as the boundary for positioning instead of the viewport. * Useful when rendered inside iframes or constrained containers. */ useParentContainer?: boolean; /** * When true (and useParentContainer is true), clamps the dropdown's vertical * position to stay within the parent container's height. */ useParentHeight?: boolean; /** * When true, disables dynamic flip/reposition logic. The dropdown opens exactly * at the specified placement without checking available space. */ forceStaticPlacement?: boolean; /** Children (CometChatContextMenu.Item elements). */ children?: ReactNode; /** Optional custom className. */ className?: string; } /** Context value shared across sub-components. */ interface CometChatContextMenuContextValue { /** Whether the dropdown is open. */ isOpen: boolean; /** Open the dropdown. */ open: () => void; /** Close the dropdown. */ close: () => void; /** Toggle the dropdown. */ toggle: () => void; /** Placement of the dropdown. */ placement: CometChatContextMenuPlacement; /** Callback when an item is clicked. */ onOptionClicked?: (item: CometChatContextMenuItemData) => void; /** Ref for the trigger button (used for focus restoration). */ triggerRef: React.RefObject; /** Use parent container as positioning boundary. */ useParentContainer?: boolean; /** Clamp vertical position to parent height. */ useParentHeight?: boolean; /** Disable dynamic flip/reposition logic. */ forceStaticPlacement?: boolean; /** Block background scroll/interaction when dropdown is open. */ disableBackgroundInteraction?: boolean; } /** * Flat API props for CometChatContextMenu. * Same as Root props — the Root already supports data-driven rendering * when no children are provided (splits items into top-row + dropdown). */ type CometChatContextMenuProps = Omit; declare const CometChatContextMenu: React__default.FC & { Root: React__default.FC; Item: React__default.FC; Trigger: React__default.FC; Dropdown: React__default.FC; }; declare function useCometChatContextMenuContext(): CometChatContextMenuContextValue; declare function useCometChatAvatarContext(): CometChatAvatarContextValue; /** * Extracts initials from a name. * - 2+ words: first letter of first two words, uppercased * - 1 word: first 2 characters, uppercased * - Empty: returns empty string */ declare function getInitials(name: string): string; /** * Configuration for date formatting based on temporal proximity. * Plain interface replacing the CalendarObject class. */ interface CometChatDateFormatConfig { /** Format pattern for same-day dates (e.g., "hh:mm A"). */ today?: string; /** Format pattern for previous-day dates (e.g., "Yesterday"). */ yesterday?: string; /** Format pattern for dates within the last 7 days (e.g., "dddd"). */ lastWeek?: string; /** Format pattern for dates older than 7 days (e.g., "DD/MM/YYYY"). */ otherDays?: string; /** Relative time formatting for recent timestamps. */ relativeTime?: { /** Formatting for minutes (singular). Use %d as placeholder for the count. */ minute?: string; /** Formatting for minutes (plural). Use %d as placeholder for the count. */ minutes?: string; /** Formatting for hours (singular). Use %d as placeholder for the count. */ hour?: string; /** Formatting for hours (plural). Use %d as placeholder for the count. */ hours?: string; }; } /** Style variant for the date text. */ type CometChatDateVariant = 'caption' | 'caption2' | 'body' | 'label' | 'separator'; /** Props for CometChatDateRoot. */ interface CometChatDateRootProps { /** Unix timestamp (seconds) of the date to display. */ timestamp: number; /** * Format configuration based on temporal proximity. * Defaults to: today="hh:mm A", yesterday="Yesterday", lastWeek="dddd", otherDays="DD/MM/YYYY". */ formatConfig?: CometChatDateFormatConfig; /** * Custom formatter function. When provided, overrides formatConfig. * Receives the timestamp and returns the display string. */ formatter?: (timestamp: number) => string; /** Visual style variant. Defaults to 'caption'. */ variant?: CometChatDateVariant; /** Optional custom className. */ className?: string; children?: ReactNode; } /** Props for CometChatDateText. */ interface CometChatDateTextProps { /** Optional custom className. */ className?: string; } /** Context value exposed by CometChatDateRoot. */ interface CometChatDateContextValue { /** The original Unix timestamp. */ timestamp: number; /** The formatted date string for display. */ formattedDate: string; /** ISO 8601 string for the