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

package/dist/components/chat/BccChat.vue.d.ts

@@ -0,0 +1,509 @@
+import { ChatClient, ChatConversationItem, ChatMessageItem, Language, MessageSendOptions, ParticipantInfo } from '../../chat/types';
+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;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'no-messages'?(_: {}): any;
+    };
+    refs: {
+        chatRootRef: HTMLDivElement;
+        mainComposerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            target: import('../../composables/useChatEventBus').ChatTarget;
+        }> & Readonly<{}>, {
+            focusEditor: () => Promise<void>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            composerRef: import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+                onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+                onSendPoll?: ((input: import('../..').PollComposerInput) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onSendText?: (() => any) | undefined;
+                onOpenScheduled?: (() => any) | undefined;
+                onCancelReply?: (() => any) | undefined;
+                onCancelEdit?: (() => any) | undefined;
+            }>, {
+                focusEditor: () => Promise<void>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                scheduleMessage: (input: import('../..').ScheduleMessageInput) => any;
+                sendAttachment: (input: import('../..').AttachmentUploadInput) => any;
+                sendPoll: (input: import('../..').PollComposerInput) => any;
+                "update:modelValue": (value: string) => any;
+                sendText: () => any;
+                openScheduled: () => any;
+                cancelReply: () => any;
+                cancelEdit: () => any;
+            }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                fileInputRef: HTMLInputElement;
+                composerShellRef: HTMLDivElement;
+                composerEditorRef: HTMLDivElement;
+                composerActionsRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+                    onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+                    onOpenPoll?: (() => any) | undefined;
+                }>, {
+                    toggle: (event: Event) => void;
+                    hide: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+                    openPoll: () => any;
+                }, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                    popoverRef: ({
+                        $props: import('primevue').PopoverProps & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                        $slots: import('primevue').PopoverSlots;
+                        $emit: ((e: "show") => void) & ((e: "hide") => void);
+                    } & import('primevue').PopoverMethods) | null;
+                }, any, import('vue').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, import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+                onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+                onSendPoll?: ((input: import('../..').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, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            target: import('../../composables/useChatEventBus').ChatTarget;
+        }> & Readonly<{}>, {
+            focusEditor: () => Promise<void>;
+        }, {}, {}, {}, {}> | null;
+        threadComposerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+            target: import('../../composables/useChatEventBus').ChatTarget;
+        }> & Readonly<{}>, {
+            focusEditor: () => Promise<void>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            composerRef: import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+                onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+                onSendPoll?: ((input: import('../..').PollComposerInput) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+                onSendText?: (() => any) | undefined;
+                onOpenScheduled?: (() => any) | undefined;
+                onCancelReply?: (() => any) | undefined;
+                onCancelEdit?: (() => any) | undefined;
+            }>, {
+                focusEditor: () => Promise<void>;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                scheduleMessage: (input: import('../..').ScheduleMessageInput) => any;
+                sendAttachment: (input: import('../..').AttachmentUploadInput) => any;
+                sendPoll: (input: import('../..').PollComposerInput) => any;
+                "update:modelValue": (value: string) => any;
+                sendText: () => any;
+                openScheduled: () => any;
+                cancelReply: () => any;
+                cancelEdit: () => any;
+            }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                fileInputRef: HTMLInputElement;
+                composerShellRef: HTMLDivElement;
+                composerEditorRef: HTMLDivElement;
+                composerActionsRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+                    onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+                    onOpenPoll?: (() => any) | undefined;
+                }>, {
+                    toggle: (event: Event) => void;
+                    hide: () => void;
+                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                    pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+                    openPoll: () => any;
+                }, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                    popoverRef: ({
+                        $props: import('primevue').PopoverProps & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                        $slots: import('primevue').PopoverSlots;
+                        $emit: ((e: "show") => void) & ((e: "hide") => void);
+                    } & import('primevue').PopoverMethods) | null;
+                }, any, import('vue').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, import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+                onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+                onSendPoll?: ((input: import('../..').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, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<{
+            target: import('../../composables/useChatEventBus').ChatTarget;
+        }> & Readonly<{}>, {
+            focusEditor: () => Promise<void>;
+        }, {}, {}, {}, {}> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    groupMembersFetched: (members: ParticipantInfo[]) => any;
+    chatEmpty: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onGroupMembersFetched?: ((members: ParticipantInfo[]) => any) | undefined;
+    onChatEmpty?: (() => any) | undefined;
+}>, {
+    messages: ChatMessageItem[];
+    senderDisplayName: string;
+    conversation: ChatConversationItem | null;
+    client: ChatClient | 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;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    chatRootRef: HTMLDivElement;
+    mainComposerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        target: import('../../composables/useChatEventBus').ChatTarget;
+    }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        composerRef: import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+            onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+            onSendPoll?: ((input: import('../..').PollComposerInput) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onSendText?: (() => any) | undefined;
+            onOpenScheduled?: (() => any) | undefined;
+            onCancelReply?: (() => any) | undefined;
+            onCancelEdit?: (() => any) | undefined;
+        }>, {
+            focusEditor: () => Promise<void>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            scheduleMessage: (input: import('../..').ScheduleMessageInput) => any;
+            sendAttachment: (input: import('../..').AttachmentUploadInput) => any;
+            sendPoll: (input: import('../..').PollComposerInput) => any;
+            "update:modelValue": (value: string) => any;
+            sendText: () => any;
+            openScheduled: () => any;
+            cancelReply: () => any;
+            cancelEdit: () => any;
+        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            fileInputRef: HTMLInputElement;
+            composerShellRef: HTMLDivElement;
+            composerEditorRef: HTMLDivElement;
+            composerActionsRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+                onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+                onOpenPoll?: (() => any) | undefined;
+            }>, {
+                toggle: (event: Event) => void;
+                hide: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+                openPoll: () => any;
+            }, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                popoverRef: ({
+                    $props: import('primevue').PopoverProps & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $slots: import('primevue').PopoverSlots;
+                    $emit: ((e: "show") => void) & ((e: "hide") => void);
+                } & import('primevue').PopoverMethods) | null;
+            }, any, import('vue').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, import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+            onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+            onSendPoll?: ((input: import('../..').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, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        target: import('../../composables/useChatEventBus').ChatTarget;
+    }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+    }, {}, {}, {}, {}> | null;
+    threadComposerRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        target: import('../../composables/useChatEventBus').ChatTarget;
+    }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        composerRef: import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+            onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+            onSendPoll?: ((input: import('../..').PollComposerInput) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+            onSendText?: (() => any) | undefined;
+            onOpenScheduled?: (() => any) | undefined;
+            onCancelReply?: (() => any) | undefined;
+            onCancelEdit?: (() => any) | undefined;
+        }>, {
+            focusEditor: () => Promise<void>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            scheduleMessage: (input: import('../..').ScheduleMessageInput) => any;
+            sendAttachment: (input: import('../..').AttachmentUploadInput) => any;
+            sendPoll: (input: import('../..').PollComposerInput) => any;
+            "update:modelValue": (value: string) => any;
+            sendText: () => any;
+            openScheduled: () => any;
+            cancelReply: () => any;
+            cancelEdit: () => any;
+        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            fileInputRef: HTMLInputElement;
+            composerShellRef: HTMLDivElement;
+            composerEditorRef: HTMLDivElement;
+            composerActionsRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{
+                onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+                onOpenPoll?: (() => any) | undefined;
+            }>, {
+                toggle: (event: Event) => void;
+                hide: () => void;
+            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+                openPoll: () => any;
+            }, import('vue').PublicProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+                popoverRef: ({
+                    $props: import('primevue').PopoverProps & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+                    $slots: import('primevue').PopoverSlots;
+                    $emit: ((e: "show") => void) & ((e: "hide") => void);
+                } & import('primevue').PopoverMethods) | null;
+            }, any, import('vue').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, import('vue').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: import('../..').ScheduleMessageInput) => any) | undefined;
+            onSendAttachment?: ((input: import('../..').AttachmentUploadInput) => any) | undefined;
+            onSendPoll?: ((input: import('../..').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, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        target: import('../../composables/useChatEventBus').ChatTarget;
+    }> & Readonly<{}>, {
+        focusEditor: () => Promise<void>;
+    }, {}, {}, {}, {}> | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/chat/ChatStatusOverlay.vue.d.ts

@@ -0,0 +1,33 @@
+type __VLS_Props = {
+    visible: boolean;
+    offlineMode: boolean;
+    connected: boolean;
+    loading: boolean;
+    notFound: boolean;
+    isEmpty: boolean;
+    showEmptySlot: boolean;
+    messages: {
+        waitingForNetwork: string;
+        connecting: string;
+        loading: string;
+        notFound: string;
+        noMessages: string;
+    };
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'no-messages'?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/chat/publicContract.d.ts

@@ -0,0 +1,43 @@
+import { ChatClient, ChatConversationItem, ChatMessageItem, Language, MessageSendOptions, ParticipantInfo } from '../../chat/types';
+export interface BccChatPublicProps {
+    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;
+}
+export declare const bccChatPublicPropDefaults: {
+    client: null;
+    conversation: undefined;
+    messages: undefined;
+    threadMessages: undefined;
+    loadingMessages: undefined;
+    loadingThreadMessages: undefined;
+    isReadOnly: undefined;
+    sendOptions: undefined;
+    showDefaultEmptyState: undefined;
+    initialScheduledMessagesOpen: boolean;
+    chatUid: string;
+    senderDisplayName: undefined;
+    hideDeletedMessages: boolean;
+    groupMessageGetter: undefined;
+    loadMessageId: string;
+    displayNoMessagesText: boolean;
+    language: undefined;
+};
+export type BccChatPublicEmits = {
+    groupMembersFetched: [members: ParticipantInfo[]];
+    chatEmpty: [];
+};

package/dist/components/conversations/ConversationList.vue.d.ts

@@ -0,0 +1,15 @@
+import { ChatConversationItem } from '../../chat/types';
+type __VLS_Props = {
+    conversations: ChatConversationItem[];
+    activeConversationId: string | null;
+    loading: boolean;
+    query: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (conversationId: string) => any;
+    "update:query": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((conversationId: string) => any) | undefined;
+    "onUpdate:query"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+export default _default;

package/dist/components/conversations/UserProfileCard.vue.d.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    name: string;
+    subtitle?: string;
+    avatar?: string;
+    connected: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/messages/ActionMessageRow.vue.d.ts

@@ -0,0 +1,5 @@
+type __VLS_Props = {
+    text: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/messages/ComposerActionsPopover.vue.d.ts

@@ -0,0 +1,19 @@
+declare function toggle(event: Event): void;
+declare function hide(): void;
+declare const _default: import('vue').DefineComponent<{}, {
+    toggle: typeof toggle;
+    hide: typeof hide;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    pickFile: (kind: "image" | "video" | "audio" | "file") => any;
+    openPoll: () => any;
+}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{
+    onPickFile?: ((kind: "image" | "video" | "audio" | "file") => any) | undefined;
+    onOpenPoll?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    popoverRef: ({
+        $props: import('primevue').PopoverProps & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps;
+        $slots: import('primevue').PopoverSlots;
+        $emit: ((e: "show") => void) & ((e: "hide") => void);
+    } & import('primevue').PopoverMethods) | null;
+}, any>;
+export default _default;

package/dist/components/messages/ComposerContextBanner.vue.d.ts

@@ -0,0 +1,13 @@
+import { ChatMessageItem } from '../../chat/types';
+type __VLS_Props = {
+    message: ChatMessageItem;
+    /** "editing" shows an information-coloured banner; "replying" shows success-coloured */
+    variant: "editing" | "replying";
+    contextLabel?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    cancel: () => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onCancel?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;