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

package/dist/composables/chat/useComposerContext.d.ts

@@ -0,0 +1,43 @@
+import { ComputedRef, Ref, ShallowRef } from 'vue';
+import { AttachmentUploadInput, ChatClient, ChatMessageItem, MessageSendOptions, PollComposerInput, ScheduleMessageInput } from '../../chat/types';
+/** Minimal public interface exposed by a composer component via defineExpose. */
+export interface ComposerHandle {
+    focusEditor: () => Promise<void>;
+}
+export interface ComposerContext {
+    readonly draft: Ref<string>;
+    readonly threadDraft: Ref<string>;
+    readonly composerResetSignal: Ref<number>;
+    readonly threadComposerResetSignal: Ref<number>;
+    readonly mainComposerRef: ShallowRef<ComposerHandle | null>;
+    readonly threadComposerRef: ShallowRef<ComposerHandle | null>;
+    readonly messageBeingRepliedTo: ComputedRef<ChatMessageItem | null>;
+    readonly messageBeingEdited: ComputedRef<ChatMessageItem | null>;
+    readonly offlineMode: ComputedRef<boolean>;
+    readonly pendingQueueCount: ComputedRef<number>;
+    readonly isSendingMessage: ComputedRef<boolean>;
+    readonly isSchedulingMessage: ComputedRef<boolean>;
+    resetMainComposer(): void;
+    resetThreadComposer(): void;
+    focusMainComposer(): void;
+    focusThreadComposer(): void;
+    shouldFocusThreadComposer(message: ChatMessageItem): boolean;
+    loadMainDraft(message: ChatMessageItem): void;
+    loadThreadDraft(message: ChatMessageItem): void;
+    sendMessage(): Promise<void>;
+    sendAttachment(input: AttachmentUploadInput): Promise<void>;
+    sendPoll(input: PollComposerInput): Promise<void>;
+    scheduleMessage(input: ScheduleMessageInput): Promise<void>;
+    sendThreadMessage(): Promise<void>;
+    sendThreadAttachment(input: AttachmentUploadInput): Promise<void>;
+    sendThreadPoll(input: PollComposerInput): Promise<void>;
+}
+export interface CreateComposerContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    sendOptions: ComputedRef<MessageSendOptions | undefined>;
+    /** Called after a message has been scheduled. */
+    afterSchedule: () => Promise<void>;
+}
+export declare function createComposerContext(options: CreateComposerContextOptions): ComposerContext;
+export declare function provideComposerContext(ctx: ComposerContext): void;
+export declare function useComposerContext(): ComposerContext;

package/dist/composables/chat/useConversationContext.d.ts

@@ -0,0 +1,30 @@
+import { ComputedRef } from 'vue';
+import { ChatClient, ChatConversationItem, MessageSendOptions } from '../../chat/types';
+export interface ConversationContext {
+    /** The resolved ChatClient (from BccChat prop or global singleton). */
+    readonly client: ComputedRef<ChatClient | null>;
+    /** The currently active conversation. */
+    readonly conversation: ComputedRef<ChatConversationItem | null>;
+    /** UID of the authenticated user. */
+    readonly currentUserId: ComputedRef<string | undefined>;
+    readonly canUseMessageActions: ComputedRef<boolean>;
+    readonly canReact: ComputedRef<boolean>;
+    readonly canReply: ComputedRef<boolean>;
+    readonly canOpenThread: ComputedRef<boolean>;
+    readonly isReadOnly: ComputedRef<boolean>;
+    readonly isChannel: ComputedRef<boolean>;
+    readonly sendOptions: ComputedRef<MessageSendOptions | undefined>;
+}
+export interface CreateConversationContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    selectedConversation: ComputedRef<ChatConversationItem | null>;
+    /** Returns prop-supplied read-only flag, or undefined to auto-detect. */
+    getPropIsReadOnly: () => boolean | undefined;
+    /** Returns prop-supplied send options, or undefined to auto-detect. */
+    getPropSendOptions: () => MessageSendOptions | undefined;
+    /** Display name override for the sender. */
+    getSenderDisplayName: () => string | undefined;
+}
+export declare function createConversationContext(options: CreateConversationContextOptions): ConversationContext;
+export declare function provideConversationContext(ctx: ConversationContext): void;
+export declare function useConversationContext(): ConversationContext;

package/dist/composables/chat/useDialogsContext.d.ts

