import { AllowedComponentProps } from 'vue';
import { App } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { DefineComponent } from 'vue';
import { MaybeRefOrGetter } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { ShallowUnwrapRef } from 'vue';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';

declare const __VLS_component: DefineComponent<AudioPlayerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"hover-audio-progress": (hovering: boolean) => any;
"update-progress-time": (value: string) => any;
}, string, PublicProps, Readonly<AudioPlayerProps> & Readonly<{
"onHover-audio-progress"?: ((hovering: boolean) => any) | undefined;
"onUpdate-progress-time"?: ((value: string) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
player: HTMLAudioElement;
}, HTMLDivElement>;

declare const __VLS_component_10: DefineComponent<LayoutProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<LayoutProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_11: DefineComponent<MediaPreviewProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"close-media-preview": () => any;
}, string, PublicProps, Readonly<MediaPreviewProps> & Readonly<{
"onClose-media-preview"?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
modal: HTMLDivElement;
}, any>;

declare const __VLS_component_12: DefineComponent<MessageProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"click-user-tag": (user: User) => any;
"message-action-handler": (payload: {
action: Action;
message: MessageModel;
}) => any;
"send-message-reaction": (payload: {
emoji: string;
message: MessageModel;
}) => any;
"open-file": (payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any;
"select-message": (message: MessageModel) => any;
"open-failed-message": (message: MessageModel) => any;
}, string, PublicProps, Readonly<MessageProps> & Readonly<{
"onClick-user-tag"?: ((user: User) => any) | undefined;
"onMessage-action-handler"?: ((payload: {
action: Action;
message: MessageModel;
}) => any) | undefined;
"onSend-message-reaction"?: ((payload: {
emoji: string;
message: MessageModel;
}) => any) | undefined;
"onOpen-file"?: ((payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any) | undefined;
"onSelect-message"?: ((message: MessageModel) => any) | undefined;
"onOpen-failed-message"?: ((message: MessageModel) => any) | undefined;
}>, {
users: User[];
messageSelectionEnabled: boolean;
textFormatting: Partial<TextFormattingOptions>;
actions: Action[];
showReactionEmojis: boolean;
selected: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_13: DefineComponent<MessageActionsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"message-action-handler": (payload: {
action: Action;
message: MessageModel;
}) => any;
"send-message-reaction": (payload: {
emoji: string;
message: MessageModel;
}) => any;
}, string, PublicProps, Readonly<MessageActionsProps> & Readonly<{
"onMessage-action-handler"?: ((payload: {
action: Action;
message: MessageModel;
}) => any) | undefined;
"onSend-message-reaction"?: ((payload: {
emoji: string;
message: MessageModel;
}) => any) | undefined;
}>, {
actions: Action[];
showReactionEmojis: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
reactionTrigger: HTMLButtonElement;
reactionMenu: HTMLDivElement;
optionsTrigger: HTMLButtonElement;
optionsMenu: HTMLDivElement;
}, any>;

declare const __VLS_component_14: DefineComponent<MessageFileProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"open-file": (payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any;
}, string, PublicProps, Readonly<MessageFileProps> & Readonly<{
"onOpen-file"?: ((payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any) | undefined;
}>, {
messageSelectionEnabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
imageRef: HTMLDivElement;
}, HTMLDivElement>;

declare const __VLS_component_15: DefineComponent<MessageFilesProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"click-user-tag": (user: User) => any;
"open-file": (payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any;
}, string, PublicProps, Readonly<MessageFilesProps> & Readonly<{
"onClick-user-tag"?: ((user: User) => any) | undefined;
"onOpen-file"?: ((payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any) | undefined;
}>, {
textFormatting: Partial<TextFormattingOptions>;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_16: DefineComponent<MessageReplyProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<MessageReplyProps> & Readonly<{}>, {
textFormatting: Partial<TextFormattingOptions>;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_2: DefineComponent<ChatProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"click-user-tag": (user: User) => any;
"send-message": (payload: {
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
reply?: MessageModel | null;
}) => any;
"edit-message": (payload: {
messageId: MessageModel["id"];
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
}) => any;
"typing-message": (value: string) => any;
"invalid-file": (payload: {
file: File;
reason: "size" | "count";
}) => any;
"toggle-chat-list": () => any;
"show-chat-info": () => any;
"menu-action-handler": (payload: {
chat: ChatModel;
action: Action;
}) => any;
"cancel-message-selection": () => any;
"message-selection-action-handler": (payload: {
chat: ChatModel;
action: Action;
messages: MessageModel[];
}) => any;
"message-action-handler": (payload: {
action: Action;
message: MessageModel;
}) => any;
"send-message-reaction": (payload: {
emoji: string;
message: MessageModel;
}) => any;
"open-file": (payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any;
"open-failed-message": (message: MessageModel) => any;
"fetch-messages": () => any;
}, string, PublicProps, Readonly<ChatProps> & Readonly<{
"onClick-user-tag"?: ((user: User) => any) | undefined;
"onSend-message"?: ((payload: {
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
reply?: MessageModel | null;
}) => any) | undefined;
"onEdit-message"?: ((payload: {
messageId: MessageModel["id"];
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
}) => any) | undefined;
"onTyping-message"?: ((value: string) => any) | undefined;
"onInvalid-file"?: ((payload: {
file: File;
reason: "size" | "count";
}) => any) | undefined;
"onToggle-chat-list"?: (() => any) | undefined;
"onShow-chat-info"?: (() => any) | undefined;
"onMenu-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
}) => any) | undefined;
"onCancel-message-selection"?: (() => any) | undefined;
"onMessage-selection-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
messages: MessageModel[];
}) => any) | undefined;
"onMessage-action-handler"?: ((payload: {
action: Action;
message: MessageModel;
}) => any) | undefined;
"onSend-message-reaction"?: ((payload: {
emoji: string;
message: MessageModel;
}) => any) | undefined;
"onOpen-file"?: ((payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any) | undefined;
"onOpen-failed-message"?: ((message: MessageModel) => any) | undefined;
"onFetch-messages"?: (() => any) | undefined;
}>, {
chat: ChatModel | null;
textFormatting: Partial<TextFormattingOptions>;
showSendIcon: boolean;
showFiles: boolean;
showEmojis: boolean;
showFooter: boolean;
accept: string;
multiple: boolean;
capture: "" | "user" | "environment";
maxFiles: number;
maxFileSize: number;
currentUser: UserReference | null;
standalone: boolean;
showChatList: boolean;
isMobile: boolean;
chatInfoEnabled: boolean;
selectionActions: Action[];
showReactionEmojis: boolean;
messages: MessageModel[];
showNewMessagesDivider: boolean;
loadingMessages: boolean;
messagesLoaded: boolean;
headerActions: Action[];
messageActions: Action[];
composerDisabled: boolean;
typingIndicatorPosition: "header" | "composer" | "both" | "none";
autoScroll: {
onMount?: boolean;
onChatSwitch?: boolean;
onSend?: boolean;
onReceive?: boolean;
};
}, {}, {}, {}, string, ComponentProvideOptions, false, {
scrollContainer: HTMLDivElement;
}, HTMLDivElement>;

declare const __VLS_component_3: DefineComponent<ChatFileProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"remove-file": (index: number) => any;
}, string, PublicProps, Readonly<ChatFileProps> & Readonly<{
"onRemove-file"?: ((index: number) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_4: DefineComponent<ChatFilesProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"remove-file": (index: number) => any;
"reset-message": () => any;
}, string, PublicProps, Readonly<ChatFilesProps> & Readonly<{
"onRemove-file"?: ((index: number) => any) | undefined;
"onReset-message"?: (() => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_5: DefineComponent<ChatFooterProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"send-message": (payload: {
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
reply?: MessageModel | null;
}) => any;
"edit-message": (payload: {
messageId: MessageModel["id"];
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
}) => any;
"update-edited-message-id": (value: string | null) => any;
"typing-message": (value: string) => any;
"reset-reply-message": () => any;
"reset-edit-message": () => any;
"focus-textarea": () => any;
"blur-textarea": () => any;
"invalid-file": (payload: {
file: File;
reason: InvalidFileReason;
}) => any;
}, string, PublicProps, Readonly<ChatFooterProps> & Readonly<{
"onSend-message"?: ((payload: {
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
reply?: MessageModel | null;
}) => any) | undefined;
"onEdit-message"?: ((payload: {
messageId: MessageModel["id"];
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
}) => any) | undefined;
"onUpdate-edited-message-id"?: ((value: string | null) => any) | undefined;
"onTyping-message"?: ((value: string) => any) | undefined;
"onReset-reply-message"?: (() => any) | undefined;
"onReset-edit-message"?: (() => any) | undefined;
"onFocus-textarea"?: (() => any) | undefined;
"onBlur-textarea"?: (() => any) | undefined;
"onInvalid-file"?: ((payload: {
file: File;
reason: InvalidFileReason;
}) => any) | undefined;
}>, {
users: User[];
disabled: boolean;
roomMessage: string;
showSendIcon: boolean;
showFiles: boolean;
showEmojis: boolean;
showFooter: boolean;
initReplyMessage: MessageModel | null;
initEditMessage: MessageModel | null;
accept: string;
multiple: boolean;
capture: "" | "user" | "environment";
maxFiles: number;
maxFileSize: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
fileInput: HTMLInputElement;
}, any>;

declare const __VLS_component_6: DefineComponent<ChatHeaderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"toggle-chat-list": () => any;
"show-chat-info": () => any;
"menu-action-handler": (payload: {
chat: ChatModel;
action: Action;
}) => any;
"cancel-message-selection": () => any;
"message-selection-action-handler": (payload: {
chat: ChatModel;
action: Action;
}) => any;
}, string, PublicProps, Readonly<ChatHeaderProps> & Readonly<{
"onToggle-chat-list"?: (() => any) | undefined;
"onShow-chat-info"?: (() => any) | undefined;
"onMenu-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
}) => any) | undefined;
"onCancel-message-selection"?: (() => any) | undefined;
"onMessage-selection-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
}) => any) | undefined;
}>, {
standalone: boolean;
showChatList: boolean;
isMobile: boolean;
chatInfoEnabled: boolean;
actions: Array<Action>;
selectionActions: Array<Action>;
selectedCount: number;
showTypingIndicator: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_7: DefineComponent<ChatsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"search-chat": (query: string) => any;
"add-chat": () => any;
"chat-action-handler": (payload: {
chat: ChatModel;
action: Action;
}) => any;
"fetch-more-chats": () => any;
"open-chat": (chat: ChatModel) => any;
"loading-more-chats": (isLoading: boolean) => any;
}, string, PublicProps, Readonly<ChatsProps> & Readonly<{
"onSearch-chat"?: ((query: string) => any) | undefined;
"onAdd-chat"?: (() => any) | undefined;
"onChat-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
}) => any) | undefined;
"onFetch-more-chats"?: (() => any) | undefined;
"onOpen-chat"?: ((chat: ChatModel) => any) | undefined;
"onLoading-more-chats"?: ((isLoading: boolean) => any) | undefined;
}>, {
isMobile: boolean;
showSearch: boolean;
showAddChat: boolean;
loadingChats: boolean;
chats: Array<ChatModel>;
showChats: boolean;
chatsLoaded: boolean;
minimumVisibleChats: number;
chatActions: Array<Action>;
customSearchEnabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
scrollRootEl: HTMLDivElement;
sentinelEl: HTMLDivElement;
}, any>;

