@bcc-code/vue-bcc-chat-ui 7.2.3 → 7.2.7

package/dist/chat/localization.d.ts

@@ -0,0 +1,17 @@
+import { MaybeRefOrGetter, Ref, ComputedRef } from 'vue';
+import { englishTranslations } from './i18n/en';
+import { TranslationEntry, TranslationParams } from './i18n/types';
+import { Language } from './types';
+type TranslationDictionary = Record<keyof typeof englishTranslations, TranslationEntry>;
+export type TranslationKey = keyof TranslationDictionary;
+export declare const currentChatLanguage: Ref<Language, Language>;
+export declare function resolveChatLocale(language?: Language | null): "nb-NO" | "en-US";
+/** Chat uses 24-hour time formatting consistently. */
+export declare function getSystemHourCycle(): "h12" | "h23";
+export declare function setCurrentChatLanguage(language: Language): void;
+export declare function translateChat(key: TranslationKey, params?: TranslationParams, language?: Language | null): string;
+export declare function useChatI18n(language?: MaybeRefOrGetter<Language | undefined | null>): {
+    locale: ComputedRef<"nb-NO" | "en-US">;
+    t: (key: TranslationKey, params?: TranslationParams) => string;
+};
+export {};

package/dist/chat/mentions.d.ts

@@ -0,0 +1,33 @@
+import { BaseMessage } from '@cometchat/chat-sdk-javascript';
+import { ParticipantInfo } from './types';
+export declare const MENTION_TOKEN_PATTERN: RegExp;
+export declare const MENTION_TOKEN_ENCODED_PATTERN: RegExp;
+export declare const MENTION_UID_DATA_ATTR = "data-mention-uid";
+export declare const COMPOSER_MENTION_CLASS = "composer-mention";
+export declare const MESSAGE_MENTION_CLASS = "message-mention";
+export interface MentionCandidate {
+    uid: string;
+    displayName: string;
+    avatar?: string;
+}
+export declare function participantToMentionCandidate(participant: ParticipantInfo): MentionCandidate;
+export declare function buildMentionNameByUid(candidates: ReadonlyArray<MentionCandidate>): Record<string, string>;
+export declare function filterMentionCandidates(candidates: ReadonlyArray<MentionCandidate>, query: string, limit?: number): MentionCandidate[];
+export declare function encodeMentionToken(uid: string): string;
+export declare function decodeMentionTokenEntities(text: string): string;
+export declare function containsMentionTokens(text: string): boolean;
+export declare function shieldMentionTokens(text: string): {
+    shielded: string;
+    tokens: string[];
+};
+export declare function unshieldMentionTokens(text: string, tokens: string[]): string;
+export declare function replaceMentionTokens(text: string, resolveName: (uid: string) => string, className?: string): string;
+export declare function convertMentionTokensToComposerHtml(text: string, nameByUid?: Record<string, string>): string;
+export declare function convertMentionTokensToMessageHtml(text: string, nameByUid?: Record<string, string>): string;
+export declare function serializeComposerHtmlToWireText(html: string): string;
+export declare function ingestMessageTextFromServer(text: string | null | undefined, nameByUid?: Record<string, string>): string;
+export declare function getMentionNameByUidFromSdkMessage(source: BaseMessage | undefined): Record<string, string>;
+export declare function mergeMentionNameByUid(...maps: ReadonlyArray<Record<string, string>>): Record<string, string>;
+export declare function formatMentionTokensPlain(text: string, nameByUid?: Record<string, string>): string;
+export declare function formatConversationSubtitlePreview(subtitle: string, nameByUid?: Record<string, string>): string;
+export declare function getPlainTextWithMentionLabels(html: string, nameByUid?: Record<string, string>): string;

package/dist/chat/messageText.d.ts