@@ -0,0 +1,27 @@
+import { ComputedRef, Ref } from 'vue';
+import { ChatClient, ChatConversationItem, ChatMessageItem, ChatMessageReceiptItem } from '../../chat/types';
+export interface DialogsContext {
+    readonly infoMessage: Ref<ChatMessageItem | null>;
+    readonly infoMessageReceipts: Ref<ChatMessageReceiptItem[]>;
+    readonly loadingMessageReceipts: Ref<boolean>;
+    readonly messageReceiptsError: Ref<string | null>;
+    openMessageInfo(message: ChatMessageItem): Promise<void>;
+    closeMessageInfo(): void;
+    readonly hasScheduledMessages: ComputedRef<boolean>;
+    readonly showScheduledMessages: Ref<boolean>;
+    readonly loadingScheduledMessages: ComputedRef<boolean>;
+    readonly scheduledMessages: ComputedRef<ChatMessageItem[]>;
+    openScheduledMessages(): Promise<void>;
+    refreshScheduledMessages(): Promise<void>;
+}
+export interface CreateDialogsContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    selectedConversation: ComputedRef<ChatConversationItem | null>;
+    /** Whether the initial scheduled-messages dialog should be open. */
+    getInitialScheduledMessagesOpen: () => boolean;
+    /** Fallback error string shown when receipt fetch fails. */
+    fetchErrorFallback: string;
+}
+export declare function createDialogsContext(options: CreateDialogsContextOptions): DialogsContext;
+export declare function provideDialogsContext(ctx: DialogsContext): void;
+export declare function useDialogsContext(): DialogsContext;

package/dist/composables/chat/useMessagesContext.d.ts

@@ -0,0 +1,36 @@
+import { ComputedRef, Ref } from 'vue';
+import { ChatClient, ChatConversationItem, ChatMessageItem } from '../../chat/types';
+export interface MessagesContext {
+    readonly messages: ComputedRef<ChatMessageItem[]>;
+    readonly loadingMessages: ComputedRef<boolean>;
+    readonly hasOlderMessages: ComputedRef<boolean>;
+    readonly loadingOlderMessages: ComputedRef<boolean>;
+    readonly threadMessages: ComputedRef<ChatMessageItem[]>;
+    readonly loadingThreadMessages: ComputedRef<boolean>;
+    readonly activeThreadParentMessage: ComputedRef<ChatMessageItem | null>;
+    readonly hasOlderThreadMessages: ComputedRef<boolean>;
+    readonly loadingOlderThreadMessages: ComputedRef<boolean>;
+    readonly showDefaultEmptyState: ComputedRef<boolean>;
+    readonly isChatEmpty: ComputedRef<boolean>;
+}
+export interface CreateMessagesContextOptions {
+    chatClient: ComputedRef<ChatClient | null>;
+    selectedConversation: ComputedRef<ChatConversationItem | null>;
+    usesPublicContract: ComputedRef<boolean>;
+    loadingChat: Ref<boolean>;
+    /** Returns prop-supplied messages, or undefined to fall back to client. */
+    getPropMessages: () => ChatMessageItem[] | undefined;
+    /** Returns prop-supplied thread messages, or undefined to fall back. */
+    getPropThreadMessages: () => ChatMessageItem[] | undefined;
+    /** Returns prop-supplied loading flag, or undefined to fall back. */
+    getPropLoadingMessages: () => boolean | undefined;
+    /** Returns prop-supplied thread loading flag, or undefined to fall back. */
+    getPropLoadingThreadMessages: () => boolean | undefined;
+    /** Returns prop-supplied empty-state flag, or undefined for auto. */
+    getPropShowDefaultEmptyState: () => boolean | undefined;
+    /** Whether to filter out deleted messages. */
+    getHideDeletedMessages: () => boolean;
+}
+export declare function createMessagesContext(options: CreateMessagesContextOptions): MessagesContext;
+export declare function provideMessagesContext(ctx: MessagesContext): void;
+export declare function useMessagesContext(): MessagesContext;

package/dist/composables/useChatActions.d.ts

