@bcc-code/vue-bcc-chat-ui 7.0.2 → 7.0.3

package/dist/index.d.ts

@@ -1,11 +1,1034 @@
-export { default as chat, default } from './chat';
-export * from './chat/types';
-export { default as BccChatMessageList } from './components/chat/BccChat.vue';
-/** Alias for the message-list component under its new canonical name. */
-export { default as BccChat } from './components/chat/BccChat.vue';
-/**
- * Create an independent ChatClient instance.  Useful when you need to render
- * multiple `<BccChat>` components with different `chatUid` values on the same
- * page — pass a separate client to each via the `client` prop.
- */
-export { createChatClient } from './chat/client';
+import { AllowedComponentProps } from 'vue';
+import { App } from 'vue';
+import { BaseMessage } from '@cometchat/chat-sdk-javascript';
+import { ComponentCustomProps } from 'vue';
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { CreateComponentPublicInstanceWithMixins } from 'vue';
+import { DefineComponent } from 'vue';
+import { GlobalComponents } from 'vue';
+import { GlobalDirectives } from 'vue';
+import { Group } from '@cometchat/chat-sdk-javascript';
+import { MessageReceipt } from '@cometchat/chat-sdk-javascript';
+import { PopoverMethods } from 'primevue';
+import { PopoverProps } from 'primevue';
+import { PopoverSlots } from 'primevue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { VNodeProps } from 'vue';
+import { WritableComputedRef } from 'vue';
+
+declare const __VLS_component: DefineComponent<__VLS_Props, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+groupMembersFetched: (members: ParticipantInfo[]) => any;
+chatEmpty: () => any;
+}, string, PublicProps, Readonly<__VLS_Props> & Readonly<{
+onGroupMembersFetched?: ((members: ParticipantInfo[]) => any) | undefined;
+onChatEmpty?: (() => any) | undefined;
+}>, {
+messages: ChatMessageItem[];
+senderDisplayName: string;
+client: ChatClient | null;
+conversation: ChatConversationItem | null;
+threadMessages: ChatMessageItem[];
+loadingMessages: boolean;
+loadingThreadMessages: boolean;
+isReadOnly: boolean;
+sendOptions: MessageSendOptions;
+showDefaultEmptyState: boolean;
+initialScheduledMessagesOpen: boolean;
+chatUid: string;
+hideDeletedMessages: boolean;
+groupMessageGetter: (guid: string, query: string) => Promise<unknown>;
+loadMessageId: string;
+displayNoMessagesText: boolean;
+language: Language;
+showHeader: boolean;
+showMessageHeader: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, false, {
+chatRootRef: HTMLDivElement;
+mainComposerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+target: ChatTarget;
+}> & Readonly<{}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+composerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+modelValue: string;
+disabled: boolean;
+resetSignal: number;
+showScheduledButton?: boolean;
+replyToMessage?: ChatMessageItem | null;
+editingMessage?: ChatMessageItem | null;
+contextLabel?: string;
+offlineMode?: boolean;
+pendingQueueCount?: number;
+compact?: boolean;
+}> & Readonly<{
+onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+"onUpdate:modelValue"?: ((value: string) => any) | undefined;
+onSendText?: (() => any) | undefined;
+onOpenScheduled?: (() => any) | undefined;
+onCancelReply?: (() => any) | undefined;
+onCancelEdit?: (() => any) | undefined;
+}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+scheduleMessage: (input: ScheduleMessageInput) => any;
+sendAttachment: (input: AttachmentUploadInput) => any;
+sendPoll: (input: PollComposerInput) => any;
+"update:modelValue": (value: string) => any;
+sendText: () => any;
+openScheduled: () => any;
+cancelReply: () => any;
+cancelEdit: () => any;
+}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+fileInputRef: HTMLInputElement;
+composerShellRef: HTMLDivElement;
+composerEditorRef: HTMLDivElement;
+composerActionsRef: CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+onOpenPoll?: (() => any) | undefined;
+}>, {
+toggle: (event: Event) => void;
+hide: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+openPoll: () => any;
+}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+popoverRef: ({
+$props: PopoverProps & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$slots: PopoverSlots;
+$emit: ((e: "show") => void) & ((e: "hide") => void);
+} & PopoverMethods) | null;
+}, any, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{}> & Readonly<{
+onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+onOpenPoll?: (() => any) | undefined;
+}>, {
+toggle: (event: Event) => void;
+hide: () => void;
+}, {}, {}, {}, {}> | null;
+}, HTMLDivElement, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{
+modelValue: string;
+disabled: boolean;
+resetSignal: number;
+showScheduledButton?: boolean;
+replyToMessage?: ChatMessageItem | null;
+editingMessage?: ChatMessageItem | null;
+contextLabel?: string;
+offlineMode?: boolean;
+pendingQueueCount?: number;
+compact?: boolean;
+}> & Readonly<{
+onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+"onUpdate:modelValue"?: ((value: string) => any) | undefined;
+onSendText?: (() => any) | undefined;
+onOpenScheduled?: (() => any) | undefined;
+onCancelReply?: (() => any) | undefined;
+onCancelEdit?: (() => any) | undefined;
+}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, {}> | null;
+}, any, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{
+target: ChatTarget;
+}> & Readonly<{}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, {}> | null;
+threadComposerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+target: ChatTarget;
+}> & Readonly<{}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+composerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+modelValue: string;
+disabled: boolean;
+resetSignal: number;
+showScheduledButton?: boolean;
+replyToMessage?: ChatMessageItem | null;
+editingMessage?: ChatMessageItem | null;
+contextLabel?: string;
+offlineMode?: boolean;
+pendingQueueCount?: number;
+compact?: boolean;
+}> & Readonly<{
+onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+"onUpdate:modelValue"?: ((value: string) => any) | undefined;
+onSendText?: (() => any) | undefined;
+onOpenScheduled?: (() => any) | undefined;
+onCancelReply?: (() => any) | undefined;
+onCancelEdit?: (() => any) | undefined;
+}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+scheduleMessage: (input: ScheduleMessageInput) => any;
+sendAttachment: (input: AttachmentUploadInput) => any;
+sendPoll: (input: PollComposerInput) => any;
+"update:modelValue": (value: string) => any;
+sendText: () => any;
+openScheduled: () => any;
+cancelReply: () => any;
+cancelEdit: () => any;
+}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+fileInputRef: HTMLInputElement;
+composerShellRef: HTMLDivElement;
+composerEditorRef: HTMLDivElement;
+composerActionsRef: CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+onOpenPoll?: (() => any) | undefined;
+}>, {
+toggle: (event: Event) => void;
+hide: () => void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+openPoll: () => any;
+}, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+popoverRef: ({
+$props: PopoverProps & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+$slots: PopoverSlots;
+$emit: ((e: "show") => void) & ((e: "hide") => void);
+} & PopoverMethods) | null;
+}, any, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{}> & Readonly<{
+onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+onOpenPoll?: (() => any) | undefined;
+}>, {
+toggle: (event: Event) => void;
+hide: () => void;
+}, {}, {}, {}, {}> | null;
+}, HTMLDivElement, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{
+modelValue: string;
+disabled: boolean;
+resetSignal: number;
+showScheduledButton?: boolean;
+replyToMessage?: ChatMessageItem | null;
+editingMessage?: ChatMessageItem | null;
+contextLabel?: string;
+offlineMode?: boolean;
+pendingQueueCount?: number;
+compact?: boolean;
+}> & Readonly<{
+onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+"onUpdate:modelValue"?: ((value: string) => any) | undefined;
+onSendText?: (() => any) | undefined;
+onOpenScheduled?: (() => any) | undefined;
+onCancelReply?: (() => any) | undefined;
+onCancelEdit?: (() => any) | undefined;
+}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, {}> | null;
+}, any, ComponentProvideOptions, {
+P: {};
+B: {};
+D: {};
+C: {};
+M: {};
+Defaults: {};
+}, Readonly<{
+target: ChatTarget;
+}> & Readonly<{}>, {
+focusEditor: () => Promise<void>;
+}, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+
+declare type __VLS_Props = {
+    client?: ChatClient | null;
+    conversation?: ChatConversationItem | null;
+    messages?: ChatMessageItem[];
+    threadMessages?: ChatMessageItem[];
+    loadingMessages?: boolean;
+    loadingThreadMessages?: boolean;
+    isReadOnly?: boolean;
+    sendOptions?: MessageSendOptions;
+    showDefaultEmptyState?: boolean;
+    initialScheduledMessagesOpen?: boolean;
+    chatUid?: string;
+    senderDisplayName?: string;
+    hideDeletedMessages?: boolean;
+    groupMessageGetter?: (guid: string, query: string) => Promise<unknown>;
+    loadMessageId?: string;
+    displayNoMessagesText?: boolean;
+    language?: Language;
+    showHeader?: boolean;
+    showMessageHeader?: boolean;
+};
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'message-header'?(_: {
+            conversation: ChatConversationItem | null;
+            parentMessage: ChatMessageItem | null;
+            target: ChatTarget;
+            title: string;
+            subtitle: string;
+            memberCount: number;
+        }): any;
+        'no-messages'?(_: {}): any;
+    };
+    refs: {
+        chatRootRef: HTMLDivElement;
+        mainComposerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+        target: ChatTarget;
+        }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        composerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue: string;
+        disabled: boolean;
+        resetSignal: number;
+        showScheduledButton?: boolean;
+        replyToMessage?: ChatMessageItem | null;
+        editingMessage?: ChatMessageItem | null;
+        contextLabel?: string;
+        offlineMode?: boolean;
+        pendingQueueCount?: number;
+        compact?: boolean;
+        }> & Readonly<{
+        onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+        onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+        onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onSendText?: (() => any) | undefined;
+        onOpenScheduled?: (() => any) | undefined;
+        onCancelReply?: (() => any) | undefined;
+        onCancelEdit?: (() => any) | undefined;
+        }>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        scheduleMessage: (input: ScheduleMessageInput) => any;
+        sendAttachment: (input: AttachmentUploadInput) => any;
+        sendPoll: (input: PollComposerInput) => any;
+        "update:modelValue": (value: string) => any;
+        sendText: () => any;
+        openScheduled: () => any;
+        cancelReply: () => any;
+        cancelEdit: () => any;
+        }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        fileInputRef: HTMLInputElement;
+        composerShellRef: HTMLDivElement;
+        composerEditorRef: HTMLDivElement;
+        composerActionsRef: CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+        onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+        onOpenPoll?: (() => any) | undefined;
+        }>, {
+        toggle: (event: Event) => void;
+        hide: () => void;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+        openPoll: () => any;
+        }, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        popoverRef: ({
+        $props: PopoverProps & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $slots: PopoverSlots;
+        $emit: ((e: "show") => void) & ((e: "hide") => void);
+        } & PopoverMethods) | null;
+        }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+        }, Readonly<{}> & Readonly<{
+        onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+        onOpenPoll?: (() => any) | undefined;
+        }>, {
+        toggle: (event: Event) => void;
+        hide: () => void;
+        }, {}, {}, {}, {}> | null;
+        }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+        }, Readonly<{
+        modelValue: string;
+        disabled: boolean;
+        resetSignal: number;
+        showScheduledButton?: boolean;
+        replyToMessage?: ChatMessageItem | null;
+        editingMessage?: ChatMessageItem | null;
+        contextLabel?: string;
+        offlineMode?: boolean;
+        pendingQueueCount?: number;
+        compact?: boolean;
+        }> & Readonly<{
+        onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+        onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+        onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onSendText?: (() => any) | undefined;
+        onOpenScheduled?: (() => any) | undefined;
+        onCancelReply?: (() => any) | undefined;
+        onCancelEdit?: (() => any) | undefined;
+        }>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, {}> | null;
+        }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+        }, Readonly<{
+        target: ChatTarget;
+        }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, {}> | null;
+        threadComposerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+        target: ChatTarget;
+        }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        composerRef: CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue: string;
+        disabled: boolean;
+        resetSignal: number;
+        showScheduledButton?: boolean;
+        replyToMessage?: ChatMessageItem | null;
+        editingMessage?: ChatMessageItem | null;
+        contextLabel?: string;
+        offlineMode?: boolean;
+        pendingQueueCount?: number;
+        compact?: boolean;
+        }> & Readonly<{
+        onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+        onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+        onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onSendText?: (() => any) | undefined;
+        onOpenScheduled?: (() => any) | undefined;
+        onCancelReply?: (() => any) | undefined;
+        onCancelEdit?: (() => any) | undefined;
+        }>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        scheduleMessage: (input: ScheduleMessageInput) => any;
+        sendAttachment: (input: AttachmentUploadInput) => any;
+        sendPoll: (input: PollComposerInput) => any;
+        "update:modelValue": (value: string) => any;
+        sendText: () => any;
+        openScheduled: () => any;
+        cancelReply: () => any;
+        cancelEdit: () => any;
+        }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        fileInputRef: HTMLInputElement;
+        composerShellRef: HTMLDivElement;
+        composerEditorRef: HTMLDivElement;
+        composerActionsRef: CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+        onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+        onOpenPoll?: (() => any) | undefined;
+        }>, {
+        toggle: (event: Event) => void;
+        hide: () => void;
+        }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+        pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+        openPoll: () => any;
+        }, PublicProps, {}, true, {}, {}, GlobalComponents, GlobalDirectives, string, {
+        popoverRef: ({
+        $props: PopoverProps & VNodeProps & AllowedComponentProps & ComponentCustomProps;
+        $slots: PopoverSlots;
+        $emit: ((e: "show") => void) & ((e: "hide") => void);
+        } & PopoverMethods) | null;
+        }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+        }, Readonly<{}> & Readonly<{
+        onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+        onOpenPoll?: (() => any) | undefined;
+        }>, {
+        toggle: (event: Event) => void;
+        hide: () => void;
+        }, {}, {}, {}, {}> | null;
+        }, HTMLDivElement, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+        }, Readonly<{
+        modelValue: string;
+        disabled: boolean;
+        resetSignal: number;
+        showScheduledButton?: boolean;
+        replyToMessage?: ChatMessageItem | null;
+        editingMessage?: ChatMessageItem | null;
+        contextLabel?: string;
+        offlineMode?: boolean;
+        pendingQueueCount?: number;
+        compact?: boolean;
+        }> & Readonly<{
+        onScheduleMessage?: ((input: ScheduleMessageInput) => any) | undefined;
+        onSendAttachment?: ((input: AttachmentUploadInput) => any) | undefined;
+        onSendPoll?: ((input: PollComposerInput) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onSendText?: (() => any) | undefined;
+        onOpenScheduled?: (() => any) | undefined;
+        onCancelReply?: (() => any) | undefined;
+        onCancelEdit?: (() => any) | undefined;
+        }>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, {}> | null;
+        }, any, ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+        }, Readonly<{
+        target: ChatTarget;
+        }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+        }, {}, {}, {}, {}> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare interface AttachmentUploadInput {
+    file: File;
+    caption?: string;
+}
+
+export declare interface CachedLastMessage {
+    chatUid: string;
+    lastMessage: null | MessageInfo;
+    lastUpdated: number;
+}
+
+export declare interface CachedParticipantSettings {
+    chatUid: string;
+    mutedUntil: string | null;
+    lastUpdated: number;
+}
+
+declare const chat: {
+    install: typeof install;
+    updateGetGroupMessages: typeof updateGetGroupMessages;
+    initialized: Ref<boolean, boolean>;
+    connected: ComputedRef<boolean>;
+    connecting: ComputedRef<boolean>;
+    loggedIn: ComputedRef<boolean>;
+    userChats: ComputedRef<UserChatInfo[]>;
+    connect: typeof connect;
+    disconnect: typeof disconnect;
+    disconnectAll: typeof disconnectAll;
+    setAccessToken: typeof setAccessToken;
+    login: typeof login;
+    logout: typeof logout;
+    setCurrentEnvironment: typeof setEnvironment;
+    getCurrentEnvironment: typeof getCurrentEnvironment;
+    setThemeMode: typeof setThemeMode;
+    setLanguage: typeof setLanguage;
+    getGroup: typeof getGroup;
+    getGroupMembersInfo: typeof getGroupMembersInfo;
+    getUserChats: typeof getUserChats;
+    clearGroupChatCount: typeof clearGroupChatCount;
+    getOnlineGroupMemberCount: typeof getOnlineGroupMemberCount;
+    getGroupOnlineCount: typeof getOnlineGroupMemberCount;
+    searchChat: (searchQuery: string, limit?: number) => SearchedItems | undefined;
+    getSenderDisplayName: typeof getSenderDisplayName;
+    getMessageTextPreview: typeof getMessageTextPreview;
+    proxyImage: typeof proxyImage;
+    getMutedUntil: typeof getMutedUntil;
+    muteChat: typeof muteChat;
+    getMyChatSettings: typeof getMyChatSettings;
+    updateMyChatSettings: typeof updateMyChatSettings;
+    setMuteAll: typeof setMuteAll;
+    toggleMuteAll: typeof toggleMuteAll;
+    toMarkdownHtml: typeof toMarkdownHtml;
+    retrieveCcToken: typeof retrieveCcToken;
+    getGroupMessages: Ref<((guid: string, query: string) => Promise<unknown>) | undefined, ((guid: string, query: string) => Promise<unknown>) | undefined>;
+    loadMessageId: Ref<string | undefined, string | undefined>;
+    scrollToMessageId: Ref<string | undefined, string | undefined>;
+    scrollToMessage: typeof scrollToMessage;
+    connectivity: {
+        onlineMode: WritableComputedRef<OnlineStatus, OnlineStatus>;
+        onlineStatus: ComputedRef<OnlineStatus>;
+    };
+    onlineMode: WritableComputedRef<OnlineStatus, OnlineStatus>;
+    onlineStatus: ComputedRef<OnlineStatus>;
+    theme: Ref<    {
+    palette: {
+    mode: ThemeMode;
+    setMode: (mode: ThemeMode) => void;
+    };
+    }, {
+    palette: {
+    mode: ThemeMode;
+    setMode(mode: ThemeMode): void;
+    };
+    } | {
+    palette: {
+    mode: ThemeMode;
+    setMode: (mode: ThemeMode) => void;
+    };
+    }>;
+    themeMode: Ref<ThemeMode, ThemeMode>;
+    language: Ref<Language, Language>;
+};
+export { chat }
+export default chat;
+
+export declare interface ChatAttachmentItem {
+    kind: Extract<ChatMessageKind, "image" | "video" | "audio" | "file">;
+    name: string;
+    url?: string;
+    mimeType?: string;
+    extension?: string;
+    size?: number;
+}
+
+export declare 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>;
+    loggedIn: Ref<boolean>;
+    error: Ref<string | null>;
+    currentUser: Ref<ChatUserProfile | null>;
+    conversations: Ref<ChatConversationItem[]>;
+    messages: Ref<ChatMessageItem[]>;
+    threadMessages: Ref<ChatMessageItem[]>;
+    scheduledMessages: Ref<ChatMessageItem[]>;
+    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) => Promise<void>;
+    sendTextMessage: (text: string, options?: MessageSendOptions) => Promise<void>;
+    sendAttachmentMessage: (input: AttachmentUploadInput, options?: MessageSendOptions) => Promise<void>;
+    sendPollMessage: (input: PollComposerInput, options?: MessageSendOptions) => 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>;
+    setReplyToMessage: (message: ChatMessageItem | null) => void;
+    setEditingMessage: (message: ChatMessageItem | null) => void;
+    openThread: (message: ChatMessageItem) => Promise<void>;
+    closeThread: () => void;
+    fetchMessageReceipts: (message: ChatMessageItem) => Promise<ChatMessageReceiptItem[]>;
+    deleteMessage: (message: ChatMessageItem) => Promise<void>;
+    votePoll: (message: ChatMessageItem, optionId: string) => Promise<void>;
+    toggleReaction: (message: ChatMessageItem, emoji: string) => Promise<void>;
+    translateMessage: (message: ChatMessageItem) => Promise<void>;
+}
+
+export declare interface ChatConversationItem {
+    id: string;
+    targetId: string;
+    type: "group" | "user";
+    title: string;
+    subtitle: string;
+    avatar?: string;
+    unreadCount: number;
+    lastMessageAt?: Date;
+    muteSettings?: Date | null;
+    tags: string[];
+    memberCount?: number;
+    source: any;
+}
+
+export declare type ChatDeliveryState = "sent" | "queued" | "sending" | "failed";
+
+declare interface ChatEnvironmentConfig {
+    region: string;
+    appId: string;
+    chatApiBaseUrl: string;
+}
+
+export declare interface ChatInstallOptions {
+    environment: Environment;
+    language?: Language;
+    themeMode: ThemeMode;
+    accessToken?: Ref<string | null | undefined> | null | undefined | string;
+    loggerCallback?: (entry: LogEntry) => void;
+}
+
+export declare 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 declare 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;
+    parentMessageId?: string;
+    replyCount: number;
+    reactions: ChatReactionItem[];
+    receipts: ChatMessageReceiptSummary;
+    deliveryState: ChatDeliveryState;
+    metadata?: Record<string, unknown>;
+    source: any;
+}
+
+export declare type ChatMessageKind = "text" | "image" | "video" | "audio" | "file" | "poll" | "action" | "unsupported";
+
+export declare interface ChatMessageReceiptItem {
+    kind: ChatMessageReceiptKind;
+    user: ChatUserProfile;
+    timestamp?: Date;
+}
+
+export declare type ChatMessageReceiptKind = "delivered" | "read";
+
+export declare interface ChatMessageReceiptSummary {
+    deliveredAt?: Date;
+    deliveredToMeAt?: Date;
+    readAt?: Date;
+    readByMeAt?: Date;
+}
+
+export declare interface ChatPollData {
+    id?: string;
+    question: string;
+    options: ChatPollOptionItem[];
+    totalVotes: number;
+    allowsMultipleAnswers: boolean;
+}
+
+export declare interface ChatPollOptionItem {
+    id: string;
+    text: string;
+    voteCount: number;
+    voters: string[];
+}
+
+export declare interface ChatReactionItem {
+    emoji: string;
+    count: number;
+    reactedByMe: boolean;
+}
+
+export declare interface ChatReplyPreview {
+    messageId: string;
+    senderName: string;
+    text: string;
+    kind: ChatMessageKind;
+}
+
+export declare interface ChatScheduledInfo {
+    scheduleDate?: Date;
+    originalChatUid?: string;
+    muid?: string;
+    messageId?: number;
+}
+
+/** Target identifier used to distinguish main-conversation from thread actions. */
+declare type ChatTarget = "main" | "thread";
+
+export declare interface ChatUserProfile {
+    uid: string;
+    name: string;
+    avatar?: string;
+    status?: string;
+}
+
+declare function clearGroupChatCount(groupUid: string): Promise<void>;
+
+declare function connect(connectionName?: string): Promise<void>;
+
+export declare function createChatClient({ environment, }: CreateChatClientOptions): ChatClient;
+
+declare interface CreateChatClientOptions {
+    environment: Environment;
+}
+
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export { _default as BccChat }
+export { _default as BccChatMessageList }
+
+declare function disconnect(connectionName?: string): Promise<void>;
+
+declare function disconnectAll(): Promise<void>;
+
+export declare interface DispatchData {
+    muid: string;
+    originalChatUid: string;
+    scheduleDate: string;
+    messageId: number;
+}
+
+export declare type Environment = "prod" | "sandbox";
+
+export declare interface FuseResultMatch {
+    indices: ReadonlyArray<[number, number]>;
+    key?: {
+        src: string;
+    } | string;
+    value?: string;
+}
+
+declare function getCurrentEnvironment(): ChatEnvironmentConfig;
+
+declare function getGroup(groupUid: string): Promise<Group | null | undefined>;
+
+declare function getGroupMembersInfo(groupUid: string): Promise<ParticipantInfo[]>;
+
+declare function getMessageTextPreview(message?: any, showEmoji?: boolean, showAttachmentName?: boolean): string;
+
+declare function getMutedUntil(chatUid: string): Promise<string | null>;
+
+declare function getMyChatSettings(): Promise<PersonSettings>;
+
+declare function getOnlineGroupMemberCount(groupUid: string): Promise<number>;
+
+declare function getSenderDisplayName(message: any, group?: {
+    value?: any;
+}): any;
+
+declare function getUserChats(): Promise<UserChatInfo[]>;
+
+declare function install(app: App, options: ChatInstallOptions): Promise<void>;
+
+export declare type Language = "nb" | "no" | "ar" | "de" | "en" | "es" | "fr" | "hi" | "ms" | "pt" | "ru" | "zh" | "zh-tw" | "sv" | "lt";
+
+export declare interface LogEntry {
+    logUid: string;
+    correlationUid?: string;
+    message: string;
+    severity: LogSeverity;
+    userMetadata?: Record<string, unknown>;
+    timestamp: string;
+}
+
+declare function login(accessToken?: string): Promise<void>;
+
+declare function logout(): Promise<void>;
+
+export declare enum LogSeverity {
+    DEBUG = "Debug",
+    INFO = "Info",
+    WARN = "Warn",
+    ERROR = "Error"
+}
+
+export declare interface MessageInfo {
+    text?: string;
+    type: string;
+    senderName: string;
+    sentAt: Date;
+    messageReceipts?: MessageReceipt[];
+}
+
+export declare interface MessageSendOptions {
+    senderDisplayName?: string;
+}
+
+declare function muteChat(chatUid: string, mutedUntil: string | null): Promise<string | null>;
+
+export declare type OnlineStatus = "online" | "offline";
+
+export declare interface ParticipantInfo {
+    uid: string;
+    displayName: string;
+    avatar: string;
+    role: string;
+}
+
+export declare interface ParticipantSettings {
+    chatUid: string;
+    personUid: string;
+    mutedUntil: string | null;
+}
+
+export declare interface PersonSettings {
+    mutedAll: boolean;
+}
+
+export declare interface PollComposerInput {
+    question: string;
+    options: string[];
+    allowsMultipleAnswers?: boolean;
+}
+
+declare function proxyImage(imageUrl: string): string;
+
+export declare interface RescheduleMessageInput {
+    messageId: number;
+    muid: string;
+    originalChatUid: string;
+    scheduleDate: string;
+}
+
+declare function retrieveCcToken(): StoredCometChatToken | null;
+
+export declare interface ScheduleMessageInput {
+    scheduleDate: string;
+    text?: string;
+    file?: File;
+    caption?: string;
+}
+
+declare function scrollToMessage(messageId: string): void;
+
+export declare interface SearchedItems {
+    conversations: {
+        conversation: ChatConversationItem;
+        matches: FuseResultMatch[];
+    }[];
+    messages: {
+        message: ChatMessageItem;
+        matches: FuseResultMatch[];
+    }[];
+}
+
+declare function setAccessToken(token: string): Promise<void>;
+
+declare function setEnvironment(environment: Environment): void;
+
+declare function setLanguage(language: Language): void;
+
+declare function setMuteAll(mute: boolean): Promise<boolean>;
+
+declare function setThemeMode(mode: ThemeMode): void;
+
+declare interface StoredCometChatToken {
+    sub: string;
+    token: string;
+}
+
+export declare type ThemeMode = "dark" | "light";
+
+declare function toggleMuteAll(): Promise<boolean>;
+
+declare function toMarkdownHtml(str: string, mentionedUsers?: any[]): string;
+
+declare function updateGetGroupMessages(groupMessageGetter: ((guid: string, query: string) => Promise<unknown>) | undefined): void;
+
+declare function updateMyChatSettings(settings: Partial<PersonSettings>): Promise<PersonSettings>;
+
+export declare interface UserChatInfo {
+    chatUid: string;
+    name: string;
+    unreadMessageCount: number;
+    lastMessage?: MessageInfo;
+    membersCount: number;
+    tags: string[];
+    muteSettings?: Date | null;
+}
+
+export declare interface View {
+    componentName: string;
+    props?: Record<string, unknown>;
+}
+
+export { }