@@ -0,0 +1,21 @@
+import { BaseMessage } from '@cometchat/chat-sdk-javascript';
+import { formatConversationSubtitlePreview } from './mentions';
+import { ChatAttachmentItem, ChatMessageItem, ChatReplyPreview } from './types';
+type MessageTextSource = Pick<ChatMessageItem, "text" | "kind" | "poll" | "attachments">;
+export declare function getAttachmentDisplayText(attachments: ReadonlyArray<Pick<ChatAttachmentItem, "kind" | "name">>, fallback?: string): string;
+export declare function normalizeMessageText(value: string | null | undefined, mentionNameByUid?: Record<string, string>): string;
+export declare function serializeMessageTextForSend(value: string | null | undefined): string;
+export declare function hasMessageText(value: string | null | undefined): boolean;
+export declare function getMessagePlainText(value: string | null | undefined, mentionNameByUid?: Record<string, string>): string;
+export declare function getMessageDisplayText(message: MessageTextSource, fallback?: string, mentionNameByUid?: Record<string, string>): string;
+export declare function getMessagePreviewText(message: MessageTextSource, mentionNameByUid?: Record<string, string>): string;
+export declare function formatReplyPreviewText(text: string, mentionNameByUid?: Record<string, string>): string;
+export declare function getMessageTextPreview(message?: any, showEmoji?: boolean, showAttachmentName?: boolean): string;
+export declare function buildReplyPreview(message: Pick<ChatMessageItem, "id" | "senderName" | "text" | "kind" | "poll" | "attachments" | "source"> & {
+    source?: unknown;
+}): ChatReplyPreview;
+export declare function buildMessageActionText(message: Pick<ChatMessageItem, "text" | "attachments">): string;
+export declare function buildConversationSubtitle(message: MessageTextSource & {
+    source?: BaseMessage;
+}): string;
+export { formatConversationSubtitlePreview };

package/dist/chat/mockClient.d.ts

@@ -0,0 +1,13 @@
+import { ChatClient, ChatUserProfile } from './types';
+export type VisualFixtureMode = "desktop" | "mobile" | "empty" | "scheduled";
+export interface MockChatScenario {
+    client: ChatClient;
+    profile: ChatUserProfile;
+    displayName: string;
+    email: string;
+    heroStatus: {
+        label: string;
+        severity: "warn" | "success" | "contrast";
+    };
+}
+export declare function createMockChatScenario(mode: VisualFixtureMode): MockChatScenario;

package/dist/chat/offlineStore.d.ts

@@ -0,0 +1,55 @@
+import { CachedLastMessage, CachedParticipantSettings, ChatAttachmentItem, ChatConversationItem, ChatMessageItem, PollComposerInput } from './types';
+interface OfflineQueueAttachment {
+    kind: ChatAttachmentItem["kind"];
+    name: string;
+    type: string;
+    size: number;
+    caption?: string;
+}
+export interface OfflineQueueItem {
+    id: string;
+    muid: string;
+    conversationId: string;
+    targetId: string;
+    receiverType: "group" | "user";
+    kind: "text" | "poll" | "attachment";
+    senderAvatar?: string;
+    text?: string;
+    poll?: PollComposerInput;
+    attachment?: OfflineQueueAttachment;
+    metadata?: Record<string, unknown>;
+    parentMessageId?: string;
+    createdAt: string;
+}
+export declare class ChatOfflineStore {
+    readonly storageKey: string;
+    private attachmentDbPromise;
+    constructor(storageKey: string);
+    getConversations(): ChatConversationItem[];
+    getSearchableConversations(): ChatConversationItem[];
+    setConversations(conversations: ChatConversationItem[]): void;
+    getMessages(conversationId: string): ChatMessageItem[];
+    getAllMessages(): ChatMessageItem[];
+    setMessages(conversationId: string, messages: ChatMessageItem[]): void;
+    getThreadMessages(parentMessageId: string): ChatMessageItem[];
+    setThreadMessages(parentMessageId: string, messages: ChatMessageItem[]): void;
+    getPinnedMessages(conversationId: string): ChatMessageItem[];
+    setPinnedMessages(conversationId: string, records: ReadonlyArray<ChatMessageItem>): void;
+    getQueue(): OfflineQueueItem[];
+    enqueue(item: OfflineQueueItem): void;
+    dequeue(id: string): void;
+    getParticipantSettings(chatUid: string): CachedParticipantSettings | null;
+    storeParticipantSettings(settings: CachedParticipantSettings): void;
+    getLastMessage(chatUid: string): CachedLastMessage | null;
+    storeLastMessage(lastMessage: CachedLastMessage): void;
+    clear(): void;
+    storeQueuedAttachment(id: string, file: File): Promise<void>;
+    getQueuedAttachment(id: string): Promise<File | null>;
+    deleteQueuedAttachment(id: string): Promise<void>;
+    private read;
+    private write;
+    private mutate;
+    private clearQueuedAttachments;
+    private openAttachmentDb;
+}
+export {};