@@ -0,0 +1,21 @@
+import { ConversationContext } from './chat/useConversationContext';
+import { ComposerContext } from './chat/useComposerContext';
+import { DialogsContext } from './chat/useDialogsContext';
+import { ChatEventBus } from './useChatEventBus';
+export interface UseChatActionsOptions {
+    /** Conversation identity and permissions. */
+    conversation: ConversationContext;
+    /** Composer draft/send state. */
+    composer: ComposerContext;
+    /** Dialog overlay state. */
+    dialogs: DialogsContext;
+    /** The event bus to subscribe to. */
+    bus: ChatEventBus;
+}
+/**
+ * Subscribes to all bus events and wires them to the appropriate business
+ * logic. Returns a teardown function (also registered via `onUnmounted`).
+ */
+export declare function useChatActions({ conversation, composer, dialogs, bus, }: UseChatActionsOptions): {
+    teardown: () => void;
+};

package/dist/composables/useChatEventBus.d.ts

@@ -0,0 +1,91 @@
+import { ChatMessageItem, AttachmentUploadInput, PollComposerInput, ScheduleMessageInput } from '../chat/types';
+/** Target identifier used to distinguish main-conversation from thread actions. */
+export type ChatTarget = "main" | "thread";
+/** All events that can flow through the chat event bus. */
+export interface ChatBusEventMap {
+    /** User wants to reply to a message. */
+    "message:reply": ChatMessageItem;
+    /** User wants to edit a message. */
+    "message:edit": ChatMessageItem;
+    /** User wants to delete a message. */
+    "message:delete": ChatMessageItem;
+    /** User wants to view message delivery info. */
+    "message:info": ChatMessageItem;
+    /** User wants to open a thread for a message. */
+    "message:openThread": ChatMessageItem;
+    /** User wants to toggle a reaction on a message. */
+    "message:toggleReaction": {
+        message: ChatMessageItem;
+        emoji: string;
+    };
+    /** User wants to translate a message. */
+    "message:translate": ChatMessageItem;
+    /** User wants to vote on a poll option. */
+    "message:votePoll": {
+        message: ChatMessageItem;
+        optionId: string;
+    };
+    /** User wants to navigate to a referenced message. */
+    "message:openReference": string;
+    /** User pressed send (text or attachment). */
+    "composer:send": {
+        target: ChatTarget;
+    };
+    /** User attached a file and pressed send. */
+    "composer:sendAttachment": {
+        target: ChatTarget;
+        input: AttachmentUploadInput;
+    };
+    /** User composed and submitted a poll. */
+    "composer:sendPoll": {
+        target: ChatTarget;
+        input: PollComposerInput;
+    };
+    /** User scheduled a message. */
+    "composer:schedule": {
+        target: ChatTarget;
+        input: ScheduleMessageInput;
+    };
+    /** User cancelled a reply. */
+    "composer:cancelReply": undefined;
+    /** User cancelled an edit. */
+    "composer:cancelEdit": undefined;
+    /** User requested older messages. */
+    "list:loadOlder": {
+        target: ChatTarget;
+    };
+    /** Open the scheduled-messages dialog. */
+    "ui:openScheduled": undefined;
+    /** Close the thread dialog. */
+    "ui:closeThread": undefined;
+    /** Reschedule a scheduled message. */
+    "ui:reschedule": {
+        messageId: number;
+        muid: string;
+        originalChatUid: string;
+        scheduleDate: string;
+    };
+}
+/** Handler type that correctly handles both void and payload events. */
+type EventHandler<T> = T extends undefined ? () => void : (payload: T) => void;
+/** A typed event bus instance. */
+export interface ChatEventBus {
+    /** Emit an event with an optional payload. */
+    emit<K extends keyof ChatBusEventMap>(event: K, ...args: ChatBusEventMap[K] extends undefined ? [] : [ChatBusEventMap[K]]): void;
+    /** Subscribe to an event. Returns an unsubscribe function. */
+    on<K extends keyof ChatBusEventMap>(event: K, handler: EventHandler<ChatBusEventMap[K]>): () => void;
+    /** Unsubscribe from an event. */
+    off<K extends keyof ChatBusEventMap>(event: K, handler: EventHandler<ChatBusEventMap[K]>): void;
+}
+/** Creates a new ChatEventBus instance. Called once by BccChat. */
+export declare function createChatEventBus(): ChatEventBus;
+/** Provides the event bus to descendant components. */
+export declare function provideChatEventBus(bus: ChatEventBus): void;
+/** Injects the event bus from an ancestor BccChat component. */
+export declare function useChatBus(): ChatEventBus;
+/**
+ * Convenience helper: subscribes to a bus event and auto-unsubscribes when the
+ * calling component is unmounted.
+ */
+export declare function useBusListener<K extends keyof ChatBusEventMap>(bus: ChatEventBus, event: K, handler: EventHandler<ChatBusEventMap[K]>): void;
+export {};