declare const __VLS_component_8: DefineComponent<ChatsItemProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"chat-action-handler": (payload: {
chat: ChatModel;
action: Action;
}) => any;
}, string, PublicProps, Readonly<ChatsItemProps> & Readonly<{
"onChat-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_9: DefineComponent<ChatsSearchProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"search-chat": (query: string) => any;
"add-chat": () => any;
}, string, PublicProps, Readonly<ChatsSearchProps> & Readonly<{
"onSearch-chat"?: ((query: string) => any) | undefined;
"onAdd-chat"?: (() => any) | undefined;
}>, {
showSearch: boolean;
showAddChat: boolean;
loadingChats: boolean;
chats: Array<ChatModel>;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare type __VLS_PrettifyLocal<T> = {
    [K in keyof T]: T[K];
} & {};

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>>;
    refs: {
        player: HTMLAudioElement;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_10(): {
    attrs: Partial<{}>;
    slots: {
        default?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_11(): {
    attrs: Partial<{}>;
    slots: {
        'preview-close-icon'?(_: {}): any;
    };
    refs: {
        modal: HTMLDivElement;
    };
    rootEl: any;
};

declare function __VLS_template_12(): {
    attrs: Partial<{}>;
    slots: Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>>;
    refs: {};
    rootEl: any;
};

declare function __VLS_template_13(): {
    attrs: Partial<{}>;
    slots: Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>>;
    refs: {
        reactionTrigger: HTMLButtonElement;
        reactionMenu: HTMLDivElement;
        optionsTrigger: HTMLButtonElement;
        optionsMenu: HTMLDivElement;
    };
    rootEl: any;
};

declare function __VLS_template_14(): {
    attrs: Partial<{}>;
    slots: Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>>;
    refs: {
        imageRef: HTMLDivElement;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_15(): {
    attrs: Partial<{}>;
    slots: {
        'document-icon'?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_16(): {
    attrs: Partial<{}>;
    slots: {
        'file-icon'?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_2(): {
    attrs: Partial<{}>;
    slots: {
        'no-chat-selected'?(_: {}): any;
        'scroll-icon'?(_: {}): any;
        'composer-typing'?(_: {
            typingUsers: string;
        }): any;
    };
    refs: {
        scrollContainer: HTMLDivElement;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_3(): {
    attrs: Partial<{}>;
    slots: {
        'image-close-icon'?(_: {}): any;
        'file-icon'?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_4(): {
    attrs: Partial<{}>;
    slots: {
        'files-close-icon'?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_5(): {
    attrs: Partial<{}>;
    slots: {
        'reply-close-icon'?(_: {}): any;
        'edit-close-icon'?(_: {}): any;
        'emoji-picker-icon'?(_: {}): any;
        'paperclip-icon'?(_: {}): any;
        'send-icon'?(_: {}): any;
    };
    refs: {
        fileInput: HTMLInputElement;
    };
    rootEl: any;
};

declare function __VLS_template_6(): {
    attrs: Partial<{}>;
    slots: {
        'chat-header'?(_: {}): any;
        'toggle-icon'?(_: {}): any;
        'chat-header-avatar'?(_: {}): any;
        'chat-header-info'?(_: {}): any;
        'chat-options'?(_: {}): any;
        'menu-icon'?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_7(): {
    attrs: Partial<{}>;
    slots: {
        'chats-header'?(_: {}): any;
        'chats-search'?(_: {}): any;
        'chats-empty'?(_: {}): any;
    };
    refs: {
        scrollRootEl: HTMLDivElement;
        sentinelEl: HTMLDivElement;
    };
    rootEl: any;
};

declare function __VLS_template_8(): {
    attrs: Partial<{}>;
    slots: Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>> & Partial<Record<string, (_: {}) => any>>;
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_9(): {
    attrs: Partial<{}>;
    slots: {
        'search-icon'?(_: {}): any;
        'add-icon'?(_: {}): any;
    };
    refs: {};
    rootEl: HTMLDivElement;
};

declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;

declare type __VLS_TemplateResult_10 = ReturnType<typeof __VLS_template_10>;

declare type __VLS_TemplateResult_11 = ReturnType<typeof __VLS_template_11>;

declare type __VLS_TemplateResult_12 = ReturnType<typeof __VLS_template_12>;

declare type __VLS_TemplateResult_13 = ReturnType<typeof __VLS_template_13>;

declare type __VLS_TemplateResult_14 = ReturnType<typeof __VLS_template_14>;

declare type __VLS_TemplateResult_15 = ReturnType<typeof __VLS_template_15>;

declare type __VLS_TemplateResult_16 = ReturnType<typeof __VLS_template_16>;

declare type __VLS_TemplateResult_2 = ReturnType<typeof __VLS_template_2>;

declare type __VLS_TemplateResult_3 = ReturnType<typeof __VLS_template_3>;

declare type __VLS_TemplateResult_4 = ReturnType<typeof __VLS_template_4>;

declare type __VLS_TemplateResult_5 = ReturnType<typeof __VLS_template_5>;

declare type __VLS_TemplateResult_6 = ReturnType<typeof __VLS_template_6>;

declare type __VLS_TemplateResult_7 = ReturnType<typeof __VLS_template_7>;

declare type __VLS_TemplateResult_8 = ReturnType<typeof __VLS_template_8>;

declare type __VLS_TemplateResult_9 = ReturnType<typeof __VLS_template_9>;

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_10<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_11<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_12<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_13<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_14<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_15<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_16<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_5<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_6<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_7<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_8<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_9<T, S> = T & {
    new (): {
        $slots: S;
    };
};

/**
 * A user-triggerable action surfaced through one of the dropdown menus
 * (header, message, chat row, or message-selection toolbar). Identified
 * by `id` for routing in the consumer's `*-action-handler`; rendered
 * with `label`.
 */
export declare interface Action {
    id: string;
    label: string;
    /**
     * Optional leading icon. Resolves to a built-in `SvgIcon` name when
     * the value matches one (e.g. `'pencil'`, `'deleted'`, `'send'`);
     * otherwise consumers can override the icon slot.
     */
    icon?: string;
    /**
     * When true, the action only appears on messages sent by the current
     * user (typical for `edit`/`delete`).
     */
    ownMessageOnly?: boolean;
}

export declare const AdvancedChat: DefineComponent<AdvancedChatProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"click-user-tag": (user: User) => any;
"send-message": (payload: {
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
reply?: MessageModel | null;
}) => any;
"edit-message": (payload: {
messageId: MessageModel["id"];
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
}) => any;
"typing-message": (value: string) => any;
"invalid-file": (payload: {
file: File;
reason: "size" | "count";
}) => any;
"show-chat-info": (chat: ChatModel) => any;
"menu-action-handler": (payload: {
chat: ChatModel;
action: Action;
}) => any;
"cancel-message-selection": () => any;
"message-selection-action-handler": (payload: {
chat: ChatModel;
action: Action;
messages: MessageModel[];
}) => any;
"message-action-handler": (payload: {
action: Action;
message: MessageModel;
}) => any;
"send-message-reaction": (payload: {
emoji: string;
message: MessageModel;
}) => any;
"open-file": (payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any;
"open-failed-message": (message: MessageModel) => any;
"fetch-messages": () => any;
"search-chat": (query: string) => any;
"add-chat": () => any;
"chat-action-handler": (payload: {
chat: ChatModel;
action: Action;
}) => any;
"fetch-more-chats": () => any;
"open-chat": (chat: ChatModel) => any;
retry: () => any;
}, string, PublicProps, Readonly<AdvancedChatProps> & Readonly<{
"onClick-user-tag"?: ((user: User) => any) | undefined;
"onSend-message"?: ((payload: {
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
reply?: MessageModel | null;
}) => any) | undefined;
"onEdit-message"?: ((payload: {
messageId: MessageModel["id"];
content: string;
files: ChatFileItem[];
mentionedUsers: User[];
}) => any) | undefined;
"onTyping-message"?: ((value: string) => any) | undefined;
"onInvalid-file"?: ((payload: {
file: File;
reason: "size" | "count";
}) => any) | undefined;
"onShow-chat-info"?: ((chat: ChatModel) => any) | undefined;
"onMenu-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
}) => any) | undefined;
"onCancel-message-selection"?: (() => any) | undefined;
"onMessage-selection-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
messages: MessageModel[];
}) => any) | undefined;
"onMessage-action-handler"?: ((payload: {
action: Action;
message: MessageModel;
}) => any) | undefined;
"onSend-message-reaction"?: ((payload: {
emoji: string;
message: MessageModel;
}) => any) | undefined;
"onOpen-file"?: ((payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any) | undefined;
"onOpen-failed-message"?: ((message: MessageModel) => any) | undefined;
"onFetch-messages"?: (() => any) | undefined;
"onSearch-chat"?: ((query: string) => any) | undefined;
"onAdd-chat"?: (() => any) | undefined;
"onChat-action-handler"?: ((payload: {
chat: ChatModel;
action: Action;
}) => any) | undefined;
"onFetch-more-chats"?: (() => any) | undefined;
"onOpen-chat"?: ((chat: ChatModel) => any) | undefined;
onRetry?: (() => any) | undefined;
}>, {
height: string;
status: "ready" | "loading" | "empty" | "error" | "offline" | "reconnecting" | "permission-denied";
chat: ChatModel | null;
textFormatting: Partial<TextFormattingOptions>;
showSendIcon: boolean;
showFiles: boolean;
showEmojis: boolean;
showFooter: boolean;
accept: string;
multiple: boolean;
capture: "" | "user" | "environment";
maxFiles: number;
maxFileSize: number;
currentUser: UserReference | null;
chatInfoEnabled: boolean;
selectionActions: Action[];
showReactionEmojis: boolean;
messages: MessageModel[];
showNewMessagesDivider: boolean;
loadingMessages: boolean;
messagesLoaded: boolean;
headerActions: Action[];
messageActions: Action[];
composerDisabled: boolean;
typingIndicatorPosition: "header" | "composer" | "both" | "none";
autoScroll: {
onMount?: boolean;
onChatSwitch?: boolean;
onSend?: boolean;
onReceive?: boolean;
};
showSearch: boolean;
showAddChat: boolean;
loadingChats: boolean;
chats: ChatModel[];
showChats: boolean;
chatsLoaded: boolean;
chatActions: Action[];
customSearchEnabled: boolean;
theme: Theme;
statusMessage: string;
retryLabel: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
container: HTMLDivElement;
}, HTMLDivElement>;

export declare interface AdvancedChatEvents {
    /**
     * Fires on each keystroke in the chats search input. Always emitted;
     * pair with `customSearchEnabled` to opt out of the built-in local
     * filter and drive results from your backend.
     */
    (e: 'search-chat', query: string): void;
    /** Fires when the "add chat" button is clicked. */
    (e: 'add-chat'): void;
    /** Fires when the chats list scrolls near the bottom and more chats should be paginated in. */
    (e: 'fetch-more-chats'): void;
    /** Fires when the messages list scrolls near the top and more messages should be paginated in. */
    (e: 'fetch-messages'): void;
    /** Fires when the user selects a chat from the list. */
    (e: 'open-chat', chat: ChatModel): void;
    /** Fires when the chat header is clicked while `chatInfoEnabled` is `true`. */
    (e: 'show-chat-info', chat: ChatModel): void;
    /** Fires when an item in the chat-header menu is selected. */
    (e: 'menu-action-handler', payload: {
        chat: ChatModel;
        action: Action;
    }): void;
    /** Fires when an item in a message's actions menu is selected. */
    (e: 'message-action-handler', payload: {
        action: Action;
        message: MessageModel;
    }): void;
    /** Fires when a bulk-selection action is invoked, with the currently-selected messages. */
    (e: 'message-selection-action-handler', payload: {
        chat: ChatModel;
        action: Action;
        messages: MessageModel[];
    }): void;
    /** Fires when an item in a chat-list item's actions menu is selected. */
    (e: 'chat-action-handler', payload: {
        chat: ChatModel;
        action: Action;
    }): void;
    /** Fires when the user exits message-selection mode. */
    (e: 'cancel-message-selection'): void;
    /** Fires when a message file is clicked; `action` is `'preview'` for media and `'download'` for other files. */
    (e: 'open-file', payload: {
        file: MessageFileModel;
        action: 'preview' | 'download';
    }): void;
    /** Fires when the user clicks a failed message to retry sending. */
    (e: 'open-failed-message', message: MessageModel): void;
    /** Fires when the viewer adds or removes a reaction; the host should toggle the emoji on the message. */
    (e: 'send-message-reaction', payload: {
        emoji: string;
        message: MessageModel;
    }): void;
    /** Fires when an `@user` tag in a rendered message is clicked. */
    (e: 'click-user-tag', user: User): void;
    /** Fires (debounced) as the viewer types in the composer; emit typing presence upstream. */
    (e: 'typing-message', value: string): void;
    /** Fires when the viewer sends a new message. */
    (e: 'send-message', payload: {
        content: string;
        files: ChatFileItem[];
        mentionedUsers: User[];
        reply?: MessageModel | null;
    }): void;
    /** Fires when the viewer commits an edit to an existing message. */
    (e: 'edit-message', payload: {
        messageId: MessageModel['id'];
        content: string;
        files: ChatFileItem[];
        mentionedUsers: User[];
    }): void;
    /**
     * Re-emitted from `Chat`/`ChatFooter` when a pending file is rejected
     * by a configured `maxFiles` / `maxFileSize` limit.
     */
    (e: 'invalid-file', payload: {
        file: File;
        reason: 'size' | 'count';
    }): void;
    /** Fires when the user activates the retry action in an error state. */
    (e: 'retry'): void;
}

export declare interface AdvancedChatOptions {
    localization?: Localization;
    strings?: Partial<Strings>;
}

export declare const AdvancedChatPlugin: ({ localization, strings }?: AdvancedChatOptions) => AdvancedChatPluginType;

export declare interface AdvancedChatPluginType {
    install: (app: App) => void;
}

export declare interface AdvancedChatProps {
    /** Outer container height as a CSS length. Defaults to `'600px'`. */
    height?: string;
    /** Visual theme. Defaults to `'auto'`, which follows the user's OS preference. */
    theme?: Theme;
    /** Identifies the viewer; required to render most UI. Defaults to `null`. */
    currentUser?: UserReference | null;
    /** Chats shown in the left-hand list. */
    chats?: ChatModel[];
    /** Initially-active chat; the inner `Chat` switches to this when it changes. */
    chat?: ChatModel | null;
    /** Messages for the active chat. */
    messages?: MessageModel[];
    /** Shows the chats-list spinner while `true`. */
    loadingChats?: boolean;
    /** Set to `true` once all chats have been delivered to disable further `fetch-more-chats`. */
    chatsLoaded?: boolean;
    /** Shows the messages spinner while `true`. */
    loadingMessages?: boolean;
    /** Set to `true` once all messages for the active chat have been delivered. */
    messagesLoaded?: boolean;
    /** Items rendered in the chat-header overflow menu. */
    headerActions?: Action[];
    /** Items rendered in each message's actions menu. */
    messageActions?: Action[];
    /** Items rendered in each chat-list item's actions menu. */
    chatActions?: Action[];
    /**
     * Bulk-action items rendered in the message-selection toolbar. Pass
     * non-empty to enable selection mode; pass empty (the default) to
     * disable it. Replaces the prior `messageSelectionActions` prop.
     */
    selectionActions?: Action[];
    /** Renders the chats sidebar when `true`. Defaults to `true`. */
    showChats?: boolean;
    /** Shows the search input in the chats sidebar. Defaults to `true`. */
    showSearch?: boolean;
    /** Shows the "add chat" button in the chats sidebar. Defaults to `true`. */
    showAddChat?: boolean;
    /** Shows the file-attachment button in the composer. Defaults to `true`. */
    showFiles?: boolean;
    /** Shows the emoji-picker button in the composer. Defaults to `true`. */
    showEmojis?: boolean;
    /** Renders the composer footer. Defaults to `true`. */
    showFooter?: boolean;
    /** Shows the send-icon button in the composer. Defaults to `true`. */
    showSendIcon?: boolean;
    /** Shows the inline emoji-reaction picker on each message. Defaults to `true`. */
    showReactionEmojis?: boolean;
    /** Renders the "new messages" divider above the first unread message. Defaults to `true`. */
    showNewMessagesDivider?: boolean;
    /**
     * Text-formatting applied to every message body in the active chat.
     */
    textFormatting?: Partial<TextFormattingOptions>;
    /** `accept` attribute forwarded to the file input. Defaults to `'*'`. */
    accept?: string;
    /** Allows selecting multiple files in the file picker. Defaults to `true`. */
    multiple?: boolean;
    /** `capture` attribute forwarded to the file input (mobile camera/mic). */
    capture?: '' | 'user' | 'environment';
    /** Max files in the composer at once. `0` / unset disables. */
    maxFiles?: number;
    /** Max bytes per file. `0` / unset disables. */
    maxFileSize?: number;
    /**
     * Where to render the typing-users indicator. See `Chat`'s prop for
     * full semantics. Default `'header'`.
     */
    typingIndicatorPosition?: 'header' | 'composer' | 'both' | 'none';
    /**
     * Auto-scroll policy for the message list. See `Chat`'s prop for
     * the per-leg semantics. All legs default `true`.
     */
    autoScroll?: {
        onMount?: boolean;
        onChatSwitch?: boolean;
        onSend?: boolean;
        onReceive?: boolean;
    };
    /**
     * When `true`, `search-chat` still fires on every keystroke but the
     * built-in local filter is suppressed — the host renders server-driven
     * results.
     */
    customSearchEnabled?: boolean;
    /** When `true`, the header becomes clickable and emits `show-chat-info`. */
    chatInfoEnabled?: boolean;
    /** Operational state shown by the component. Offline states preserve the chat UI. */
    status?: 'ready' | 'loading' | 'empty' | 'error' | 'offline' | 'reconnecting' | 'permission-denied';
    /** Optional host-provided copy for the operational state. */
    statusMessage?: string;
    /** Optional label for the error-state retry action. */
    retryLabel?: string;
    /** Disables the composer while preserving history and navigation. */
    composerDisabled?: boolean;
}

export declare const AudioControl: DefineComponent<AudioControlProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"hover-audio-progress": (hovering: boolean) => any;
"change-linehead": (position: number) => any;
}, string, PublicProps, Readonly<AudioControlProps> & Readonly<{
"onHover-audio-progress"?: ((hovering: boolean) => any) | undefined;
"onChange-linehead"?: ((position: number) => any) | undefined;
}>, {
percentage: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
progress: HTMLDivElement;
}, HTMLDivElement>;

export declare interface AudioControlEvents {
    /** Fires when the cursor enters or leaves the progress bar. */
    (e: 'hover-audio-progress', hovering: boolean): void;
    /** Fires when the user scrubs; `position` is `0`–`1` along the bar. */
    (e: 'change-linehead', position: number): void;
}

export declare interface AudioControlProps {
    /** Playback position as `0`–`100`. Drives the progress bar fill and dot. Defaults to `0`. */
    percentage?: number;
    /** When `true`, scrubbing is disabled so clicks toggle message selection instead. */
    messageSelectionEnabled: boolean;
}

export declare const AudioPlayer: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;

export declare interface AudioPlayerEvents {
    /** Fires when the cursor enters or leaves the progress bar. */
    (e: 'hover-audio-progress', hovering: boolean): void;
    /** Fires as playback advances; payload is the current `mm:ss` time, or total duration before playback starts. */
    (e: 'update-progress-time', value: string): void;
}

export declare interface AudioPlayerProps {
    /** Owning message; its `id` namespaces the underlying `<audio>` element and slot names. */
    message?: MessageReference;
    /** Audio source URL. Pass `null` to render a disabled player. */
    src?: string | null;
    /** When `true`, playback and scrubbing are disabled so clicks toggle message selection instead. */
    messageSelectionEnabled?: boolean;
}

export declare const AutocompleteMenu: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
        readonly onCommit?: ((item: T) => any) | undefined;
        readonly "onActivate-item"?: (() => any) | undefined;
        readonly "onActive-descendant-change"?: ((value: string | null) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onCommit" | "onActivate-item" | "onActive-descendant-change"> & AutocompleteMenuProps<T> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: {
        default?(_: {
            item: T;
            index: number;
            active: boolean;
        }): any;
    };
    emit: AutocompleteMenuEvents<T>;
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare interface AutocompleteMenuEvents<T> {
    /** Fired when the active item is committed. */
    (e: 'commit', item: T): void;
    /** Fired after the active index moves via `activeUpOrDown`. */
    (e: 'activate-item'): void;
    /** Reports the active option ID for the owning combobox's `aria-activedescendant`. */
    (e: 'active-descendant-change', value: string | null): void;
}

export declare interface AutocompleteMenuProps<T> {
    /** Items to render. Pass an empty array to hide the menu. */
    items: T[];
    /**
     * Stable per-item key. Avoids re-keying when item identity is stable
     * (e.g. `(user) => user.id`). Defaults to the array index, which is
     * fine for primitive lists like the emoji picker.
     */
    itemKey?: (item: T, index: number) => string | number;
    /**
     * When this signal flips truthy, the active item is committed via the
     * `commit` event. The host typically wires this to the Enter key.
     */
    selectItem?: boolean | null;
    /**
     * Positive → step forward; negative → step backward. The host wires
     * this to ArrowUp/ArrowDown.
     */
    activeUpOrDown?: number | null;
    /**
     * Layout used by the popup. `vertical` is a stacked list (user tags),
     * `horizontal` is a single-row chip strip (emoji suggestions).
     */
    layout?: 'vertical' | 'horizontal';
    /** Accessible name for the listbox. Required to satisfy axe `aria-input-field-name`. */
    ariaLabel?: string;
    /** ID used to connect the listbox and its active option to the owning combobox. */
    listboxId?: string;
}

/**
 * Union of recognized built-in action ids.
 */
export declare type BuiltInActionName = typeof REPLY_ACTION | typeof EDIT_ACTION;

export declare const Chat: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, __VLS_TemplateResult_2["slots"]>;

export declare const ChatEmojis: DefineComponent<ChatEmojisProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"activate-item": () => any;
"active-descendant-change": (value: string | null) => any;
"select-emoji": (emoji: string) => any;
}, string, PublicProps, Readonly<ChatEmojisProps> & Readonly<{
"onActivate-item"?: (() => any) | undefined;
"onActive-descendant-change"?: ((value: string | null) => any) | undefined;
"onSelect-emoji"?: ((emoji: string) => any) | undefined;
}>, {
selectItem: boolean | null;
activeUpOrDown: number | null;
listboxId: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface ChatEmojisEvents {
    /** Fires when the user commits an emoji from the popup. */
    (e: 'select-emoji', emoji: string): void;
    /** Fires after the active emoji moves via `activeUpOrDown`. */
    (e: 'activate-item'): void;
    /** Reports the active option ID for the owning combobox. */
    (e: 'active-descendant-change', value: string | null): void;
}

export declare interface ChatEmojisProps {
    /** Emojis matching the active `:` query. Pass an empty array to hide the popup. */
    filteredEmojis: string[];
    /** Truthy edge commits the active emoji. The host typically wires this to Enter. */
    selectItem?: boolean | null;
    /** Positive steps forward, negative backward. The host typically wires this to ArrowLeft/ArrowRight. */
    activeUpOrDown?: number | null;
    /** ID used to connect the suggestion listbox to the composer combobox. */
    listboxId?: string;
}

export declare interface ChatEvents {
    (e: 'toggle-chat-list'): void;
    (e: 'show-chat-info'): void;
    (e: 'menu-action-handler', payload: {
        chat: ChatModel;
        action: Action;
    }): void;
    (e: 'message-selection-action-handler', payload: {
        chat: ChatModel;
        action: Action;
        messages: MessageModel[];
    }): void;
    (e: 'cancel-message-selection'): void;
    (e: 'open-file', payload: {
        file: MessageFileModel;
        action: 'preview' | 'download';
    }): void;
    (e: 'typing-message', value: string): void;
    (e: 'send-message', payload: {
        content: string;
        files: ChatFileItem[];
        mentionedUsers: User[];
        reply?: MessageModel | null;
    }): void;
    (e: 'edit-message', payload: {
        messageId: MessageModel['id'];
        content: string;
        files: ChatFileItem[];
        mentionedUsers: User[];
    }): void;
    (e: 'message-action-handler', payload: {
        action: Action;
        message: MessageModel;
    }): void;
    (e: 'click-user-tag', user: User): void;
    (e: 'send-message-reaction', payload: {
        emoji: string;
        message: MessageModel;
    }): void;
    (e: 'open-failed-message', message: MessageModel): void;
    /**
     * Fired when the user scrolls near the top of the message list and more
     * messages should be paginated in. Suppressed while `loadingMessages` is
     * `true` or `messagesLoaded` is `true`.
     */
    (e: 'fetch-messages'): void;
    /**
     * Re-emitted from `ChatFooter` when a pending file is rejected by a
     * configured `maxFiles` / `maxFileSize` limit.
     */
    (e: 'invalid-file', payload: {
        file: File;
        reason: 'size' | 'count';
    }): void;
}

export declare const ChatFile: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, __VLS_TemplateResult_3["slots"]>;

export declare interface ChatFileEvents {
    /** Fires when the user clicks the remove button on this file tile. */
    (e: 'remove-file', index: number): void;
}

export declare interface ChatFileItem extends MessageFileModel {
    loading?: boolean;
    /**
     * Object URL used for a local preview. `ChatFooter` owns and revokes it
     * while pending; ownership transfers to the send/edit event listener.
     */
    localUrl?: string;
}

export declare interface ChatFileProps {
    /** File to render in the composer. Renders an image preview, video player, or generic file tile based on MIME type. */
    file: ChatFileItem;
    /** Position of this file within the composer's pending list; echoed back in `remove-file`. */
    index: number;
}

export declare const ChatFiles: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, __VLS_TemplateResult_4["slots"]>;

export declare interface ChatFilesEvents {
    /** Fires when the user removes a single file; `index` matches its position in `files`. */
    (e: 'remove-file', index: number): void;
    /** Fires when the user clears the entire pending-files tray. */
    (e: 'reset-message'): void;
}

export declare interface ChatFilesProps {
    /** Pending composer files. The container animates in when non-empty and hides when empty. */
    files: ChatFileItem[];
}

export declare const ChatFooter: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, __VLS_TemplateResult_5["slots"]>;

export declare interface ChatFooterEvents {
    /**
     * Transfers ownership of every emitted file's `localUrl` to the listener.
     * The listener must revoke those object URLs when it no longer needs them.
     */
    (e: 'send-message', payload: {
        content: string;
        files: ChatFileItem[];
        mentionedUsers: User[];
        reply?: MessageModel | null;
    }): void;
    /**
     * Transfers ownership of every emitted file's `localUrl` to the listener.
     * The listener must revoke those object URLs when it no longer needs them.
     */
    (e: 'edit-message', payload: {
        messageId: MessageModel['id'];
        content: string;
        files: ChatFileItem[];
        mentionedUsers: User[];
    }): void;
    (e: 'update-edited-message-id', value: MessageModel['id'] | null): void;
    (e: 'typing-message', value: string): void;
    (e: 'reset-reply-message'): void;
    (e: 'reset-edit-message'): void;
    (e: 'focus-textarea'): void;
    (e: 'blur-textarea'): void;
    /**
     * Fired once per file the composer rejected because of a configured
     * `maxFiles` / `maxFileSize` limit. Carries the original `File` so the
     * host can show its own error UI (toast, inline message, etc.).
     */
    (e: 'invalid-file', payload: {
        file: File;
        reason: InvalidFileReason;
    }): void;
}

export declare interface ChatFooterProps {
    chat?: ChatModel | null;
    users?: User[];
    roomMessage?: string;
    showSendIcon?: boolean;
    showFiles?: boolean;
    showEmojis?: boolean;
    showFooter?: boolean;
    disabled?: boolean;
    initReplyMessage?: MessageModel | null;
    initEditMessage?: MessageModel | null;
    /** MIME-type filter for the file input. */
    accept?: string;
    /** Allow multi-file selection. */
    multiple?: boolean;
    /** Mobile capture mode for the file input (e.g. `user`, `environment`). */
    capture?: '' | 'user' | 'environment';
    /**
     * Maximum number of pending files in the composer at once. Files added
     * past this limit are rejected with `invalid-file: { reason: 'count' }`.
     * `0` / unset disables the cap.
     */
    maxFiles?: number;
    /**
     * Maximum size in bytes for any single file. Files exceeding this size
     * are rejected with `invalid-file: { reason: 'size' }`. `0` / unset
     * disables the cap.
     */
    maxFileSize?: number;
}

export declare const ChatHeader: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, __VLS_TemplateResult_6["slots"]>;

export declare interface ChatHeaderEvents {
    /** Fires when the chat-list toggle button is clicked. */
    (e: 'toggle-chat-list'): void;
    /** Fires when the avatar/name area is clicked while `chatInfoEnabled` is `true`. */
    (e: 'show-chat-info'): void;
    /** Fires when an item in the overflow menu is selected. */
    (e: 'menu-action-handler', payload: {
        chat: ChatModel;
        action: Action;
    }): void;
    /** Fires when the user clicks the "cancel" button in the selection toolbar. */
    (e: 'cancel-message-selection'): void;
    /** Fires when a button in the selection toolbar is clicked. */
    (e: 'message-selection-action-handler', payload: {
        chat: ChatModel;
        action: Action;
    }): void;
}

export declare interface ChatHeaderProps {
    /** Identifies the viewer; used to derive the "other user" in 1:1 chats for avatar/status fallback. */
    currentUser: UserReference;
    /** Active chat being shown. */
    chat: ChatModel;
    /** When `true`, hides the chat-list toggle button (used when `Chat` is rendered without a sidebar). Defaults to `false`. */
    standalone?: boolean;
    /** Reflects whether the chats sidebar is currently expanded; controls the toggle-button rotation. Defaults to `false`. */
    showChatList?: boolean;
    /** Disables the toggle-button rotation animation on small viewports. Defaults to `false`. */
    isMobile?: boolean;
    /** When `true`, the avatar/name area becomes clickable and emits `show-chat-info`. Defaults to `false`. */
    chatInfoEnabled?: boolean;
    /** Items rendered in the chat-header overflow menu. */
    actions?: Array<Action>;
    /**
     * Bulk-action items rendered in the selection toolbar. When non-empty
     * and at least one message is selected, the toolbar replaces the
     * default header until the user cancels.
     */
    selectionActions?: Array<Action>;
    /** Number of currently-selected messages; rendered as a counter on each selection-action button. */
    selectedCount?: number;
    /**
     * When `false`, the typing-users line is suppressed in the header
     * (the `userStatus` line still renders). `Chat` flips this when its
     * `typingIndicatorPosition` excludes `header` so the indicator
     * doesn't render in two places at once.
     */
    showTypingIndicator?: boolean;
}

export declare const ChatMessage: DefineComponent<ChatMessageProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"click-user-tag": (user: User) => any;
"message-action-handler": (payload: {
action: Action;
message: MessageModel;
}) => any;
"send-message-reaction": (payload: {
emoji: string;
message: MessageModel;
}) => any;
"open-file": (payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any;
"select-message": (message: MessageModel) => any;
"open-failed-message": (message: MessageModel) => any;
}, string, PublicProps, Readonly<ChatMessageProps> & Readonly<{
"onClick-user-tag"?: ((user: User) => any) | undefined;
"onMessage-action-handler"?: ((payload: {
action: Action;
message: MessageModel;
}) => any) | undefined;
"onSend-message-reaction"?: ((payload: {
emoji: string;
message: MessageModel;
}) => any) | undefined;
"onOpen-file"?: ((payload: {
file: MessageFileModel;
action: "preview" | "download";
}) => any) | undefined;
"onSelect-message"?: ((message: MessageModel) => any) | undefined;
"onOpen-failed-message"?: ((message: MessageModel) => any) | undefined;
}>, {
index: number;
users: User[];
messageSelectionEnabled: boolean;
textFormatting: Partial<TextFormattingOptions>;
actions: Action[];
showReactionEmojis: boolean;
selected: boolean;
messages: MessageModel[];
showNewMessagesDivider: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare interface ChatMessageEvents {
    /** Fires when an item in the message's actions menu is selected. */
    (e: 'message-action-handler', payload: {
        action: Action;
        message: MessageModel;
    }): void;
    /** Fires when the viewer adds or removes a reaction; the host should toggle the emoji on the message. */
    (e: 'send-message-reaction', payload: {
        emoji: string;
        message: MessageModel;
    }): void;
    /** Fires when a file is clicked; `action` is `'preview'` for media and `'download'` otherwise. */
    (e: 'open-file', payload: {
        file: MessageFileModel;
        action: 'preview' | 'download';
    }): void;
    /** Fires when an `@user` tag in the message body is clicked. */
    (e: 'click-user-tag', user: User): void;
    /** Fires when the message is clicked while `messageSelectionEnabled` is `true`. */
    (e: 'select-message', message: MessageModel): void;
    /** Fires when the viewer clicks a failed message to retry sending. */
    (e: 'open-failed-message', message: MessageModel): void;
}

export declare interface ChatMessageProps {
    /** Identifies the viewer; used to render own vs. other styling and own-only actions. */
    currentUser: UserReference;
    /** Message rendered by this row. */
    message: MessageModel;
    /** Surrounding messages; used to decide whether to render a date divider above this row. */
    messages?: MessageModel[];
    /** Position of `message` within `messages`. Defaults to `0`. */
    index?: number;
    /** Chat members; used to resolve `@user` tags and reply previews. */
    users?: User[];
    /** Items rendered in this message's actions menu. */
    actions?: Action[];
    /** Shows the inline emoji-reaction picker on this message. Defaults to `true`. */
    showReactionEmojis?: boolean;
    /** Renders the "new messages" divider above this row when `message.unread` is true. Defaults to `true`. */
    showNewMessagesDivider?: boolean;
    /** Markdown / linkify configuration applied to the message body. */
    textFormatting?: Partial<TextFormattingOptions>;
    /** When `true`, clicks toggle this message's selection instead of opening menus. Defaults to `false`. */
    messageSelectionEnabled?: boolean;
    /** Whether this message is currently selected. Defaults to `false`. */
    selected?: boolean;
}

export declare interface ChatModel {
    id: Id;
    name: string;
    /**
     * Display picture for the chat — usually a group icon for multi-user
     * rooms; for 1:1 rooms consumers can leave this unset and let the
     * library fall back to the other user's avatar.
     */
    avatar?: string;
    unreadCount?: number;
    /**
     * Latest message in the chat, used to render the chat-list preview
     * row. Typed as `MessageSummary` so consumers can supply a tiny
     * projection without filling in `reactions`, `reply`, `disableActions`,
     * etc.; any full `Message` value is also assignable.
     */
    lastMessage?: MessageSummary;
    users?: User[];
    typingUsers?: UserReference[];
}

export declare interface ChatProps {
    currentUser?: UserReference | null;
    chat?: ChatModel | null;
    messages?: MessageModel[];
    loadingMessages?: boolean;
    /**
     * Set to `true` once every available message has been delivered for the
     * active chat. Disables further `fetch-messages` emissions.
     */
    messagesLoaded?: boolean;
    standalone?: boolean;
    showChatList?: boolean;
    isMobile?: boolean;
    chatInfoEnabled?: boolean;
    headerActions?: Action[];
    messageActions?: Action[];
    /**
     * Bulk-action items rendered in the selection toolbar. When non-empty,
     * clicking a message starts selection mode; the toolbar replaces the
     * default header until cancelled. Pass an empty array (default) to
     * disable selection mode entirely.
     */
    selectionActions?: Action[];
    showFiles?: boolean;
    showEmojis?: boolean;
    showFooter?: boolean;
    showSendIcon?: boolean;
    composerDisabled?: boolean;
    showReactionEmojis?: boolean;
    showNewMessagesDivider?: boolean;
    /**
     * Markdown / linkify / autolink configuration applied to every message
     * body in this chat. Per-render overrides (e.g. `singleLine` in reply
     * previews) compose on top.
     */
    textFormatting?: Partial<TextFormattingOptions>;
    accept?: string;
    multiple?: boolean;
    capture?: '' | 'user' | 'environment';
    /** Max files in the composer at once. `0` / unset disables. */
    maxFiles?: number;
    /** Max bytes per file. `0` / unset disables. */
    maxFileSize?: number;
    /**
     * Where to render the typing-users indicator.
     * - `'header'` (default): under the chat name, matches v2.
     * - `'composer'`: as a small line above `ChatFooter`'s textarea.
     * - `'both'`: render in both places.
     * - `'none'`: suppress entirely.
     */
    typingIndicatorPosition?: 'header' | 'composer' | 'both' | 'none';
    /**
     * Auto-scroll policy for the message list. Each leg defaults to the
     * v2-equivalent behavior: scroll on mount, on chat switch, on send,
     * and on receive *only when the user is already at the bottom*.
     * Set a leg to `false` to suppress that auto-scroll.
     */
    autoScroll?: {
        onMount?: boolean;
        onChatSwitch?: boolean;
        onSend?: boolean;
        onReceive?: boolean;
    };
}

export declare interface ChatReference {
    id: Id;
}

export declare const Chats: __VLS_WithTemplateSlots_7<typeof __VLS_component_7, __VLS_TemplateResult_7["slots"]>;

export declare interface ChatsEvents {
    /**
     * Emitted when the search input changes. The local list is filtered
     * automatically unless `customSearchEnabled` is true.
     */
    (event: 'search-chat', query: string): void;
    /**
     * Emitted when the add chat button is clicked
     */
    (event: 'add-chat'): void;
    /**
     * Emitted to fetch more chats for infinite scrolling
     */
    (event: 'fetch-more-chats'): void;
    /**
     * Emitted when a chat is selected to be shown
     */
    (event: 'open-chat', chat: ChatModel): void;
    /**
     * Emitted when more chats are being loaded
     */
    (event: 'loading-more-chats', isLoading: boolean): void;
    /**
     * Emitted when a per-chat dropdown action is triggered.
     */
    (event: 'chat-action-handler', payload: {
        chat: ChatModel;
        action: Action;
    }): void;
}

export declare const ChatsItem: __VLS_WithTemplateSlots_8<typeof __VLS_component_8, __VLS_TemplateResult_8["slots"]>;

export declare interface ChatsItemEvents {
    /**
     * Emitted when a chat action is triggered.
     */
    (event: 'chat-action-handler', payload: {
        chat: ChatModel;
        action: Action;
    }): void;
}

export declare interface ChatsItemProps {
    /** Identifies the viewer; used to derive the "other user" in 1:1 chats and to format checkmarks on the last message. */
    currentUser: UserReference;
    /** Chat rendered by this list item. */
    chat: ChatModel;
    /** Items rendered in this chat's overflow menu. */
    actions?: Array<Action>;
}

export declare interface ChatsProps {
    showChats?: boolean;
    showSearch?: boolean;
    showAddChat?: boolean;
    loadingChats?: boolean;
    /**
     * Set to `true` once the consumer has delivered every chat available;
     * this disables further `fetch-more-chats` emissions. When `false`
     * (the default), the component asks for more chats when the visible
     * list falls below `minimumVisibleChats` or when the bottom-of-list
     * sentinel scrolls into view.
     */
    chatsLoaded?: boolean;
    minimumVisibleChats?: number;
    isMobile?: boolean;
    currentUser?: UserReference;
    chats?: Array<ChatModel>;
    chat?: ChatModel;
    /**
     * Per-chat-row dropdown actions surfaced through `ChatsItem`.
     */
    chatActions?: Array<Action>;
    /**
     * When true, `search-chat` is emitted but the local filter is not
     * applied. Use this if the consumer drives chat results from the
     * server based on the search query.
     */
    customSearchEnabled?: boolean;
}

export declare const ChatsSearch: __VLS_WithTemplateSlots_9<typeof __VLS_component_9, __VLS_TemplateResult_9["slots"]>;

export declare interface ChatsSearchProps {
    /** Renders the search input. Defaults to `true`. */
    showSearch?: boolean;
    /** Renders the "add chat" button to the right of the input. Defaults to `true`. */
    showAddChat?: boolean;
    /** When `true`, hides the search input while the chats list is loading. Defaults to `false`. */
    loadingChats?: boolean;
    /** Chats list; the input is also hidden when this is empty. */
    chats?: Array<ChatModel>;
}

export declare const ChatUserTag: DefineComponent<ChatUserTagProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"activate-item": () => any;
"active-descendant-change": (value: string | null) => any;
"select-user-tag": (user: User) => any;
}, string, PublicProps, Readonly<ChatUserTagProps> & Readonly<{
"onActivate-item"?: (() => any) | undefined;
"onActive-descendant-change"?: ((value: string | null) => any) | undefined;
"onSelect-user-tag"?: ((user: User) => any) | undefined;
}>, {
selectItem: boolean | null;
activeUpOrDown: number | null;
listboxId: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface ChatUserTagEvents {
    /** Fires when the user commits a tag from the popup. */
    (e: 'select-user-tag', user: User): void;
    /** Fires after the active user moves via `activeUpOrDown`. */
    (e: 'activate-item'): void;
    /** Reports the active option ID for the owning combobox. */
    (e: 'active-descendant-change', value: string | null): void;
}

export declare interface ChatUserTagProps {
    /** Users matching the active `@` query. Pass an empty array to hide the popup. */
    filteredUsers: User[];
    /** Truthy edge commits the active user. The host typically wires this to Enter. */
    selectItem?: boolean | null;
    /** Positive steps forward, negative backward. The host typically wires this to ArrowUp/ArrowDown. */
    activeUpOrDown?: number | null;
    /** ID used to connect the suggestion listbox to the composer combobox. */
    listboxId?: string;
}

export declare const EDIT_ACTION = "edit";

export declare const EmojiPicker: DefineComponent<EmojiPickerProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<EmojiPickerProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
container: HTMLDivElement;
}, HTMLDivElement>;

export declare interface EmojiPickerProps {
    /** When `true`, the underlying `emoji-picker-element` is mounted into the container; setting `false` detaches it. */
    opened: boolean;
}

export declare const findUserById: (users: User[] | undefined, id: Id) => User | undefined;

export declare interface FormattedText {
    value: string;
    markdown?: boolean;
    singleLine?: boolean;
}

export declare const formatText: (text: string, { markdown, singleLine, linkify, linkOptions }: TextFormattingOptions, { users }?: TextFormattingBindings) => FormattedText;

export declare const getLocalizationStrings: (locale: Localization) => Strings;

export declare const getThemeStyles: (theme: Theme) => Styles;

/**
 * Identifier for chats, messages, and users. Pinned to `string` so
 * downstream lookups can use direct equality without coercion. Map
 * numeric backend ids with `String(id)` at the API boundary.
 */
export declare type Id = string;

/** Reason a file addition was rejected by `ChatFooter`. */
export declare type InvalidFileReason = 'size' | 'count';

export declare const Layout: __VLS_WithTemplateSlots_10<typeof __VLS_component_10, __VLS_TemplateResult_10["slots"]>;

export declare interface LayoutProps {
    height?: string;
    theme?: Theme;
    styles?: Partial<Styles>;
}

export declare interface LinkOptions {
    target?: '_blank' | '_self' | '_parent' | '_top';
    rel?: string;
}

export declare const Loader: DefineComponent<LoaderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<LoaderProps> & Readonly<{}>, {
show: boolean;
infinite: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface LoaderProps {
    /** Whether to show the loader */
    show: boolean;
    /** Whether the loader is for infinite scrolling */
    infinite?: boolean;
}

export declare type Localization = 'en' | 'auto';

export declare const MediaPreview: __VLS_WithTemplateSlots_11<typeof __VLS_component_11, __VLS_TemplateResult_11["slots"]>;

export declare interface MediaPreviewEvents {
    /** Fires when the user closes the preview via the close button, backdrop click, or Escape. */
    (e: 'close-media-preview'): void;
}

export declare interface MediaPreviewProps {
    /** Image or video to preview. The modal is hidden when `null` / unset. */
    file?: MessageFileModel | null;
}

export declare const Message: __VLS_WithTemplateSlots_12<typeof __VLS_component_12, __VLS_TemplateResult_12["slots"]>;

export declare const MessageActions: __VLS_WithTemplateSlots_13<typeof __VLS_component_13, __VLS_TemplateResult_13["slots"]>;

export declare interface MessageActionsEvents {
    /** Fires when an item in the dropdown menu is selected. */
    (e: 'message-action-handler', payload: {
        action: Action;
        message: MessageModel;
    }): void;
    /** Fires when the viewer picks a quick-reaction emoji; the host should toggle the emoji on the message. */
    (e: 'send-message-reaction', payload: {
        emoji: string;
        message: MessageModel;
    }): void;
}

export declare interface MessageActionsProps {
    /** Identifies the viewer; `ownMessageOnly` actions are hidden when this differs from `message.sender`. */
    currentUser: UserReference;
    /** Message these actions apply to. */
    message: MessageModel;
    /** Items rendered in the dropdown menu. */
    actions?: Action[];
    /** Renders the quick-reaction emoji picker alongside the dropdown. Defaults to `true`. */
    showReactionEmojis?: boolean;
}

export declare interface MessageEvents {
    (e: 'message-action-handler', payload: {
        action: Action;
        message: MessageModel;
    }): void;
    (e: 'send-message-reaction', payload: {
        emoji: string;
        message: MessageModel;
    }): void;
    (e: 'open-file', payload: {
        file: MessageFileModel;
        action: 'preview' | 'download';
    }): void;
    (e: 'click-user-tag', user: User): void;
    (e: 'select-message', message: MessageModel): void;
    (e: 'open-failed-message', message: MessageModel): void;
}

export declare const MessageFile: __VLS_WithTemplateSlots_14<typeof __VLS_component_14, __VLS_TemplateResult_14["slots"]>;

export declare interface MessageFileEvents {
    /** Fires when the file is clicked; `action` is `'preview'` for the eye icon and `'download'` for the document icon. */
    (e: 'open-file', payload: {
        file: MessageFileModel;
        action: 'preview' | 'download';
    }): void;
}

export declare interface MessageFileModel {
    name: string;
    type: string;
    extension: string;
    url: string;
    previewUrl?: string;
    /** Set to `false` to force image/video files through the host-controlled download flow. */
    previewable?: boolean;
    size?: number;
    /** Duration in seconds for audio/video files. */
    duration?: number;
    /** Upload progress (0-100) while a pending file is being sent. */
    progress?: number;
    /** In-memory blob for pending uploads (not for received files). */
    blob?: Blob;
}

export declare interface MessageFileProps {
    /** File rendered by this row. Image and video MIME types render rich previews. */
    file: MessageFileModel;
    /** Identifies the viewer; used to apply the blur-loading effect only on the sender's side. */
    currentUser: UserReference;
    /** Owning message; its `id` namespaces the slot names used to override icons. */
    message: MessageModel;
    /** Position of `file` within `message.files`. */
    index: number;
    /** When `true`, click events on this file are suppressed in favor of message selection. */
    messageSelectionEnabled: boolean;
}

export declare const MessageFiles: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;

export declare interface MessageFilesEvents {
    /** Fires when any file is clicked; `action` is `'preview'` for media and `'download'` for other files. */
    (e: 'open-file', payload: {
        file: MessageFileModel;
        action: 'preview' | 'download';
    }): void;
    /** Fires when an `@user` tag in the message body is clicked. */
    (e: 'click-user-tag', user: User): void;
}

export declare interface MessageFilesProps {
    /** Identifies the viewer; forwarded to each `MessageFile`. */
    currentUser: UserReference;
    /** Owning message; visual media files are rendered first, then other files, then the message body. */
    message: MessageModel;
    /** Chat members; used to resolve `@user` tags in the message body. */
    users: Array<User>;
    /** When `true`, file click events are suppressed in favor of message selection. */
    messageSelectionEnabled: boolean;
    /** Markdown / linkify configuration applied to the message body that follows the files. */
    textFormatting?: Partial<TextFormattingOptions>;
}

export declare interface MessageModel extends MessageSummary {
    reactions?: Record<string, Id[]>;
    /** True if this message is part of the unread batch that triggers the divider line. */
    unread?: boolean;
    system?: boolean;
    disableActions?: boolean;
    disableReactions?: boolean;
    /**
     * The message being quoted by this one. Tightened to `MessageSummary`
     * so a reply preview never recurses into yet another reply chain.
     */
    reply?: MessageSummary;
}

export declare interface MessageProps {
    currentUser: UserReference;
    message: MessageModel;
    users?: User[];
    actions?: Action[];
    showReactionEmojis?: boolean;
    /**
     * Text-formatting options applied to this message body. Composes with
     * downstream per-render overrides (single-line previews, etc.).
     */
    textFormatting?: Partial<TextFormattingOptions>;
    messageSelectionEnabled?: boolean;
    selected?: boolean;
}

export declare const MessageReactions: DefineComponent<MessageReactionsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"send-message-reaction": (payload: {
emoji: string;
reaction: Array<string | number>;
}) => any;
}, string, PublicProps, Readonly<MessageReactionsProps> & Readonly<{
"onSend-message-reaction"?: ((payload: {
emoji: string;
reaction: Array<string | number>;
}) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface MessageReactionsEvents {
    /** Fires when a reaction chip is clicked; `reaction` is the existing list of user IDs and the host should toggle `currentUser` in/out. */
    (e: 'send-message-reaction', payload: {
        emoji: string;
        reaction: Array<string | number>;
    }): void;
}

export declare interface MessageReactionsProps {
    /** Identifies the viewer; their entry in each reaction's user list highlights the chip as "mine". */
    currentUser: UserReference;
    /** Message whose `reactions` map is rendered. */
    message: MessageModel;
}

export declare interface MessageReference {
    id: Id;
}

export declare const MessageReply: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;

export declare interface MessageReplyProps {
    /** Outer message; its `reply` field provides the quoted preview body, sender, and first attachment. */
    message: MessageModel;
    /** Chat members; used to resolve `@user` tags in the quoted body. */
    users: Array<User>;
    /** Markdown / linkify configuration applied to the quoted body. `singleLine` is forced to `true`. */
    textFormatting?: Partial<TextFormattingOptions>;
}

/**
 * Delivery / failure state of a message. Replaces the four overlapping
 * booleans (`saved`/`delivered`/`read`/`failure`) used in earlier
 * alphas. Components render checkmarks based on this single value.
 */
export declare type MessageStatus = 'sending' | 'sent' | 'delivered' | 'read' | 'failed';

/**
 * The projection of a message that downstream surfaces actually need:
 * the chat-list last-message preview row and the reply-quote bubble.
 *
 * Consumers can pass any `Message` value here — every additional field
 * on `Message` is optional or unused by these surfaces. Use this type
 * for `Chat.lastMessage` and `Message.reply` so the recursive case
 * (a reply to a reply to a reply…) doesn't fall out of the model.
 */
export declare interface MessageSummary {
    id: Id;
    sender: User;
    content?: string;
    createdAt: string;
    status?: MessageStatus;
    deleted?: boolean;
    edited?: boolean;
    files?: MessageFileModel[];
}

export declare const MessageTemplate: DefineComponent<MessageTemplateProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"click-user-tag": (user: User) => any;
}, string, PublicProps, Readonly<MessageTemplateProps> & Readonly<{
"onClick-user-tag"?: ((user: User) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

export declare interface MessageTemplateEvents {
    /**
     * Emitted when a user tag is clicked
     */
    (event: 'click-user-tag', user: User): void;
}

export declare interface MessageTemplateProps {
    /** Message to render. Its `content` is run through `formatText`. */
    message?: MessageModel;
    /** Optional owning chat reference; reserved for future chat-aware formatting. */
    chat?: ChatReference;
    /** Chat members; used to resolve `@user` tags. */
    users?: Array<User>;
    /** Overrides for the default formatter (`markdown`, `linkify`, `singleLine`, etc). */
    formattingOptions?: Partial<TextFormattingOptions>;
}

/**
 * Negotiate against `navigator.language` for the closest supported
 * locale. Returns the fallback (`'en'`) and warns under DEV when the
 * detected language has no bundled dictionary.
 *
 * Exposed for tests and for consumers who want to make the same call
 * outside of Vue (e.g. SSR).
 */
export declare const negotiateLocale: () => SupportedLocale;

export declare const ProgressBar: DefineComponent<ProgressBarProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ProgressBarProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

export declare interface ProgressBarProps {
    /** The progress percentage */
    progress: number;
}

/**
 * Built-in `Action.id` values that `Chat` recognizes and handles
 * internally on top of emitting `message-action-handler`. Consumers can use
 * these constants to avoid relying on magic strings.
 */
export declare const REPLY_ACTION = "reply";

export declare type Strings = {
    'chats.empty': string;
    'chats.search.placeholder': string;
    'chat.empty': string;
    'chat.messages.empty': string;
    'chat.messages.new': string;
    'chat.message.placeholder': string;
    'chat.message.deleted': string;
    'chat.message.failure': string;
    'chat.typing': string;
    'chat.cancel-selection': string;
    'chat.cancel-reply': string;
    'chat.cancel-edit': string;
    'chat.scroll-to-bottom': string;
    'chat.user.is-online': string;
    'chat.user.last-seen': string;
    'chat.autocomplete.emojis': string;
    'chat.autocomplete.users': string;
    'chat.state.loading': string;
    'chat.state.empty': string;
    'chat.state.error': string;
    'chat.state.offline': string;
    'chat.state.reconnecting': string;
    'chat.state.permission-denied': string;
    'chat.state.retry': string;
};

export declare type Styles = {
    '--chat-color': string;
    '--chat-color-button-clear': string;
    '--chat-color-button': string;
    '--chat-bg-color-button': string;
    '--chat-bg-color-input': string;
    '--chat-color-spinner': string;
    '--chat-color-placeholder': string;
    '--chat-color-caret': string;
    '--chat-border-style': string;
    '--chat-bg-scroll-icon': string;
    '--chat-container-border': string;
    '--chat-container-border-radius': string;
    '--chat-container-box-shadow': string;
    '--chat-header-bg-color': string;
    '--chat-header-color-name': string;
    '--chat-header-color-info': string;
    '--chat-header-position': string;
    '--chat-header-width': string;
    '--chat-footer-bg-color': string;
    '--chat-border-style-input': string;
    '--chat-border-color-input-selected': string;
    '--chat-footer-bg-color-reply': string;
    '--chat-footer-bg-color-tag-active': string;
    '--chat-footer-bg-color-tag': string;
    '--chat-content-bg-color': string;
    '--chat-sidemenu-bg-color': string;
    '--chat-sidemenu-bg-color-hover': string;
    '--chat-sidemenu-bg-color-active': string;
    '--chat-sidemenu-color-active': string;
    '--chat-sidemenu-border-color-search': string;
    '--chat-dropdown-bg-color': string;
    '--chat-dropdown-bg-color-hover': string;
    '--chat-message-bg-color': string;
    '--chat-message-bg-color-me': string;
    '--chat-message-color-started': string;
    '--chat-message-bg-color-deleted': string;
    '--chat-message-bg-color-selected': string;
    '--chat-message-color-deleted': string;
    '--chat-message-color-username': string;
    '--chat-message-color-timestamp': string;
    '--chat-message-bg-color-date': string;
    '--chat-message-color-date': string;
    '--chat-message-bg-color-system': string;
    '--chat-message-color-system': string;
    '--chat-message-color': string;
    '--chat-message-bg-color-media': string;
    '--chat-message-bg-color-reply': string;
    '--chat-message-color-reply-username': string;
    '--chat-message-color-reply-content': string;
    '--chat-message-color-tag': string;
    '--chat-message-bg-color-image': string;
    '--chat-message-color-new-messages': string;
    '--chat-message-bg-color-scroll-counter': string;
    '--chat-message-color-scroll-counter': string;
    '--chat-message-bg-color-reaction': string;
    '--chat-message-border-style-reaction': string;
    '--chat-message-bg-color-reaction-hover': string;
    '--chat-message-border-style-reaction-hover': string;
    '--chat-message-color-reaction-counter': string;
    '--chat-message-bg-color-reaction-me': string;
    '--chat-message-border-style-reaction-me': string;
    '--chat-message-bg-color-reaction-hover-me': string;
    '--chat-message-border-style-reaction-hover-me': string;
    '--chat-message-color-reaction-counter-me': string;
    '--chat-message-bg-color-audio-record': string;
    '--chat-message-bg-color-audio-line': string;
    '--chat-message-bg-color-audio-progress': string;
    '--chat-message-bg-color-audio-progress-selector': string;
    '--chat-message-color-file-extension': string;
    '--chat-markdown-bg': string;
    '--chat-markdown-border': string;
    '--chat-markdown-color': string;
    '--chat-markdown-color-multi': string;
    '--chat-room-color-username': string;
    '--chat-room-color-message': string;
    '--chat-room-color-timestamp': string;
    '--chat-room-color-online': string;
    '--chat-room-color-offline': string;
    '--chat-room-bg-color-badge': string;
    '--chat-room-color-badge': string;
    '--chat-emoji-bg-color': string;
    '--chat-icon-color-search': string;
    '--chat-icon-color-add': string;
    '--chat-icon-color-toggle': string;
    '--chat-icon-color-menu': string;
    '--chat-icon-color-close': string;
    '--chat-icon-color-close-image': string;
    '--chat-icon-color-file': string;
    '--chat-icon-color-paperclip': string;
    '--chat-icon-color-close-outline': string;
    '--chat-icon-color-close-preview': string;
    '--chat-icon-color-send': string;
    '--chat-icon-color-send-disabled': string;
    '--chat-icon-color-emoji': string;
    '--chat-icon-color-emoji-reaction': string;
    '--chat-icon-color-document': string;
    '--chat-icon-color-pencil': string;
    '--chat-icon-color-checkmark': string;
    '--chat-icon-color-checkmark-seen': string;
    '--chat-icon-color-eye': string;
    '--chat-icon-color-dropdown-message': string;
    '--chat-icon-bg-dropdown-message': string;
    '--chat-icon-color-dropdown-room': string;
    '--chat-icon-color-dropdown-scroll': string;
    '--chat-icon-color-microphone': string;
    '--chat-icon-color-audio-play': string;
    '--chat-icon-color-audio-pause': string;
    '--chat-icon-color-audio-cancel': string;
    '--chat-icon-color-audio-confirm': string;
    '--chat-message-color-failure': string;
    '--chat-message-bg-color-failure': string;
};

/**
 * Locales the package ships strings for. Add new BCP 47 prefixes here
 * when introducing additional `*.json` dictionaries.
 */
declare const SUPPORTED_LOCALE_PREFIXES: readonly ["en"];

declare type SupportedLocale = (typeof SUPPORTED_LOCALE_PREFIXES)[number];

export declare const SvgIcon: DefineComponent<SvgIconProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SvgIconProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, SVGSVGElement>;

export declare interface SvgIconProps {
    /** The name of the SVG icon to display */
    name: string;
    /** An optional parameter to differentiate icons */
    param?: string | null;
}

export declare interface TextFormattingBindings {
    users?: Array<User>;
}

export declare interface TextFormattingOptions {
    markdown?: boolean;
    singleLine?: boolean;
    linkify?: boolean;
    linkOptions?: LinkOptions;
}

export declare type Theme = 'light' | 'dark' | 'auto' | {
    base: 'light' | 'dark';
    overrides: Partial<Styles>;
};

export declare const typingUsersString: (chat: ChatModel, strings: Pick<Strings, "chat.typing">) => string;

/**
 * Shared state machine for the floating autocomplete menus that surface
 * emoji and user-tag suggestions in `ChatFooter`. Owns the active-index
 * logic; the host component renders the items and forwards the parent's
 * keyboard signals.
 *
 * The signal-driven shape (rather than direct keyboard handlers) lets
 * the parent component decide which keys mean navigate / commit so the
 * same composable can power user-tag, emoji, slash-command, etc.
 */
export declare const useAutocomplete: <T>(options: UseAutocompleteOptions<T>) => UseAutocompleteReturn;

export declare interface UseAutocompleteOptions<T> {
    /** Reactive list of currently-suggested items. */
    items: MaybeRefOrGetter<T[]>;
    /** When this signal flips truthy, the active item is committed via `onCommit`. */
    selectSignal?: MaybeRefOrGetter<boolean | null>;
    /** Positive number → step forward; negative → step backward. */
    navSignal?: MaybeRefOrGetter<number | null>;
    /** Fired with the active item when `selectSignal` flips truthy. */
    onCommit?: (item: T) => void;
    /** Fired after `navSignal` moves the active index. */
    onNavigate?: () => void;
}

export declare interface UseAutocompleteReturn {
    /** Currently highlighted index, or `null` when the list is empty. */
    activeIndex: Readonly<Ref<number | null>>;
    /** Manually set the active index (e.g. on hover). */
    setActiveIndex: (index: number | null) => void;
}

/**
 * IntersectionObserver-driven `loadMore` trigger. Re-attaches automatically
 * when the target or scroll root changes, and releases the observer on
 * unmount. The host owns the actual fetch — this composable just decides
 * when to call it.
 */
export declare const useInfiniteScroll: (options: UseInfiniteScrollOptions) => UseInfiniteScrollReturn;

export declare interface UseInfiniteScrollOptions {
    /**
     * Element whose visibility triggers loading (the bottom-of-list
     * sentinel). Accepts a `Ref` (e.g. from `useTemplateRef`) or a
     * lazy getter for elements behind a `v-if`.
     */
    target: MaybeRefOrGetter<HTMLElement | null>;
    /**
     * Element used as the `IntersectionObserver` root (the scroll
     * container). Same shape as `target`.
     */
    scrollRoot: MaybeRefOrGetter<HTMLElement | null>;
    /** Stops the observer once the consumer has delivered every available item. */
    exhausted: MaybeRefOrGetter<boolean>;
    /** Margin around the root, forwarded to IntersectionObserver. Defaults to `100px`. */
    rootMargin?: string;
    /** Fired when the sentinel intersects the root. */
    onLoadMore: () => void;
}

export declare interface UseInfiniteScrollReturn {
    /** True between an `onLoadMore` invocation and the consumer flipping `exhausted` or
     *  appending new items (which the host is expected to detect and reset via `setLoading(false)`). */
    loading: Readonly<Ref<boolean>>;
    /** Manually toggle the loading flag (e.g. when the host knows new items have arrived). */
    setLoading: (value: boolean) => void;
    /** Manually re-attach the observer (the composable already does this when `target`/`scrollRoot` change). */
    reset: () => void;
}

export declare const useLocalizationStrings: () => Strings;

/**
 * Wraps the project's tiny `filterItems` helper in a reactive composable
 * with the custom-search escape hatch already plumbed in. Used by `Chats`
 * for chat-list search and reusable for other id-bearing collections.
 */
export declare const useLocalSearch: <T>(options: UseLocalSearchOptions<T>) => UseLocalSearchReturn<T>;

export declare interface UseLocalSearchOptions<T> {
    /** Items to filter. */
    items: MaybeRefOrGetter<T[]>;
    /** Item field to match against (e.g. `'name'`). */
    field: keyof T;
    /**
     * When `true`, `query` is exposed and emitted but the local list is
     * passed through unfiltered — the host renders server-driven results.
     */
    custom?: MaybeRefOrGetter<boolean>;
    /** Fired with the current query on every change (after `null`-to-empty conversion). */
    onSearch?: (query: string) => void;
}

export declare interface UseLocalSearchReturn<T> {
    /** Current search query. `null` means no filter is active. */
    query: Ref<string | null>;
    /** Filtered items, or the raw input when `custom` is true. */
    filtered: ComputedRef<T[]>;
    /** Update the query and forward it via `onSearch`. */
    setQuery: (value: string) => void;
}

/**
 * Tracks the currently selected messages while bulk-selection mode is active.
 * Used by `Chat.vue` and any host that wants to expose multi-select actions
 * (forward, delete, etc.). The composable is generic so consumers can select
 * any id-bearing entity, not just `Message`.
 */
export declare const useMessageSelection: <T extends {
    id: Id;
}>(options: UseMessageSelectionOptions) => UseMessageSelectionReturn<T>;

export declare interface UseMessageSelectionOptions {
    /** When non-empty, selection mode is enabled. Pass the configured action list. */
    enabled: MaybeRefOrGetter<boolean>;
    /** Resets the selection whenever this value changes (e.g. the active chat id). */
    resetKey?: MaybeRefOrGetter<unknown>;
    /** Fired when the user explicitly cancels selection. */
    onCancel?: () => void;
}

export declare interface UseMessageSelectionReturn<T extends {
    id: Id;
}> {
    /** Currently selected items, in selection order. */
    selected: Ref<T[]>;
    /** Convenience predicate for templates: `selectedIds.value.has(id)`. */
    selectedIds: ComputedRef<Set<Id>>;
    /** Toggle membership of `item` in the selection. No-op when disabled. */
    toggle: (item: T) => void;
    /** Clear the selection without invoking `onCancel`. */
    clear: () => void;
    /** Clear the selection and invoke `onCancel` (host-driven cancel button). */
    cancel: () => void;
}

export declare interface User {
    id: Id;
    name: string;
    /**
     * Optional URL of the user's profile picture. Rendered as an avatar
     * in the message author block, the user-tag autocomplete row, and
     * (for 1:1 chats) as a fallback for `Chat.avatar`.
     */
    avatar?: string;
    status: {
        state: 'online' | 'offline' | 'away' | 'busy';
        lastActiveAt?: string;
    };
}

/**
 * Owns the reply/edit message state in the composer. Reading the action's
 * `id` (rather than identity) keeps host-defined actions interchangeable
 * with the library's `REPLY_ACTION` / `EDIT_ACTION` constants.
 */
export declare const useReplyEdit: (options?: UseReplyEditOptions) => UseReplyEditReturn;

export declare interface UseReplyEditOptions {
    /** Resets reply/edit state whenever this value changes (e.g. the active chat id). */
    resetKey?: MaybeRefOrGetter<unknown>;
}

export declare interface UseReplyEditReturn {
    /** Message currently being replied to, or `null`. */
    replyMessage: Ref<MessageModel | null>;
    /** Message currently being edited, or `null`. */
    editMessage: Ref<MessageModel | null>;
    /**
     * Dispatches a `message-action-handler` payload. Sets `replyMessage` /
     * `editMessage` for the built-in reply/edit actions and is otherwise a
     * no-op so hosts can still chain custom actions through it.
     */
    dispatch: (payload: {
        action: Action;
        message: MessageModel;
    }) => void;
    /** Clears `replyMessage`. Match this to `ChatFooter`'s `reset-reply-message`. */
    resetReply: () => void;
    /** Clears `editMessage`. Match this to `ChatFooter`'s `reset-edit-message`. */
    resetEdit: () => void;
}

export declare interface UserReference {
    id: Id;
}

/**
 * Reactive `Styles` ref that follows the active theme. When the theme
 * is `'auto'` it tracks `prefers-color-scheme` updates after mount.
 */
export declare const useThemeStyles: (theme: Ref<Theme | undefined>) => Ref<Styles>;

export { }