package/dist/chat/participants.d.ts

@@ -0,0 +1,8 @@
+import { GroupMember, User } from '@cometchat/chat-sdk-javascript';
+import { ParticipantInfo } from './types';
+/**
+ * Normalizes a CometChat `GroupMember`/`User` instance into a {@link ParticipantInfo}.
+ * Pass `roleOverride` when the caller already knows the role (e.g. from a scope-change event)
+ * rather than relying on the source object's own scope.
+ */
+export declare function normalizeParticipantInfo(source: GroupMember | User, roleOverride?: string): ParticipantInfo;

package/dist/chat/pinnedMessages.d.ts

@@ -0,0 +1,12 @@
+import { ChatMessageItem } from './types';
+export declare const SYSTEM_PINNER_UID = "app_system";
+export declare function canPinMessage(message: Pick<ChatMessageItem, "kind" | "isDeleted" | "deliveryState"> | null): boolean | null;
+export declare function isPinnedMessage(message: Pick<ChatMessageItem, "pinnedAt"> | null | undefined): boolean;
+/** Whether the pin came from the app/admin rather than from a member. */
+export declare function isSystemPinnedMessage(message: Pick<ChatMessageItem, "pinnedAt" | "pinnedBy"> | null | undefined): boolean;
+/** Most recently pinned message first, falling back to the send order. */
+export declare function sortPinnedMessages(messages: ReadonlyArray<ChatMessageItem>): ChatMessageItem[];
+export declare function upsertPinnedMessage(messages: ReadonlyArray<ChatMessageItem>, message: ChatMessageItem): ChatMessageItem[];
+export declare function removePinnedMessage(messages: ReadonlyArray<ChatMessageItem>, messageId: string): ChatMessageItem[];
+export declare function isPinnedMessageId(messages: ReadonlyArray<ChatMessageItem>, messageId: string): boolean;
+export declare function hasReachedPinnedMessagesLimit(messages: ReadonlyArray<ChatMessageItem>, limit: number | null | undefined): boolean;

package/dist/chat/publicChannelMessageFallback.d.ts

@@ -0,0 +1 @@
+export declare function installPublicChannelMessageFallback(): void;

package/dist/chat/reactions.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Emoji reaction sets used across message action menus and reaction pickers.
+ *
+ * COMMON_REACTIONS are shown first in the compact popover row.
+ * EXTENDED_REACTIONS populate the expanded grid when the user opens the full picker.
+ */
+export declare const COMMON_REACTIONS: string[];
+export declare const EXTENDED_REACTIONS: string[];

package/dist/chat/richText.d.ts

@@ -0,0 +1,9 @@
+export declare function normalizeRichTextForStorage(input: string | null | undefined): string;
+export interface RenderRichTextOptions {
+    mentionNameByUid?: Record<string, string>;
+}
+export declare function getPlainTextFromRichText(input: string | null | undefined, mentionNameByUid?: Record<string, string>): string;
+export declare function renderRichText(input: string | null | undefined, options?: RenderRichTextOptions): string;
+export declare function toMarkdownHtml(str: string, mentionedUsers?: any[]): string;
+export declare function getFirstUrlFromRichText(input: string | null | undefined): string | undefined;
+export declare function normalizeHyperlinkUrl(value: string | null | undefined): string | undefined;

package/dist/chat/runtime.d.ts

@@ -0,0 +1,3 @@
+import { ChatClient } from './types';
+import { ShallowRef } from 'vue';
+export declare const chatClient: ShallowRef<ChatClient | null, ChatClient | null>;