package/dist/composables/useComposerDrafts.d.ts

@@ -0,0 +1,44 @@
+import { AttachmentUploadInput, ChatClient, ChatMessageItem, MessageSendOptions, PollComposerInput, ScheduleMessageInput } from '../chat/types';
+/** Minimal public interface exposed by MessageComposer via `defineExpose`. */
+interface ComposerHandle {
+    focusEditor: () => Promise<void>;
+}
+export interface UseComposerDraftsOptions {
+    /** Returns the active chat client, or null when unavailable. */
+    getClient: () => ChatClient | null;
+    /** Returns the resolved send options for the current conversation. */
+    getSendOptions: () => MessageSendOptions | undefined;
+    /**
+     * Called after a message has been scheduled so the parent can refresh the
+     * scheduled-messages overlay.
+     */
+    afterSchedule: () => Promise<void>;
+}
+/**
+ * Composable that owns all state for the main + thread dual-composer drafts, including
+ * draft text, reset signals, focus helpers, and delegated send actions.
+ */
+export declare function useComposerDrafts(options: UseComposerDraftsOptions): {
+    draft: import('vue').Ref<string, string>;
+    threadDraft: import('vue').Ref<string, string>;
+    composerResetSignal: import('vue').Ref<number, number>;
+    threadComposerResetSignal: import('vue').Ref<number, number>;
+    mainComposerRef: import('vue').ShallowRef<ComposerHandle | null, ComposerHandle | null>;
+    threadComposerRef: import('vue').ShallowRef<ComposerHandle | null, ComposerHandle | null>;
+    resetMainComposer: () => void;
+    resetThreadComposer: () => void;
+    focusMainComposer: () => void;
+    focusThreadComposer: () => void;
+    shouldFocusThreadComposer: (message: ChatMessageItem) => boolean;
+    getEditableMessageText: (message: ChatMessageItem) => string;
+    loadMainDraft: (message: ChatMessageItem) => void;
+    loadThreadDraft: (message: ChatMessageItem) => void;
+    sendMessage: () => Promise<void>;
+    sendAttachment: (input: AttachmentUploadInput) => Promise<void>;
+    sendPoll: (input: PollComposerInput) => Promise<void>;
+    scheduleMessage: (input: ScheduleMessageInput) => Promise<void>;
+    sendThreadMessage: () => Promise<void>;
+    sendThreadAttachment: (input: AttachmentUploadInput) => Promise<void>;
+    sendThreadPoll: (input: PollComposerInput) => Promise<void>;
+};
+export {};

package/dist/composables/useConversationComposer.d.ts

@@ -0,0 +1,15 @@
+import { AttachmentUploadInput, ChatClient, ChatMessageItem, MessageSendOptions, PollComposerInput, ScheduleMessageInput } from '../chat/types';
+export declare function useConversationComposer(options: {
+    client: ChatClient;
+    getSendOptions: () => MessageSendOptions | undefined;
+    afterSchedule?: () => Promise<void> | void;
+}): {
+    draft: import('vue').Ref<string, string>;
+    loadMessageDraft: (message: ChatMessageItem) => void;
+    reset: () => void;
+    resetSignal: import('vue').Ref<number, number>;
+    scheduleMessage: (input: ScheduleMessageInput) => Promise<void>;
+    sendAttachment: (input: AttachmentUploadInput) => Promise<void>;
+    sendPoll: (input: PollComposerInput) => Promise<void>;
+    sendText: () => Promise<void>;
+};

package/dist/composables/useGroupMemberTracking.d.ts

@@ -0,0 +1,28 @@
+import { ParticipantInfo } from '../chat/types';
+export interface UseGroupMemberTrackingOptions {
+    /** Returns the CometChat GUID of the currently active conversation, or undefined when none is selected. */
+    getConversationTargetId: () => string | undefined;
+    /** Returns true when the active conversation is a broadcast channel (members are not tracked). */
+    isChannel: () => boolean;
+    /** Called whenever the member list changes with the new complete list. */
+    onMembersChanged: (members: ParticipantInfo[]) => void;
+}
+/**
+ * Composable that keeps a live `groupMembers` ref in sync with CometChat
+ * membership events and exposes a manual `fetchGroupMembers` loader for the
+ * initial page-load.
+ */
+export declare function useGroupMemberTracking(options: UseGroupMemberTrackingOptions): {
+    groupMembers: import('vue').Ref<{
+        uid: string;
+        displayName: string;
+        avatar: string;
+        role: string;
+    }[], ParticipantInfo[] | {
+        uid: string;
+        displayName: string;
+        avatar: string;
+        role: string;
+    }[]>;
+    fetchGroupMembers: (groupUid: string) => Promise<void>;
+};

package/dist/composables/useImageZoom.d.ts

@@ -0,0 +1,26 @@
+import { Ref } from 'vue';
+export interface UseImageZoomOptions {
+    /** Ref to the scrollable viewport wrapper element. */
+    viewportRef: Ref<HTMLElement | null>;
+    /** Ref to the `<img>` element whose natural dimensions guide clamping. */
+    imageRef: Ref<HTMLImageElement | null>;
+    /** Returns true when the current attachment is an image (non-image = zoom disabled). */
+    isImage: () => boolean;
+}
+/**
+ * Composable that owns scale, translateX, and translateY state and exposes
+ * all pointer event handlers required by the media-viewer image stage.
+ */
+export declare function useImageZoom(options: UseImageZoomOptions): {
+    scale: Ref<number, number>;
+    translateX: Ref<number, number>;
+    translateY: Ref<number, number>;
+    isDragging: Ref<boolean, boolean>;
+    resetTransform: () => void;
+    handlePointerDown: (event: PointerEvent) => void;
+    handlePointerMove: (event: PointerEvent) => void;
+    handlePointerUp: (event: PointerEvent) => void;
+    handlePointerCancel: (event: PointerEvent) => void;
+    handleWheel: (event: WheelEvent) => void;
+    handleDoubleClick: () => void;
+};

package/dist/composables/useMessageActionMenu.d.ts