package/dist/chat/theme.d.ts

@@ -0,0 +1,19 @@
+import { ThemeMode } from './types';
+import { Ref } from 'vue';
+export declare const theme: Ref<{
+    palette: {
+        mode: ThemeMode;
+        setMode: (mode: ThemeMode) => void;
+    };
+}, {
+    palette: {
+        mode: ThemeMode;
+        setMode(mode: ThemeMode): void;
+    };
+} | {
+    palette: {
+        mode: ThemeMode;
+        setMode: (mode: ThemeMode) => void;
+    };
+}>;
+export declare function setThemeMode(mode: ThemeMode): void;

package/dist/chat/types.d.ts

@@ -0,0 +1,409 @@
+import { BaseMessage, Conversation, Group, MessageReceipt, CometChat } from '@cometchat/chat-sdk-javascript';
+import { ComputedRef, Ref } from 'vue';
+import { Environment } from './environment';
+export interface ChatUserProfile {
+    uid: string;
+    name: string;
+    avatar?: string;
+    status?: string;
+    lastSeen?: Date;
+}
+export interface FuseResultMatch {
+    indices: ReadonlyArray<[number, number]>;
+    key?: {
+        src: string;
+    } | string;
+    value?: string;
+}
+export type Language = "nb" | "no" | "ar" | "de" | "en" | "es" | "fr" | "hi" | "ms" | "pt" | "ru" | "zh" | "zh-tw" | "sv" | "lt";
+export type ThemeMode = "dark" | "light";
+export type OnlineStatus = "online" | "offline";
+export interface ChatInstallOptions {
+    environment: Environment;
+    language?: Language;
+    themeMode: ThemeMode;
+    accessToken?: Ref<string | null | undefined> | null | undefined | string;
+    loggerCallback?: (entry: LogEntry) => void;
+}
+export interface ChatInstance {
+    componentId: string;
+    replyToMessage: BaseMessage | null;
+    captionedAttachment: {
+        fileObject?: File;
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+    } | null;
+    decoyAttachment: {
+        fileObject?: File;
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+    } | null;
+    scheduledMessageChat?: Group;
+    showScheduledMessagesChat: boolean;
+    showAlert: boolean;
+    showRescheduleAlert: boolean;
+    userInput: string | null;
+    rescheduleInfo: {
+        rescheduleMuid: string;
+        messageId: number;
+    } | null;
+}
+export interface View {
+    componentName: string;
+    props?: Record<string, unknown>;
+}
+export type ChatMessageKind = "text" | "image" | "video" | "audio" | "file" | "poll" | "action" | "unsupported";
+export type ChatComposerTarget = "main" | "thread";
+export type ComposerFormatCommand = "bold" | "italic" | "underline";
+export type ComposerFormattingMode = "default" | "external";
+export interface ComposerSelectionRect {
+    x: number;
+    y: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    width: number;
+    height: number;
+}
+export interface ComposerSelectionState {
+    text: string;
+    href?: string;
+    rect: ComposerSelectionRect;
+}
+export interface ChatComposerSelectionState extends ComposerSelectionState {
+    target: ChatComposerTarget;
+}
+export interface BccChatComposerFormattingHandle {
+    applyComposerFormat(command: ComposerFormatCommand, target?: ChatComposerTarget): boolean;
+    requestComposerLink(target?: ChatComposerTarget): boolean;
+    applyComposerLink(url: string, target?: ChatComposerTarget): boolean;
+    cancelComposerLink(target?: ChatComposerTarget): void;
+    getComposerSelection(target?: ChatComposerTarget): ChatComposerSelectionState | null;
+}
+export interface BccChatExpose extends BccChatComposerFormattingHandle {
+    scrollToMessage(messageId: string): Promise<void>;
+    readonly groupMembers: ParticipantInfo[];
+}
+export interface ChatAttachmentItem {
+    kind: Extract<ChatMessageKind, "image" | "video" | "audio" | "file">;
+    name: string;
+    url?: string;
+    mimeType?: string;
+    extension?: string;
+    size?: number;
+    width?: number;
+    height?: number;
+}
+export interface ChatPollOptionItem {
+    id: string;
+    text: string;
+    voteCount: number;
+    voters: ChatUserProfile[];
+}
+export interface ChatPollData {
+    id?: string;
+    question: string;
+    options: ChatPollOptionItem[];
+    totalVotes: number;
+    allowsMultipleAnswers: boolean;
+}
+export interface ChatReactionItem {
+    emoji: string;
+    count: number;
+    reactedByMe: boolean;
+}
+export interface ChatReactionDetailItem {
+    emoji: string;
+    user: ChatUserProfile;
+    reactedAt?: Date;
+}
+export type ChatMessageReceiptKind = "delivered" | "read";
+export interface ChatMessageReceiptItem {
+    kind: ChatMessageReceiptKind;
+    user: ChatUserProfile;
+    timestamp?: Date;
+}
+export interface MessageInfo {
+    text?: string;
+    type: string;
+    senderUid: string;
+    senderName: string;
+    sentAt: Date;
+    sentByCurrentUser: boolean;
+    readAt: Date | undefined;
+    messageReceipts?: MessageReceipt[];
+}
+export interface ChatMessageReceiptSummary {
+    deliveredAt?: Date;
+    deliveredToMeAt?: Date;
+    readAt?: Date;
+    readByMeAt?: Date;
+}
+export interface ChatReplyPreview {
+    messageId: string;
+    senderName: string;
+    text: string;
+    kind: ChatMessageKind;
+}
+export interface ChatForwardedFromInfo {
+    senderName: string;
+}
+export type ChatDeliveryState = "sent" | "queued" | "sending" | "failed";
+export interface ChatScheduledInfo {
+    scheduleDate?: Date;
+    originalChatUid?: string;
+    muid?: string;
+    messageId?: number;
+}
+export interface ChatMessageItem {
+    id: string;
+    muid?: string;
+    conversationId: string;
+    senderId: string;
+    senderName: string;
+    text: string;
+    kind: ChatMessageKind;
+    sentAt: Date;
+    category: string;
+    type: string;
+    senderAvatar?: string;
+    isOwn: boolean;
+    isDeleted: boolean;
+    isEdited: boolean;
+    attachments: ChatAttachmentItem[];
+    poll?: ChatPollData;
+    scheduled?: ChatScheduledInfo;
+    translatedText?: string;
+    replyTo?: ChatReplyPreview;
+    forwardedFrom?: ChatForwardedFromInfo;
+    parentMessageId?: string;
+    replyCount: number;
+    reactions: ChatReactionItem[];
+    receipts: ChatMessageReceiptSummary;
+    /** Set while the message is pinned in its conversation; the same value for every member. */
+    pinnedAt?: Date;
+    /** Uid of the most recent pinner, or the `app_system` sentinel for an app/admin pin. */
+    pinnedBy?: string;
+    deliveryState: ChatDeliveryState;
+    metadata?: Record<string, unknown>;
+    source: any;
+}
+export interface ChatConversationItem {
+    id: string;
+    targetId: string;
+    type: "group" | "user";
+    title: string;
+    subtitle: string;
+    avatar?: string;
+    unreadCount: number;
+    lastMessageAt?: Date;
+    muteSettings?: Date | null;
+    hasJoined?: boolean;
+    tags: string[];
+    memberCount?: number;
+    source?: Conversation | null;
+    lastMessage?: ChatMessageItem | null;
+}
+export interface UserChatInfo {
+    chatUid: string;
+    name: string;
+    unreadMessageCount: number;
+    lastMessage?: MessageInfo;
+    membersCount: number;
+    tags: string[];
+    muteSettings?: Date | null;
+    hasJoined: boolean;
+}
+export interface ForwardMessageTarget {
+    chatUid: string;
+    type: "user" | "group";
+}
+export interface ParticipantInfo {
+    uid: string;
+    displayName: string;
+    avatar: string;
+    role: string;
+    lastSeen?: Date;
+}
+export interface DispatchData {
+    muid: string;
+    originalChatUid: string;
+    scheduleDate: string;
+    messageId: number;
+}
+export interface LogEntry {
+    logUid: string;
+    correlationUid?: string;
+    message: string;
+    severity: LogSeverity;
+    userMetadata?: Record<string, unknown>;
+    timestamp: string;
+}
+export declare enum LogSeverity {
+    DEBUG = "Debug",
+    INFO = "Info",
+    WARN = "Warn",
+    ERROR = "Error"
+}
+export interface SearchedItems {
+    conversations: {
+        conversation: ChatConversationItem;
+        matches: FuseResultMatch[];
+    }[];
+    messages: {
+        message: ChatMessageItem;
+        matches: FuseResultMatch[];
+    }[];
+}
+export interface ParticipantSettings {
+    chatUid: string;
+    personUid: string;
+    mutedUntil: string | null;
+}
+export interface PersonSettings {
+    mutedAll: boolean;
+}
+export interface CachedParticipantSettings {
+    chatUid: string;
+    mutedUntil: string | null;
+    lastUpdated: number;
+}
+export interface CachedLastMessage {
+    chatUid: string;
+    lastMessage: null | MessageInfo;
+    lastUpdated: number;
+}
+export interface AttachmentUploadInput {
+    file: File;
+    caption?: string;
+}
+export interface PollComposerInput {
+    question: string;
+    options: string[];
+}
+export interface MessageSendOptions {
+    senderDisplayName?: string;
+}
+export interface ScheduleMessageInput {
+    scheduleDate: string;
+    text?: string;
+    file?: File;
+    caption?: string;
+}
+export interface ChatMessagesGetterPagination {
+    total_pages?: number;
+    current_page?: number;
+    [key: string]: unknown;
+}
+export interface ChatMessagesGetterResult<TMessage = Record<string, unknown>> {
+    data: TMessage[];
+    meta?: {
+        pagination?: ChatMessagesGetterPagination;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+}
+export type ChatMessagesGetter = (guid: string, query: string) => Promise<ChatMessagesGetterResult>;
+export interface RescheduleMessageInput {
+    messageId: number;
+    muid: string;
+    originalChatUid: string;
+    scheduleDate: string;
+}
+export interface ChatClient {
+    initialized: Ref<boolean>;
+    loggingIn: Ref<boolean>;
+    loadingConversations: Ref<boolean>;
+    loadingMessages: Ref<boolean>;
+    loadingThreadMessages: Ref<boolean>;
+    loadingOlderMessages: Ref<boolean>;
+    loadingOlderThreadMessages: Ref<boolean>;
+    loadingScheduledMessages: Ref<boolean>;
+    sendingMessage: Ref<boolean>;
+    schedulingMessage: Ref<boolean>;
+    syncingQueue: Ref<boolean>;
+    connected: Ref<boolean>;
+    offlineMode: Ref<boolean>;
+    hideGroupActions: Ref<boolean>;
+    loggedIn: Ref<boolean>;
+    error: Ref<string | null>;
+    currentUser: Ref<ChatUserProfile | null>;
+    conversations: Ref<ChatConversationItem[]>;
+    messages: Ref<ChatMessageItem[]>;
+    threadMessages: Ref<ChatMessageItem[]>;
+    scheduledMessages: Ref<ChatMessageItem[]>;
+    /** Pinned messages of the active conversation, most recently pinned first. */
+    pinnedMessages: Ref<ChatMessageItem[]>;
+    loadingPinnedMessages: Ref<boolean>;
+    /** Whether Pin Message is enabled for the chat app. */
+    pinningEnabled: Ref<boolean>;
+    /** Server-owned cap on pins per conversation; null while unknown. */
+    pinnedMessagesLimit: Ref<number | null>;
+    hasOlderMessages: Ref<boolean>;
+    hasOlderThreadMessages: Ref<boolean>;
+    pendingQueueCount: ComputedRef<number>;
+    activeConversationId: Ref<string | null>;
+    activeConversation: ComputedRef<ChatConversationItem | null>;
+    activeThreadParentMessage: Ref<ChatMessageItem | null>;
+    replyToMessage: Ref<ChatMessageItem | null>;
+    editingMessage: Ref<ChatMessageItem | null>;
+    init: () => Promise<void>;
+    connectRealtime: () => Promise<void>;
+    disconnectRealtime: () => Promise<void>;
+    login: (accessToken: string) => Promise<void>;
+    logout: () => Promise<void>;
+    fetchConversations: () => Promise<void>;
+    selectConversation: (conversationId: string | null) => Promise<void>;
+    sendTextMessage: (text: string, options?: MessageSendOptions) => Promise<void>;
+    sendAttachmentMessage: (input: AttachmentUploadInput, options?: MessageSendOptions) => Promise<void>;
+    sendPollMessage: (input: PollComposerInput, options?: MessageSendOptions) => Promise<void>;
+    forwardMessage: (message: ChatMessageItem, target: ForwardMessageTarget) => Promise<void>;
+    fetchScheduledMessages: (originalChatUid?: string) => Promise<void>;
+    loadOlderMessages: () => Promise<boolean>;
+    loadOlderThreadMessages: () => Promise<boolean>;
+    ensureMessageLoaded: (messageId: string) => Promise<boolean>;
+    scheduleMessage: (input: ScheduleMessageInput, options?: MessageSendOptions) => Promise<void>;
+    rescheduleMessage: (input: RescheduleMessageInput) => Promise<void>;
+    removeScheduledMessage: (message: ChatMessageItem) => Promise<void>;
+    editScheduledMessage: (message: ChatMessageItem, nextText: string) => Promise<void>;
+    setReplyToMessage: (message: ChatMessageItem | null) => void;
+    setEditingMessage: (message: ChatMessageItem | null) => void;
+    openThread: (message: ChatMessageItem) => Promise<void>;
+    closeThread: () => void;
+    refreshVisibleMessages: (options?: {
+        includeThread?: boolean;
+    }) => Promise<void>;
+    fetchMessageReceipts: (message: ChatMessageItem) => Promise<ChatMessageReceiptItem[]>;
+    fetchMessageReactions: (message: ChatMessageItem) => Promise<ChatReactionDetailItem[]>;
+    deleteMessage: (message: ChatMessageItem) => Promise<void>;
+    votePoll: (message: ChatMessageItem, optionId: string) => Promise<void>;
+    toggleReaction: (message: ChatMessageItem, emoji: string) => Promise<void>;
+    fetchPinnedMessages: (conversationId?: string) => Promise<void>;
+    pinMessage: (message: ChatMessageItem) => Promise<void>;
+    unpinMessage: (messageId: string) => Promise<void>;
+    togglePinnedMessage: (message: ChatMessageItem) => Promise<void>;
+    isMessagePinned: (messageId: string) => boolean;
+    translateMessage: (message: ChatMessageItem) => Promise<void>;
+    mentionDisplayNamesByUid: Ref<Record<string, string>>;
+    rememberMentionDisplayNames: (entries: ReadonlyArray<{
+        uid: string;
+        displayName: string;
+    }>) => void;
+    initiateCall: (receiverId: string, container: HTMLElement, callType?: "video" | "audio", receiverType?: "user" | "group") => Promise<InstanceType<typeof CometChat.Call>>;
+    acceptIncomingCall: (container: HTMLElement, sessionId?: string) => Promise<void>;
+    rejectIncomingCall: (sessionId?: string) => Promise<void>;
+    endActiveCall: () => Promise<void>;
+    joinOutgoingCallSession: (container: HTMLElement) => Promise<void>;
+    incomingCall: Ref<InstanceType<typeof CometChat.Call> | null>;
+    incomingCalls: Ref<Map<string, InstanceType<typeof CometChat.Call>>>;
+    outgoingCall: Ref<InstanceType<typeof CometChat.Call> | null>;
+    activeCallSessionId: Ref<string | null>;
+    activeCallType: Ref<"audio" | "video">;
+    callState: Ref<"idle" | "outgoing" | "incoming" | "connecting" | "in-call">;
+}
+export type { Environment };