@@ -0,0 +1,202 @@
+import { ChatMessageItem } from '../chat/types';
+import { TranslationKey } from '../chat/localization';
+import { TranslationParams } from '../chat/i18n/types';
+/** Minimal public interface of the custom MessageItemMenu component. */
+interface ActionMenuHandle {
+    show: (event: Event) => void;
+    hide: () => void;
+}
+export interface UseMessageActionMenuOptions {
+    /** Returns true when message actions are enabled for this view. */
+    canUseMessageActions: () => boolean;
+    /** Returns true when reactions are allowed. */
+    canReact: () => boolean;
+    /** Returns true when replying is allowed. */
+    canReply: () => boolean;
+    /** Returns true when opening a thread is allowed. */
+    canOpenThread: () => boolean;
+    /** Returns true when the list is rendering a thread view (disables thread action). */
+    isInThread: () => boolean;
+    /** Translation helper forwarded from the parent component. */
+    t: (key: TranslationKey, params?: TranslationParams) => string;
+    /** Called to signal a disable-auto-scroll intent (prevents jarring jumps). */
+    disableAutoScroll: () => void;
+    emit: {
+        reply: (message: ChatMessageItem) => void;
+        edit: (message: ChatMessageItem) => void;
+        info: (message: ChatMessageItem) => void;
+        openThread: (message: ChatMessageItem) => void;
+        delete: (message: ChatMessageItem) => void;
+        translate: (message: ChatMessageItem) => void;
+        toggleReaction: (message: ChatMessageItem, emoji: string) => void;
+    };
+}
+/**
+ * Composable that owns all state for the per-message action popover, reaction
+ * expansion, inline reaction toggles, and message copying.
+ */
+export declare function useMessageActionMenu(options: UseMessageActionMenuOptions): {
+    actionMenuRef: import('vue').Ref<{
+        show: (event: Event) => void;
+        hide: () => void;
+    } | null, ActionMenuHandle | {
+        show: (event: Event) => void;
+        hide: () => void;
+    } | null>;
+    actionMenuAnchorRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    activeActionMessage: import('vue').Ref<{
+        id: string;
+        muid?: string | undefined;
+        conversationId: string;
+        senderId: string;
+        senderName: string;
+        text: string;
+        kind: import('..').ChatMessageKind;
+        sentAt: Date;
+        category: string;
+        type: string;
+        senderAvatar?: string | undefined;
+        isOwn: boolean;
+        isDeleted: boolean;
+        isEdited: boolean;
+        attachments: {
+            kind: Extract<import('..').ChatMessageKind, "image" | "video" | "audio" | "file">;
+            name: string;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+            extension?: string | undefined;
+            size?: number | undefined;
+        }[];
+        poll?: {
+            id?: string | undefined;
+            question: string;
+            options: {
+                id: string;
+                text: string;
+                voteCount: number;
+                voters: string[];
+            }[];
+            totalVotes: number;
+            allowsMultipleAnswers: boolean;
+        } | undefined;
+        scheduled?: {
+            scheduleDate?: Date | undefined;
+            originalChatUid?: string | undefined;
+            muid?: string | undefined;
+            messageId?: number | undefined;
+        } | undefined;
+        translatedText?: string | undefined;
+        replyTo?: {
+            messageId: string;
+            senderName: string;
+            text: string;
+            kind: import('..').ChatMessageKind;
+        } | undefined;
+        parentMessageId?: string | undefined;
+        replyCount: number;
+        reactions: {
+            emoji: string;
+            count: number;
+            reactedByMe: boolean;
+        }[];
+        receipts: {
+            deliveredAt?: Date | undefined;
+            deliveredToMeAt?: Date | undefined;
+            readAt?: Date | undefined;
+            readByMeAt?: Date | undefined;
+        };
+        deliveryState: import('..').ChatDeliveryState;
+        metadata?: Record<string, unknown> | undefined;
+        source: any;
+    } | null, ChatMessageItem | {
+        id: string;
+        muid?: string | undefined;
+        conversationId: string;
+        senderId: string;
+        senderName: string;
+        text: string;
+        kind: import('..').ChatMessageKind;
+        sentAt: Date;
+        category: string;
+        type: string;
+        senderAvatar?: string | undefined;
+        isOwn: boolean;
+        isDeleted: boolean;
+        isEdited: boolean;
+        attachments: {
+            kind: Extract<import('..').ChatMessageKind, "image" | "video" | "audio" | "file">;
+            name: string;
+            url?: string | undefined;
+            mimeType?: string | undefined;
+            extension?: string | undefined;
+            size?: number | undefined;
+        }[];
+        poll?: {
+            id?: string | undefined;
+            question: string;
+            options: {
+                id: string;
+                text: string;
+                voteCount: number;
+                voters: string[];
+            }[];
+            totalVotes: number;
+            allowsMultipleAnswers: boolean;
+        } | undefined;
+        scheduled?: {
+            scheduleDate?: Date | undefined;
+            originalChatUid?: string | undefined;
+            muid?: string | undefined;
+            messageId?: number | undefined;
+        } | undefined;
+        translatedText?: string | undefined;
+        replyTo?: {
+            messageId: string;
+            senderName: string;
+            text: string;
+            kind: import('..').ChatMessageKind;
+        } | undefined;
+        parentMessageId?: string | undefined;
+        replyCount: number;
+        reactions: {
+            emoji: string;
+            count: number;
+            reactedByMe: boolean;
+        }[];
+        receipts: {
+            deliveredAt?: Date | undefined;
+            deliveredToMeAt?: Date | undefined;
+            readAt?: Date | undefined;
+            readByMeAt?: Date | undefined;
+        };
+        deliveryState: import('..').ChatDeliveryState;
+        metadata?: Record<string, unknown> | undefined;
+        source: any;
+    } | null>;
+    copiedMessageId: import('vue').Ref<string | null, string | null>;
+    actionMenuPointer: import('vue').Ref<{
+        x: number;
+        y: number;
+    }, {
+        x: number;
+        y: number;
+    } | {
+        x: number;
+        y: number;
+    }>;
+    supportsDesktopContextMenu: boolean;
+    handleMessageContextMenu: (message: ChatMessageItem, event: MouseEvent) => void;
+    handleMessageTap: (message: ChatMessageItem, event: MouseEvent) => void;
+    closeActionMenu: () => void;
+    resetActionMenuState: () => void;
+    reactToMessage: (message: ChatMessageItem, emoji: string) => void;
+    toggleInlineReaction: (message: ChatMessageItem, emoji: string) => void;
+    getActionItems: (message: ChatMessageItem) => {
+        key: string;
+        label: string;
+        icon: string;
+        visible: boolean;
+        action: () => void;
+    }[];
+};
+export {};