import { AllowedComponentProps } from 'vue';
import { App } from 'vue';
import { Component } from 'vue';
import { ComponentCustomProperties } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentInternalInstance } from 'vue';
import { ComponentOptionsBase } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { CSSProperties } from 'vue';
import { DebuggerEvent } from 'vue';
import { DefineComponent } from 'vue';
import { Directive } from 'vue';
import { Editor } from '@tiptap/vue-3';
import { Editor as Editor_2 } from '@tiptap/core';
import { Extension } from '@tiptap/core';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { MaybeComputedElementRef } from '@vueuse/core';
import { MaybeRefOrGetter } from 'vue';
import { nextTick } from 'vue';
import { Node as Node_2 } from '@tiptap/core';
import { OnCleanup } from '@vue/reactivity';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { ShallowUnwrapRef } from 'vue';
import { Slot } from 'vue';
import { TransitionProps } from 'vue';
import { UseFileDialogOptions } from '@vueuse/core';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';
import { WatchOptions } from 'vue';
import { WatchStopHandle } from 'vue';

declare const __VLS_component: DefineComponent<BubbleProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"state-change": (payload: {
key: string;
value: unknown;
messageIndex: number;
contentIndex: number;
}) => any;
}, string, PublicProps, Readonly<BubbleProps> & Readonly<{
"onState-change"?: ((payload: {
key: string;
value: unknown;
messageIndex: number;
contentIndex: number;
}) => any) | undefined;
}>, {
placement: "start" | "end";
shape: "corner" | "rounded" | "none";
contentRenderMode: "single" | "split";
contentResolver: (message: BubbleMessage) => ChatMessageContent | undefined;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
bubbleRef: HTMLDivElement;
}, HTMLDivElement>;

declare const __VLS_component_10: DefineComponent<__VLS_PublicProps_3, {
children: ComputedRef<(HTMLElement | SVGElement)[]>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:showAll": (value: boolean | undefined) => any;
} & {
"click-outside": (event: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_PublicProps_3> & Readonly<{
"onClick-outside"?: ((event: MouseEvent) => any) | undefined;
"onUpdate:showAll"?: ((value: boolean | undefined) => any) | undefined;
}>, {
showAllButtonOn: "hover" | "always";
overflowMode: "expand" | "scroll";
}, {}, {}, {}, string, ComponentProvideOptions, false, {
containerWrapperRef: HTMLDivElement;
containerRef: HTMLDivElement;
staticMaybeItemRefs: unknown[];
floatingItemsRef: HTMLDivElement;
floatingMaybeItemRefs: unknown[];
}, HTMLDivElement>;

declare const __VLS_component_11: DefineComponent<__VLS_PublicProps_4, {
update: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:selectedGroup": (value: string) => any;
} & {
close: () => any;
open: () => any;
"item-click": (item: SuggestionItem<Record<string, unknown>>) => any;
"click-outside": (event: MouseEvent) => any;
"group-click": (group: SuggestionGroup<Record<string, unknown>>) => any;
}, string, PublicProps, Readonly<__VLS_PublicProps_4> & Readonly<{
onClose?: (() => any) | undefined;
onOpen?: (() => any) | undefined;
"onItem-click"?: ((item: SuggestionItem<Record<string, unknown>>) => any) | undefined;
"onClick-outside"?: ((event: MouseEvent) => any) | undefined;
"onGroup-click"?: ((group: SuggestionGroup<Record<string, unknown>>) => any) | undefined;
"onUpdate:selectedGroup"?: ((value: string) => any) | undefined;
}>, {
title: string;
trigger: "click" | "manual";
groupShowMoreTrigger: "click" | "hover";
topOffset: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
basePopperRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly appendTo?: (string | HTMLElement) | undefined;
readonly offset?: number | {
mainAxis?: number;
crossAxis?: number;
} | undefined;
readonly placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | undefined;
readonly preventOverflow?: boolean | undefined;
readonly show?: boolean | undefined;
readonly transitionProps?: TransitionProps | undefined;
readonly triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>> | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: ComponentOptionsBase<Readonly<{
appendTo?: string | HTMLElement;
offset?: number | {
mainAxis?: number;
crossAxis?: number;
};
placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
preventOverflow?: boolean;
show?: boolean;
transitionProps?: TransitionProps;
triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
}> & Readonly<{}>, {
triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
popperRef: ComputedRef<HTMLDivElement | null>;
update: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
}> & Omit<Readonly<{
appendTo?: string | HTMLElement;
offset?: number | {
mainAxis?: number;
crossAxis?: number;
};
placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
preventOverflow?: boolean;
show?: boolean;
transitionProps?: TransitionProps;
triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
}> & Readonly<{}>, "placement" | "popperRef" | "update" | "triggerRef"> & ShallowUnwrapRef<    {
triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
popperRef: ComputedRef<HTMLDivElement | null>;
update: () => void;
}> & {} & ComponentCustomProperties & {} & {
$slots: Readonly<{
trigger?: () => VNode[];
content?: () => VNode[];
}> & {
trigger?: () => VNode[];
content?: () => VNode[];
};
}) | null;
listRef: HTMLUListElement;
tooltipRef: CreateComponentPublicInstanceWithMixins<Readonly<{
show?: TooltipContentProps["show"];
} & TooltipContentProps> & Readonly<{
"onUpdate:show"?: ((value: boolean | undefined) => any) | undefined;
}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:show": (value: boolean | undefined) => any;
}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
P: {};
B: {};
D: {};
C: {};
M: {};
Defaults: {};
}, Readonly<{
show?: TooltipContentProps["show"];
} & TooltipContentProps> & Readonly<{
"onUpdate:show"?: ((value: boolean | undefined) => any) | undefined;
}>, {}, {}, {}, {}, {}> | null;
}, any>;

declare const __VLS_component_12: DefineComponent<__VLS_PublicProps_5, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:theme": (value: string) => any;
"update:colorMode": (value: ColorMode) => any;
}, string, PublicProps, Readonly<__VLS_PublicProps_5> & Readonly<{
"onUpdate:theme"?: ((value: string) => any) | undefined;
"onUpdate:colorMode"?: ((value: ColorMode) => any) | undefined;
}>, {
targetElement: string;
storageKey: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_13: DefineComponent<WelcomeProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<WelcomeProps> & Readonly<{}>, {
align: "left" | "center" | "right" | string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_14: DefineComponent<__VLS_PublicProps_6, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:visible": (value: boolean) => any;
} & {
refresh: (tab: "installed" | "market") => any;
"update:visible": (visible: boolean) => any;
"market-category-change": (category: string) => any;
"tab-change": (activeTab: "installed" | "market") => any;
"plugin-toggle": (plugin: PluginInfo, enabled: boolean) => any;
"plugin-delete": (plugin: PluginInfo) => any;
"plugin-add": (plugin: PluginInfo) => any;
"plugin-create": (type: "code" | "form", data: PluginCreationData) => any;
"tool-toggle": (plugin: PluginInfo, toolId: string, enabled: boolean) => any;
"update:activeCount": (count: number) => any;
}, string, PublicProps, Readonly<__VLS_PublicProps_6> & Readonly<{
onRefresh?: ((tab: "installed" | "market") => any) | undefined;
"onUpdate:visible"?: ((value: boolean) => any) | undefined;
"onMarket-category-change"?: ((category: string) => any) | undefined;
"onTab-change"?: ((activeTab: "installed" | "market") => any) | undefined;
"onPlugin-toggle"?: ((plugin: PluginInfo, enabled: boolean) => any) | undefined;
"onPlugin-delete"?: ((plugin: PluginInfo) => any) | undefined;
"onPlugin-add"?: ((plugin: PluginInfo) => any) | undefined;
"onPlugin-create"?: ((type: "code" | "form", data: PluginCreationData) => any) | undefined;
"onTool-toggle"?: ((plugin: PluginInfo, toolId: string, enabled: boolean) => any) | undefined;
"onUpdate:activeCount"?: ((count: number) => any) | undefined;
}>, {
title: string;
loading: boolean;
installedPlugins: PluginInfo[];
marketPlugins: PluginInfo[];
searchPlaceholder: string;
enableSearch: boolean;
installedSearchFn: (query: string, item: PluginInfo) => boolean;
marketSearchFn: (query: string, item: PluginInfo) => boolean;
marketCategoryOptions: MarketCategoryOption[];
marketCategoryPlaceholder: string;
enableMarketCategoryFilter: boolean;
defaultActiveTab: "installed" | "market";
showInstalledTab: boolean;
showMarketTab: boolean;
popupConfig: PopupConfig;
installedTabTitle: string;
marketTabTitle: string;
showCustomAddButton: boolean;
customAddButtonText: string;
allowPluginToggle: boolean;
allowToolToggle: boolean;
allowPluginDelete: boolean;
allowPluginAdd: boolean;
marketLoading: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_15: DefineComponent<ActionButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ActionButtonProps> & Readonly<{}>, {
disabled: boolean;
active: boolean;
tooltipPlacement: TooltipPlacement;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_16: DefineComponent<VoiceButtonProps, {
start: () => void;
stop: () => void;
speechState: SpeechState;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"speech-start": () => any;
"speech-interim": (transcript: string) => any;
"speech-final": (transcript: string) => any;
"speech-end": (transcript?: string | undefined) => any;
"speech-error": (error: Error) => any;
}, string, PublicProps, Readonly<VoiceButtonProps> & Readonly<{
"onSpeech-start"?: (() => any) | undefined;
"onSpeech-interim"?: ((transcript: string) => any) | undefined;
"onSpeech-final"?: ((transcript: string) => any) | undefined;
"onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
"onSpeech-error"?: ((error: Error) => any) | undefined;
}>, {
tooltipPlacement: TooltipPlacement;
autoInsert: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_2: DefineComponent<BubbleListProps, {
scrollToBottom: (behavior?: ScrollBehavior) => Promise<void>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"state-change": (payload: {
key: string;
value: unknown;
messageIndex: number;
contentIndex: number;
}) => any;
}, string, PublicProps, Readonly<BubbleListProps> & Readonly<{
"onState-change"?: ((payload: {
key: string;
value: unknown;
messageIndex: number;
contentIndex: number;
}) => any) | undefined;
}>, {
contentResolver: (message: BubbleMessage) => ChatMessageContent | undefined;
groupStrategy: "consecutive" | "divider" | ((messages: BubbleMessage[], dividerRole?: string) => BubbleMessageGroup[]);
dividerRole: string;
fallbackRole: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
listRef: HTMLDivElement;
}, HTMLDivElement>;

declare const __VLS_component_3: DefineComponent<BubbleProviderProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BubbleProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_4: DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:show": (value: boolean) => any;
"update:fullscreen": (value: boolean | undefined) => any;
} & {
close: () => any;
}, string, PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
onClose?: (() => any) | undefined;
"onUpdate:show"?: ((value: boolean) => any) | undefined;
"onUpdate:fullscreen"?: ((value: boolean | undefined) => any) | undefined;
}>, {
title: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_5: DefineComponent<DragOverlayProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<DragOverlayProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;

declare const __VLS_component_6: DefineComponent<__VLS_PublicProps_2, {
update: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:show": (value: boolean) => any;
} & {
"item-click": (item: DropdownMenuItem) => any;
"click-outside": (event: MouseEvent) => any;
}, string, PublicProps, Readonly<__VLS_PublicProps_2> & Readonly<{
"onUpdate:show"?: ((value: boolean) => any) | undefined;
"onItem-click"?: ((item: DropdownMenuItem) => any) | undefined;
"onClick-outside"?: ((event: MouseEvent) => any) | undefined;
}>, {
trigger: "click" | "hover" | "manual";
}, {}, {}, {}, string, ComponentProvideOptions, false, {
basePopperRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly appendTo?: (string | HTMLElement) | undefined;
readonly offset?: number | {
mainAxis?: number;
crossAxis?: number;
} | undefined;
readonly placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | undefined;
readonly preventOverflow?: boolean | undefined;
readonly show?: boolean | undefined;
readonly transitionProps?: TransitionProps | undefined;
readonly triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>> | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: (event: string, ...args: any[]) => void;
$el: any;
$options: ComponentOptionsBase<Readonly<{
appendTo?: string | HTMLElement;
offset?: number | {
mainAxis?: number;
crossAxis?: number;
};
placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
preventOverflow?: boolean;
show?: boolean;
transitionProps?: TransitionProps;
triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
}> & Readonly<{}>, {
triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
popperRef: ComputedRef<HTMLDivElement | null>;
update: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
}> & Omit<Readonly<{
appendTo?: string | HTMLElement;
offset?: number | {
mainAxis?: number;
crossAxis?: number;
};
placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
preventOverflow?: boolean;
show?: boolean;
transitionProps?: TransitionProps;
triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
}> & Readonly<{}>, "placement" | "popperRef" | "update" | "triggerRef"> & ShallowUnwrapRef<    {
triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
popperRef: ComputedRef<HTMLDivElement | null>;
update: () => void;
}> & {} & ComponentCustomProperties & {} & {
$slots: Readonly<{
trigger?: () => VNode[];
content?: () => VNode[];
}> & {
trigger?: () => VNode[];
content?: () => VNode[];
};
}) | null;
}, any>;

declare const __VLS_component_7: DefineComponent<PromptsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"item-click": (ev: MouseEvent, item: PromptProps) => any;
}, string, PublicProps, Readonly<PromptsProps> & Readonly<{
"onItem-click"?: ((ev: MouseEvent, item: PromptProps) => any) | undefined;
}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const __VLS_component_8: DefineComponent<SenderProps_2, {
focus: () => void;
blur: () => void;
clear: () => void;
submit: () => void;
setTemplateData: (templateData: UserTemplateItem[]) => void;
startSpeech: () => void;
stopSpeech: () => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
clear: () => any;
blur: (event: FocusEvent) => any;
cancel: () => any;
focus: (event: FocusEvent) => any;
submit: (value: string) => any;
"update:modelValue": (value: string) => any;
"speech-start": () => any;
"speech-interim": (transcript: string) => any;
"speech-end": (transcript?: string | undefined) => any;
"speech-error": (error: Error) => any;
"update:templateData": (value: UserItem[]) => any;
"suggestion-select": (value: string) => any;
"escape-press": () => any;
"reset-template": () => any;
"files-selected": (files: File[]) => any;
}, string, PublicProps, Readonly<SenderProps_2> & Readonly<{
onClear?: (() => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
onCancel?: (() => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onSubmit?: ((value: string) => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
"onSpeech-start"?: (() => any) | undefined;
"onSpeech-interim"?: ((transcript: string) => any) | undefined;
"onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
"onSpeech-error"?: ((error: Error) => any) | undefined;
"onUpdate:templateData"?: ((value: UserItem[]) => any) | undefined;
"onSuggestion-select"?: ((value: string) => any) | undefined;
"onEscape-press"?: (() => any) | undefined;
"onReset-template"?: (() => any) | undefined;
"onFiles-selected"?: ((files: File[]) => any) | undefined;
}>, {
placeholder: string;
mode: InputMode;
submitType: SubmitTrigger;
}, {}, {}, {}, string, ComponentProvideOptions, false, {
senderRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly modelValue?: string | undefined;
readonly defaultValue?: string | undefined;
readonly placeholder?: string | undefined;
readonly disabled?: boolean | undefined;
readonly loading?: boolean | undefined;
readonly autofocus?: boolean | undefined;
readonly enterkeyhint?: EnterKeyHint | undefined;
readonly mode?: InputMode | undefined;
readonly autoSize?: AutoSize | undefined;
readonly maxLength?: number | undefined;
readonly showWordLimit?: boolean | undefined;
readonly clearable?: boolean | undefined;
readonly extensions?: Extension[] | any[] | undefined;
readonly size?: "normal" | "small" | undefined;
readonly stopText?: string | undefined;
readonly defaultActions?: DefaultActions | undefined;
readonly submitType?: SubmitTrigger | undefined;
readonly onClear?: (() => any) | undefined;
readonly onInput?: ((value: string) => any) | undefined;
readonly onBlur?: ((event: FocusEvent) => any) | undefined;
readonly onCancel?: (() => any) | undefined;
readonly onFocus?: ((event: FocusEvent) => any) | undefined;
readonly onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: ((event: "clear") => void) & ((event: "input", value: string) => void) & ((event: "blur", event: FocusEvent) => void) & ((event: "cancel") => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "submit", textContent: string, structuredData?: StructuredData | undefined) => void) & ((event: "update:modelValue", value: string) => void);
$el: HTMLDivElement;
$options: ComponentOptionsBase<Readonly<SenderProps> & Readonly<{
onClear?: (() => any) | undefined;
onInput?: ((value: string) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
onCancel?: (() => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
submit: () => void;
clear: () => void;
cancel: () => void;
focus: () => void;
blur: () => void;
setContent: (content: string) => void;
getContent: () => string;
editor: SenderContext["editor"];
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
clear: () => any;
input: (value: string) => any;
blur: (event: FocusEvent) => any;
cancel: () => any;
focus: (event: FocusEvent) => any;
submit: (textContent: string, structuredData?: StructuredData | undefined) => any;
"update:modelValue": (value: string) => any;
}, string, {
size: "normal" | "small";
placeholder: string;
mode: InputMode;
enterkeyhint: EnterKeyHint;
autoSize: AutoSize;
extensions: Extension[] | any[];
submitType: SubmitTrigger;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
size: "normal" | "small";
placeholder: string;
mode: InputMode;
enterkeyhint: EnterKeyHint;
autoSize: AutoSize;
extensions: Extension[] | any[];
submitType: SubmitTrigger;
}> & Omit<Readonly<SenderProps> & Readonly<{
onClear?: (() => any) | undefined;
onInput?: ((value: string) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
onCancel?: (() => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, "clear" | "blur" | "cancel" | "focus" | "submit" | "editor" | "setContent" | ("size" | "placeholder" | "mode" | "enterkeyhint" | "autoSize" | "extensions" | "submitType") | "getContent"> & ShallowUnwrapRef<    {
submit: () => void;
clear: () => void;
cancel: () => void;
focus: () => void;
blur: () => void;
setContent: (content: string) => void;
getContent: () => string;
editor: SenderContext["editor"];
}> & {} & ComponentCustomProperties & {} & {
$slots: {
header?(_: {}): any;
header?(_: {}): any;
prefix?(_: {}): any;
prefix?(_: {}): any;
content?(_: {
editor: Editor | undefined;
}): any;
content?(_: {
editor: Ref<Editor | undefined, Editor | undefined>;
}): any;
'actions-inline'?(_: {}): any;
footer?(_: {}): any;
'footer-right'?(_: {}): any;
};
}) | null;
voiceRef: ({
$: ComponentInternalInstance;
$data: {};
$props: {
readonly icon?: (VNode | Component) | undefined;
readonly recordingIcon?: (VNode | Component) | undefined;
readonly disabled?: boolean | undefined;
readonly size?: "small" | "normal" | undefined;
readonly tooltip?: TooltipContent | undefined;
readonly tooltipPlacement?: TooltipPlacement | undefined;
readonly speechConfig?: SpeechConfig | undefined;
readonly autoInsert?: boolean | undefined;
readonly onButtonClick?: ((isRecording: boolean, preventDefault: () => void) => void | Promise<void>) | undefined;
readonly "onSpeech-start"?: (() => any) | undefined;
readonly "onSpeech-interim"?: ((transcript: string) => any) | undefined;
readonly "onSpeech-final"?: ((transcript: string) => any) | undefined;
readonly "onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
readonly "onSpeech-error"?: ((error: Error) => any) | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps;
$attrs: {
[x: string]: unknown;
};
$refs: {
[x: string]: unknown;
};
$slots: Readonly<{
[name: string]: Slot<any> | undefined;
}>;
$root: ComponentPublicInstance | null;
$parent: ComponentPublicInstance | null;
$host: Element | null;
$emit: ((event: "speech-start") => void) & ((event: "speech-interim", transcript: string) => void) & ((event: "speech-final", transcript: string) => void) & ((event: "speech-end", transcript?: string | undefined) => void) & ((event: "speech-error", error: Error) => void);
$el: any;
$options: ComponentOptionsBase<Readonly<VoiceButtonProps> & Readonly<{
"onSpeech-start"?: (() => any) | undefined;
"onSpeech-interim"?: ((transcript: string) => any) | undefined;
"onSpeech-final"?: ((transcript: string) => any) | undefined;
"onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
"onSpeech-error"?: ((error: Error) => any) | undefined;
}>, {
start: () => void;
stop: () => void;
speechState: SpeechState;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"speech-start": () => any;
"speech-interim": (transcript: string) => any;
"speech-final": (transcript: string) => any;
"speech-end": (transcript?: string | undefined) => any;
"speech-error": (error: Error) => any;
}, string, {
tooltipPlacement: TooltipPlacement;
autoInsert: boolean;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
beforeCreate?: (() => void) | (() => void)[];
created?: (() => void) | (() => void)[];
beforeMount?: (() => void) | (() => void)[];
mounted?: (() => void) | (() => void)[];
beforeUpdate?: (() => void) | (() => void)[];
updated?: (() => void) | (() => void)[];
activated?: (() => void) | (() => void)[];
deactivated?: (() => void) | (() => void)[];
beforeDestroy?: (() => void) | (() => void)[];
beforeUnmount?: (() => void) | (() => void)[];
destroyed?: (() => void) | (() => void)[];
unmounted?: (() => void) | (() => void)[];
renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
};
$forceUpdate: () => void;
$nextTick: nextTick;
$watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
} & Readonly<{
tooltipPlacement: TooltipPlacement;
autoInsert: boolean;
}> & Omit<Readonly<VoiceButtonProps> & Readonly<{
"onSpeech-start"?: (() => any) | undefined;
"onSpeech-interim"?: ((transcript: string) => any) | undefined;
"onSpeech-final"?: ((transcript: string) => any) | undefined;
"onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
"onSpeech-error"?: ((error: Error) => any) | undefined;
}>, "stop" | "start" | "speechState" | ("tooltipPlacement" | "autoInsert")> & ShallowUnwrapRef<    {
start: () => void;
stop: () => void;
speechState: SpeechState;
}> & {} & ComponentCustomProperties & {} & {
$slots: {
icon?(_: {
isRecording: boolean;
}): any;
'recording-overlay'?(_: {
isRecording: boolean;
stop: () => void;
}): any;
};
}) | null;
}, HTMLDivElement>;

declare const __VLS_component_9: DefineComponent<SuggestionPillButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<SuggestionPillButtonProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;

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

declare type __VLS_Props = ContainerProps;

declare type __VLS_Props_2 = DropdownMenuProps;

declare type __VLS_Props_3 = SuggestionPillsProps;

declare type __VLS_Props_4 = SuggestionPopoverProps;

declare type __VLS_Props_5 = ThemeProviderProps;

declare type __VLS_Props_6 = McpServerPickerProps;

declare type __VLS_PublicProps = {
    'show': ContainerProps['show'];
    'fullscreen'?: ContainerProps['fullscreen'];
} & __VLS_Props;

declare type __VLS_PublicProps_2 = {
    'show'?: boolean;
} & __VLS_Props_2;

declare type __VLS_PublicProps_3 = {
    'showAll'?: SuggestionPillsProps['showAll'];
} & __VLS_Props_3;

declare type __VLS_PublicProps_4 = {
    'selectedGroup'?: string;
} & __VLS_Props_4;

declare type __VLS_PublicProps_5 = {
    'theme'?: string;
    'colorMode'?: ColorMode;
} & __VLS_Props_5;

declare type __VLS_PublicProps_6 = {
    'visible': boolean;
} & __VLS_Props_6;

declare function __VLS_template(): {
    attrs: Partial<{}>;
    slots: Readonly<BubbleSlots> & BubbleSlots;
    refs: {
        bubbleRef: HTMLDivElement;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_10(): {
    attrs: Partial<{}>;
    slots: Readonly<SuggestionPillsSlots> & SuggestionPillsSlots;
    refs: {
        containerWrapperRef: HTMLDivElement;
        containerRef: HTMLDivElement;
        staticMaybeItemRefs: unknown[];
        floatingItemsRef: HTMLDivElement;
        floatingMaybeItemRefs: unknown[];
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_11(): {
    attrs: Partial<{}>;
    slots: Readonly<SuggestionPopoverSlots> & SuggestionPopoverSlots;
    refs: {
        basePopperRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly appendTo?: (string | HTMLElement) | undefined;
                readonly offset?: number | {
                    mainAxis?: number;
                    crossAxis?: number;
                } | undefined;
                readonly placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | undefined;
                readonly preventOverflow?: boolean | undefined;
                readonly show?: boolean | undefined;
                readonly transitionProps?: TransitionProps | undefined;
                readonly triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>> | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: any;
            $options: ComponentOptionsBase<Readonly<{
            appendTo?: string | HTMLElement;
            offset?: number | {
            mainAxis?: number;
            crossAxis?: number;
            };
            placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
            preventOverflow?: boolean;
            show?: boolean;
            transitionProps?: TransitionProps;
            triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
            }> & Readonly<{}>, {
            triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
            popperRef: ComputedRef<HTMLDivElement | null>;
            update: () => void;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
            placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
        }> & Omit<Readonly<{
            appendTo?: string | HTMLElement;
            offset?: number | {
                mainAxis?: number;
                crossAxis?: number;
            };
            placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
            preventOverflow?: boolean;
            show?: boolean;
            transitionProps?: TransitionProps;
            triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
        }> & Readonly<{}>, "placement" | "popperRef" | "update" | "triggerRef"> & ShallowUnwrapRef<    {
        triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
        popperRef: ComputedRef<HTMLDivElement | null>;
        update: () => void;
        }> & {} & ComponentCustomProperties & {} & {
            $slots: Readonly<{
                trigger?: () => VNode[];
                content?: () => VNode[];
            }> & {
                trigger?: () => VNode[];
                content?: () => VNode[];
            };
        }) | null;
        listRef: HTMLUListElement;
        tooltipRef: CreateComponentPublicInstanceWithMixins<Readonly<{
        show?: TooltipContentProps["show"];
        } & TooltipContentProps> & Readonly<{
        "onUpdate:show"?: ((value: boolean | undefined) => any) | undefined;
        }>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
        "update:show": (value: boolean | undefined) => any;
        }, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
        }, Readonly<{
        show?: TooltipContentProps["show"];
        } & TooltipContentProps> & Readonly<{
        "onUpdate:show"?: ((value: boolean | undefined) => any) | undefined;
        }>, {}, {}, {}, {}, {}> | null;
    };
    rootEl: any;
};

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

declare function __VLS_template_13(): {
    attrs: Partial<{}>;
    slots: Readonly<WelcomeSlots> & WelcomeSlots;
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_14(): {
    attrs: Partial<{}>;
    slots: {
        'header-actions'?(_: {}): any;
    };
    refs: {};
    rootEl: any;
};

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

declare function __VLS_template_16(): {
    attrs: Partial<{}>;
    slots: {
        icon?(_: {
            isRecording: boolean;
        }): any;
        'recording-overlay'?(_: {
            isRecording: boolean;
            stop: () => void;
        }): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_2(): {
    attrs: Partial<{}>;
    slots: Readonly<BubbleListSlots> & BubbleListSlots;
    refs: {
        listRef: HTMLDivElement;
    };
    rootEl: HTMLDivElement;
};

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

declare function __VLS_template_4(): {
    attrs: Partial<{}>;
    slots: Readonly<ContainerSlots> & ContainerSlots;
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_5(): {
    attrs: Partial<{}>;
    slots: {
        overlay?(_: {
            isDragging: true;
        }): any;
    };
    refs: {};
    rootEl: any;
};

declare function __VLS_template_6(): {
    attrs: Partial<{}>;
    slots: {
        trigger?(_: {}): any;
    };
    refs: {
        basePopperRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly appendTo?: (string | HTMLElement) | undefined;
                readonly offset?: number | {
                    mainAxis?: number;
                    crossAxis?: number;
                } | undefined;
                readonly placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | undefined;
                readonly preventOverflow?: boolean | undefined;
                readonly show?: boolean | undefined;
                readonly transitionProps?: TransitionProps | undefined;
                readonly triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>> | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: (event: string, ...args: any[]) => void;
            $el: any;
            $options: ComponentOptionsBase<Readonly<{
            appendTo?: string | HTMLElement;
            offset?: number | {
            mainAxis?: number;
            crossAxis?: number;
            };
            placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
            preventOverflow?: boolean;
            show?: boolean;
            transitionProps?: TransitionProps;
            triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
            }> & Readonly<{}>, {
            triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
            popperRef: ComputedRef<HTMLDivElement | null>;
            update: () => void;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
            placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            placement: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
        }> & Omit<Readonly<{
            appendTo?: string | HTMLElement;
            offset?: number | {
                mainAxis?: number;
                crossAxis?: number;
            };
            placement?: "top-center" | "bottom-center" | "top-left" | "top-right" | "bottom-left" | "bottom-right";
            preventOverflow?: boolean;
            show?: boolean;
            transitionProps?: TransitionProps;
            triggerEvents?: Partial<Record<`on${Capitalize<string>}`, (...args: any[]) => void>>;
        }> & Readonly<{}>, "placement" | "popperRef" | "update" | "triggerRef"> & ShallowUnwrapRef<    {
        triggerRef: ComputedRef<HTMLElement | SVGElement | null | undefined>;
        popperRef: ComputedRef<HTMLDivElement | null>;
        update: () => void;
        }> & {} & ComponentCustomProperties & {} & {
            $slots: Readonly<{
                trigger?: () => VNode[];
                content?: () => VNode[];
            }> & {
                trigger?: () => VNode[];
                content?: () => VNode[];
            };
        }) | null;
    };
    rootEl: any;
};

declare function __VLS_template_7(): {
    attrs: Partial<{}>;
    slots: Readonly<PromptsSlots> & PromptsSlots;
    refs: {};
    rootEl: HTMLDivElement;
};

declare function __VLS_template_8(): {
    attrs: Partial<{}>;
    slots: {
        header?(_: {}): any;
        prefix?(_: {}): any;
        content?(_: {
            editor: Ref<Editor | undefined, Editor | undefined>;
        }): any;
        actions?(_: {}): any;
        'footer-left'?(_: {}): any;
        footer?(_: {}): any;
        'footer-right'?(_: {}): any;
    };
    refs: {
        senderRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly modelValue?: string | undefined;
                readonly defaultValue?: string | undefined;
                readonly placeholder?: string | undefined;
                readonly disabled?: boolean | undefined;
                readonly loading?: boolean | undefined;
                readonly autofocus?: boolean | undefined;
                readonly enterkeyhint?: EnterKeyHint | undefined;
                readonly mode?: InputMode | undefined;
                readonly autoSize?: AutoSize | undefined;
                readonly maxLength?: number | undefined;
                readonly showWordLimit?: boolean | undefined;
                readonly clearable?: boolean | undefined;
                readonly extensions?: Extension[] | any[] | undefined;
                readonly size?: "normal" | "small" | undefined;
                readonly stopText?: string | undefined;
                readonly defaultActions?: DefaultActions | undefined;
                readonly submitType?: SubmitTrigger | undefined;
                readonly onClear?: (() => any) | undefined;
                readonly onInput?: ((value: string) => any) | undefined;
                readonly onBlur?: ((event: FocusEvent) => any) | undefined;
                readonly onCancel?: (() => any) | undefined;
                readonly onFocus?: ((event: FocusEvent) => any) | undefined;
                readonly onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
                readonly "onUpdate:modelValue"?: ((value: string) => any) | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "clear") => void) & ((event: "input", value: string) => void) & ((event: "blur", event: FocusEvent) => void) & ((event: "cancel") => void) & ((event: "focus", event: FocusEvent) => void) & ((event: "submit", textContent: string, structuredData?: StructuredData | undefined) => void) & ((event: "update:modelValue", value: string) => void);
            $el: HTMLDivElement;
            $options: ComponentOptionsBase<Readonly<SenderProps> & Readonly<{
            onClear?: (() => any) | undefined;
            onInput?: ((value: string) => any) | undefined;
            onBlur?: ((event: FocusEvent) => any) | undefined;
            onCancel?: (() => any) | undefined;
            onFocus?: ((event: FocusEvent) => any) | undefined;
            onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
            }>, {
            submit: () => void;
            clear: () => void;
            cancel: () => void;
            focus: () => void;
            blur: () => void;
            setContent: (content: string) => void;
            getContent: () => string;
            editor: SenderContext["editor"];
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
            clear: () => any;
            input: (value: string) => any;
            blur: (event: FocusEvent) => any;
            cancel: () => any;
            focus: (event: FocusEvent) => any;
            submit: (textContent: string, structuredData?: StructuredData | undefined) => any;
            "update:modelValue": (value: string) => any;
            }, string, {
            size: "normal" | "small";
            placeholder: string;
            mode: InputMode;
            enterkeyhint: EnterKeyHint;
            autoSize: AutoSize;
            extensions: Extension[] | any[];
            submitType: SubmitTrigger;
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            size: "normal" | "small";
            placeholder: string;
            mode: InputMode;
            enterkeyhint: EnterKeyHint;
            autoSize: AutoSize;
            extensions: Extension[] | any[];
            submitType: SubmitTrigger;
        }> & Omit<Readonly<SenderProps> & Readonly<{
            onClear?: (() => any) | undefined;
            onInput?: ((value: string) => any) | undefined;
            onBlur?: ((event: FocusEvent) => any) | undefined;
            onCancel?: (() => any) | undefined;
            onFocus?: ((event: FocusEvent) => any) | undefined;
            onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
        }>, "clear" | "blur" | "cancel" | "focus" | "submit" | "editor" | "setContent" | ("size" | "placeholder" | "mode" | "enterkeyhint" | "autoSize" | "extensions" | "submitType") | "getContent"> & ShallowUnwrapRef<    {
        submit: () => void;
        clear: () => void;
        cancel: () => void;
        focus: () => void;
        blur: () => void;
        setContent: (content: string) => void;
        getContent: () => string;
        editor: SenderContext["editor"];
        }> & {} & ComponentCustomProperties & {} & {
            $slots: {
                header?(_: {}): any;
                header?(_: {}): any;
                prefix?(_: {}): any;
                prefix?(_: {}): any;
                content?(_: {
                    editor: Editor | undefined;
                }): any;
                content?(_: {
                    editor: Ref<Editor | undefined, Editor | undefined>;
                }): any;
                'actions-inline'?(_: {}): any;
                footer?(_: {}): any;
                'footer-right'?(_: {}): any;
            };
        }) | null;
        voiceRef: ({
            $: ComponentInternalInstance;
            $data: {};
            $props: {
                readonly icon?: (VNode | Component) | undefined;
                readonly recordingIcon?: (VNode | Component) | undefined;
                readonly disabled?: boolean | undefined;
                readonly size?: "small" | "normal" | undefined;
                readonly tooltip?: TooltipContent | undefined;
                readonly tooltipPlacement?: TooltipPlacement | undefined;
                readonly speechConfig?: SpeechConfig | undefined;
                readonly autoInsert?: boolean | undefined;
                readonly onButtonClick?: ((isRecording: boolean, preventDefault: () => void) => void | Promise<void>) | undefined;
                readonly "onSpeech-start"?: (() => any) | undefined;
                readonly "onSpeech-interim"?: ((transcript: string) => any) | undefined;
                readonly "onSpeech-final"?: ((transcript: string) => any) | undefined;
                readonly "onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
                readonly "onSpeech-error"?: ((error: Error) => any) | undefined;
            } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: Slot<any> | undefined;
            }>;
            $root: ComponentPublicInstance | null;
            $parent: ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "speech-start") => void) & ((event: "speech-interim", transcript: string) => void) & ((event: "speech-final", transcript: string) => void) & ((event: "speech-end", transcript?: string | undefined) => void) & ((event: "speech-error", error: Error) => void);
            $el: any;
            $options: ComponentOptionsBase<Readonly<VoiceButtonProps> & Readonly<{
            "onSpeech-start"?: (() => any) | undefined;
            "onSpeech-interim"?: ((transcript: string) => any) | undefined;
            "onSpeech-final"?: ((transcript: string) => any) | undefined;
            "onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
            "onSpeech-error"?: ((error: Error) => any) | undefined;
            }>, {
            start: () => void;
            stop: () => void;
            speechState: SpeechState;
            }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
            "speech-start": () => any;
            "speech-interim": (transcript: string) => any;
            "speech-final": (transcript: string) => any;
            "speech-end": (transcript?: string | undefined) => any;
            "speech-error": (error: Error) => any;
            }, string, {
            tooltipPlacement: TooltipPlacement;
            autoInsert: boolean;
            }, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                renderTriggered?: ((e: DebuggerEvent) => void) | ((e: DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, OnCleanup]) => any : (...args: [any, any, OnCleanup]) => any, options?: WatchOptions): WatchStopHandle;
        } & Readonly<{
            tooltipPlacement: TooltipPlacement;
            autoInsert: boolean;
        }> & Omit<Readonly<VoiceButtonProps> & Readonly<{
            "onSpeech-start"?: (() => any) | undefined;
            "onSpeech-interim"?: ((transcript: string) => any) | undefined;
            "onSpeech-final"?: ((transcript: string) => any) | undefined;
            "onSpeech-end"?: ((transcript?: string | undefined) => any) | undefined;
            "onSpeech-error"?: ((error: Error) => any) | undefined;
        }>, "stop" | "start" | "speechState" | ("tooltipPlacement" | "autoInsert")> & ShallowUnwrapRef<    {
        start: () => void;
        stop: () => void;
        speechState: SpeechState;
        }> & {} & ComponentCustomProperties & {} & {
            $slots: {
                icon?(_: {
                    isRecording: boolean;
                }): any;
                'recording-overlay'?(_: {
                    isRecording: boolean;
                    stop: () => void;
                }): any;
            };
        }) | null;
    };
    rootEl: HTMLDivElement;
};

declare function __VLS_template_9(): {
    attrs: Partial<{}>;
    slots: Readonly<SuggestionPillButtonSlots> & SuggestionPillButtonSlots;
    refs: {};
    rootEl: HTMLButtonElement;
};

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;
    };
};

declare interface ActionButton_2 {
    type: string;
    label: string;
    handler?: (file: Attachment) => void;
}

/**
 * ActionButton Props
 *
 * 基础操作按钮的 Props
 */
export declare interface ActionButtonProps {
    /**
     * 按钮图标
     */
    icon: VNode | Component;
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 是否激活状态
     */
    active?: boolean;
    /**
     * 工具提示
     */
    tooltip?: TooltipContent;
    /**
     * Tooltip 位置
     */
    tooltipPlacement?: TooltipPlacement;
    /**
     * 按钮大小
     */
    size?: string | number;
}

export declare type AddType = 'form' | 'code';

export declare type Attachment = UrlAttachment | RawFileAttachment;

export declare interface AttachmentListEmits {
    (e: 'update:items', items: Attachment[]): void;
    (e: 'remove', file: Attachment): void;
    (e: 'download', event: MouseEvent, file: Attachment): void;
    (e: 'retry', file: Attachment): void;
    (e: 'preview', event: MouseEvent, file: Attachment): void;
    (e: 'action', payload: {
        action: ActionButton_2;
        file: Attachment;
    }): void;
}

export declare interface AttachmentListProps {
    items?: Attachment[];
    disabled?: boolean;
    wrap?: boolean;
    fileIcons?: Record<string, Component>;
    actions?: ActionButton_2[];
    variant?: DisplayVariant;
    fileMatchers?: FileTypeMatcher[];
}

/**
 * 自动高度配置
 */
export declare type AutoSize = boolean | {
    minRows: number;
    maxRows: number;
};

export declare interface BaseAttachment {
    id?: string;
    name?: string;
    status?: FileStatus;
    fileType?: FileType;
    message?: string;
}

declare type BaseCardProps = Pick<AttachmentListProps, 'fileIcons' | 'disabled' | 'actions' | 'fileMatchers'>;

export declare type BaseFileType = 'image' | 'pdf' | 'word' | 'excel' | 'ppt' | 'folder' | 'other';

declare const Bubble: typeof _default_25 & {
    install: typeof bubbleInstall;
};
export { Bubble }
export { Bubble as TrBubble }

export declare type BubbleBoxRendererMatch = {
    /**
     * 匹配函数，用于判断是否应该使用此渲染器
     * @param messages - 消息数组
     * @param content - 要渲染的内容项。仅在 `split` 模式下（contentIndex 为数字）才会传入；为当前消息（messages[0]）经过 `contentResolver` 解析后的内容；`messages[0].content` 一定是一个数组，`content` 则为对应索引的内容项，即 `messages[0].content[contentIndex]`；当 contentIndex 为 undefined 时，content 也为 undefined
     * @param contentIndex - 内容索引，用于指定要渲染的内容项。仅在 split 模式下才会传入（为数字），此时 messages 数组长度为 1
     * @returns 如果匹配则返回 true，否则返回 false
     */
    find: (messages: BubbleMessage[], content: ChatMessageContentItem | undefined, contentIndex: number | undefined) => boolean;
    renderer: Component<BubbleBoxRendererProps>;
    priority?: number;
    attributes?: Record<string, string>;
};

export declare type BubbleBoxRendererProps = Pick<BubbleProps, 'placement' | 'shape'>;

export declare type BubbleContentRendererMatch = {
    /**
     * 匹配函数，用于判断是否应该使用此渲染器
     * @param message - 消息对象
     * @param content - 要渲染的内容项。为当前消息经过 contentResolver 解析并统一化后的内容项：若解析结果为数组，则取对应索引的内容项（由 contentIndex 指定）；若为字符串，则转为 { type: 'text', text: string }。统一化为 ChatMessageContentItem 对象格式
     * @param contentIndex - 内容索引。由 contentResolver 的解析结果为数组时使用。若 contentResolver 解析结果为字符串，content 会转换为对象，此时 contentIndex 为 0
     * @returns 如果匹配则返回 true，否则返回 false
     */
    find: (message: BubbleMessage, content: ChatMessageContentItem, contentIndex: number) => boolean;
    renderer: Component<BubbleContentRendererProps>;
    priority?: number;
    attributes?: Record<string, string>;
};

export declare type BubbleContentRendererProps<T extends ChatMessageContent = ChatMessageContent, S extends Record<string, unknown> = Record<string, unknown>> = {
    message: BubbleMessage<T, S>;
    contentIndex: number;
};

/**
 * 自定义分组函数类型
 */
declare type BubbleGroupFunction = (messages: BubbleMessage[], dividerRole?: string) => BubbleMessageGroup[];

declare const bubbleInstall: (app: App) => void;

declare const BubbleList: typeof _default_26 & {
    install: typeof bubbleListInstall;
};
export { BubbleList }
export { BubbleList as TrBubbleList }

declare const bubbleListInstall: (app: App) => void;

export declare interface BubbleListProps {
    messages: BubbleMessage[];
    /**
     * 分组策略：
     * - 'consecutive': 连续相同角色的消息合并为一组
     * - 'divider': 按分割角色分组（每条分割角色消息单独成组，其他消息在两个分割角色之间合并为一组）
     * - 自定义函数: (messages, dividerRole) => BubbleMessageGroup[]
     *
     * 特殊情况：
     * - hidden 的消息需要单独分组，连续的 hidden 可以同一组
     */
    groupStrategy?: 'consecutive' | 'divider' | BubbleGroupFunction;
    /**
     * 'divider' 策略的分割角色
     * 具有此角色的消息将作为分割线
     * @default 'user'
     */
    dividerRole?: string;
    /**
     * 当消息没有角色或角色为空时，使用此角色
     * @default 'assistant'
     */
    fallbackRole?: string;
    /**
     * 角色配置（头像、位置、形状）
     */
    roleConfigs?: Record<string, BubbleRoleConfig>;
    contentRenderMode?: BubbleProps['contentRenderMode'];
    contentResolver?: BubbleProps['contentResolver'];
    /**
     * 是否自动滚动到底部。需要满足以下条件：
     * - BubbleList 是可滚动容器（需要 scrollHeight > clientHeight）
     * - 滚动容器接近底部
     *
     * @default false
     */
    autoScroll?: boolean;
}

declare type BubbleListSlotProps = BubbleSlotProps & {
    messageIndexes: number[];
};

export declare interface BubbleListSlots {
    prefix?: (slotProps: BubbleListSlotProps) => VNode | VNode[];
    suffix?: (slotProps: BubbleListSlotProps) => VNode | VNode[];
    after?: (slotProps: BubbleListSlotProps) => VNode | VNode[];
    'content-footer'?: (slotProps: BubbleListSlotProps & {
        contentIndex?: number;
    }) => VNode | VNode[];
}

export declare type BubbleMessage<T extends ChatMessageContent = ChatMessageContent, S extends Record<string, unknown> = Record<string, unknown>> = ChatMessageWithOptionalRole<T> & {
    id?: string;
    loading?: boolean;
    state?: S;
};

export declare type BubbleMessageGroup = {
    role: string;
    messages: BubbleMessage[];
    messageIndexes: number[];
    startIndex: number;
};

export declare type BubbleProps = BubbleMessage & {
    hidden?: boolean;
    avatar?: VNode | Component;
    placement?: 'start' | 'end';
    shape?: 'corner' | 'rounded' | 'none';
    contentRenderMode?: 'single' | 'split';
    contentResolver?: (message: BubbleMessage) => ChatMessageContent | undefined;
    fallbackBoxRenderer?: Component<BubbleBoxRendererProps>;
    fallbackContentRenderer?: Component<BubbleContentRendererProps>;
};

declare const BubbleProvider: typeof _default_27 & {
    install: typeof bubbleProviderInstall;
};
export { BubbleProvider }
export { BubbleProvider as TrBubbleProvider }

declare const bubbleProviderInstall: (app: App) => void;

export declare interface BubbleProviderProps {
    boxRendererMatches?: BubbleBoxRendererMatch[];
    contentRendererMatches?: BubbleContentRendererMatch[];
    fallbackBoxRenderer?: Component<BubbleBoxRendererProps>;
    fallbackContentRenderer?: Component<BubbleContentRendererProps>;
    store?: Record<string, unknown>;
}

/**
 * 气泡渲染器匹配优先级常量
 *
 * 用于定义不同类型渲染器的匹配优先级，数值越小优先级越高
 *
 * - LOADING: 通常基于 message.loading 判断。比如: `{ loading: true }`
 * - NORMAL: 普通渲染器的默认优先级
 * - CONTENT: 通常基于 message.content 判断。比如: `{ content: [{ type: 'image_url', image_url: 'xxx' }] }`
 * - ROLE: 通常基于 message.role 判断。比如: `{ role: 'tool' }`
 */
export declare const BubbleRendererMatchPriority: {
    readonly LOADING: -1;
    readonly NORMAL: 0;
    readonly CONTENT: 10;
    readonly ROLE: 20;
};

export declare const BubbleRenderers: {
    Box: {
        new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<BubbleBoxRendererProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {}, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
        }, Readonly<BubbleBoxRendererProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & ComponentOptionsBase<Readonly<BubbleBoxRendererProps> & Readonly<{}>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    });
    Image: DefineComponent<    {
    message: BubbleMessage<ChatMessageContentItem[], Record<string, unknown>>;
    contentIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
    message: BubbleMessage<ChatMessageContentItem[], Record<string, unknown>>;
    contentIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLImageElement>;
    Loading: DefineComponent<    {
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;
    Markdown: DefineComponent<    {
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
    Reasoning: DefineComponent<    {
    message: BubbleMessage<ChatMessageContent, {
    thinking?: boolean;
    open?: boolean;
    }>;
    contentIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
    message: BubbleMessage<ChatMessageContent, {
    thinking?: boolean;
    open?: boolean;
    }>;
    contentIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
    detailRef: HTMLParagraphElement;
    }, any>;
    Text: DefineComponent<    {
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
    Tool: DefineComponent<BubbleContentRendererProps<ChatMessageContent, {
    toolCall?: Record<string, {
    status?: ToolCallStatus;
    open?: boolean;
    }>;
    }> & {
    toolCallIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<BubbleContentRendererProps<ChatMessageContent, {
    toolCall?: Record<string, {
    status?: ToolCallStatus;
    open?: boolean;
    }>;
    }> & {
    toolCallIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {
    detailRef: HTMLDivElement;
    }, HTMLDivElement>;
    ToolRole: DefineComponent<    {
    message: BubbleMessage<string, Record<string, unknown>>;
    contentIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
    message: BubbleMessage<string, Record<string, unknown>>;
    contentIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
    Tools: DefineComponent<    {
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{
    message: BubbleMessage<ChatMessageContent, Record<string, unknown>>;
    contentIndex: number;
    }> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
};

/**
 * 角色配置
 * 用于配置不同角色的气泡样式
 */
export declare type BubbleRoleConfig = Pick<BubbleProps, 'avatar' | 'placement' | 'shape' | 'hidden' | 'fallbackBoxRenderer' | 'fallbackContentRenderer'>;

declare type BubbleSlotProps = {
    messages: BubbleMessage[];
    role?: string;
};

export declare interface BubbleSlots {
    prefix?: (slotProps: BubbleSlotProps) => VNode | VNode[];
    suffix?: (slotProps: BubbleSlotProps) => VNode | VNode[];
    after?: (slotProps: BubbleSlotProps) => VNode | VNode[];
    'content-footer'?: (slotProps: BubbleSlotProps & {
        contentIndex?: number;
    }) => VNode | VNode[];
}

declare interface ButtonGroupConfig {
    file?: ControlState & fileUploadConfig;
    submit?: ControlState;
    voice?: VoiceButtonConfig;
}

/**
 * 聊天消息接口（支持 OpenAI 格式）
 */
declare interface ChatMessage<T extends ChatMessageContent = ChatMessageContent> {
    role: string;
    content?: T;
    reasoning_content?: string;
    tool_calls?: ToolCall[];
    tool_call_id?: string;
    name?: string;
}

export declare type ChatMessageContent = string | ChatMessageContentItem[];

export declare type ChatMessageContentItem = {
    type: string;
    [key: string]: any;
};

declare type ChatMessageWithOptionalRole<T extends ChatMessageContent = ChatMessageContent> = Omit<ChatMessage<T>, 'role'> & {
    role?: string;
};

export declare type ColorMode = 'light' | 'dark' | 'auto';

declare interface CompatTemplateItem {
    id: string;
    type: 'template' | 'block';
    content: string;
}

declare interface CompatTextItem {
    id: string;
    type: 'text';
    content: string;
}

export declare interface ContainerEmits {
    (e: 'close'): void;
}

export declare interface ContainerProps {
    /**
     * model:show
     */
    show: boolean;
    /**
     * model:fullscreen
     */
    fullscreen?: boolean;
    title?: string;
}

export declare interface ContainerSlots {
    default: () => unknown;
    title: () => unknown;
    operations: () => unknown;
    footer: () => unknown;
}

declare interface ControlState {
    tooltips?: string | TooltipRender;
    disabled?: boolean;
    tooltipPlacement?: 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';
}

declare const _default: {
    install<T>(app: App<T>): void;
};
export default _default;

declare const _default_10: typeof _default_37 & {
    install: typeof install_9;
};
export { _default_10 as SenderCompat }
export { _default_10 as TrSenderCompat }

declare const _default_11: typeof _default_39 & {
    install: typeof install_10;
};
export { _default_11 as SuggestionPills }
export { _default_11 as TrSuggestionPills }

declare const _default_12: typeof _default_40 & {
    install: typeof install_11;
};
export { _default_12 as SuggestionPopover }
export { _default_12 as TrSuggestionPopover }

declare const _default_13: typeof _default_41 & {
    install: typeof install_12;
};
export { _default_13 as ThemeProvider }
export { _default_13 as TrThemeProvider }

declare const _default_14: typeof _default_42 & {
    install: typeof install_13;
};
export { _default_14 as TrWelcome }
export { _default_14 as Welcome }

declare const _default_15: typeof _default_43 & {
    install: typeof install_14;
};
export { _default_15 as McpServerPicker }
export { _default_15 as TrMcpServerPicker }

declare const _default_16: typeof _default_44 & {
    install: typeof install_15;
};
export { _default_16 as McpAddForm }
export { _default_16 as TrMcpAddForm }

declare const _default_17: __VLS_WithTemplateSlots_15<typeof __VLS_component_15, __VLS_TemplateResult_15["slots"]>;
export { _default_17 as ActionButton }
export { _default_17 as TrActionButton }

declare const _default_18: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { _default_18 as SubmitButton }
export { _default_18 as TrSubmitButton }

declare const _default_19: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { _default_19 as ClearButton }
export { _default_19 as TrClearButton }

declare const _default_2: typeof _default_24 & {
    install: typeof install;
};
export { _default_2 as Attachments }
export { _default_2 as TrAttachments }

declare const _default_20: DefineComponent<UploadButtonProps, {
open: (localOptions?: Partial<UseFileDialogOptions>) => void;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
error: (error: Error, files?: File[] | undefined) => any;
select: (files: File[]) => any;
}, string, PublicProps, Readonly<UploadButtonProps> & Readonly<{
onError?: ((error: Error, files?: File[] | undefined) => any) | undefined;
onSelect?: ((files: File[]) => any) | undefined;
}>, {
reset: boolean;
multiple: boolean;
tooltipPlacement: TooltipPlacement;
accept: string;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
export { _default_20 as TrUploadButton }
export { _default_20 as UploadButton }

declare const _default_21: __VLS_WithTemplateSlots_16<typeof __VLS_component_16, __VLS_TemplateResult_16["slots"]>;
export { _default_21 as TrVoiceButton }
export { _default_21 as VoiceButton }

declare const _default_22: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
export { _default_22 as TrWordCounter }
export { _default_22 as WordCounter }

declare const _default_23: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLDivElement>;
export { _default_23 as DefaultActionButtons }
export { _default_23 as TrDefaultActionButtons }

declare const _default_24: DefineComponent<AttachmentListProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
"update:items": (items: Attachment[]) => any;
remove: (file: Attachment) => any;
download: (event: MouseEvent, file: Attachment) => any;
retry: (file: Attachment) => any;
preview: (event: MouseEvent, file: Attachment) => any;
action: (payload: {
action: ActionButton_2;
file: Attachment;
}) => any;
}, string, PublicProps, Readonly<AttachmentListProps> & Readonly<{
"onUpdate:items"?: ((items: Attachment[]) => any) | undefined;
onRemove?: ((file: Attachment) => any) | undefined;
onDownload?: ((event: MouseEvent, file: Attachment) => any) | undefined;
onRetry?: ((file: Attachment) => any) | undefined;
onPreview?: ((event: MouseEvent, file: Attachment) => any) | undefined;
onAction?: ((payload: {
action: ActionButton_2;
file: Attachment;
}) => any) | undefined;
}>, {
actions: ActionButton_2[];
fileMatchers: FileTypeMatcher[];
variant: DisplayVariant;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

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

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

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

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

declare const _default_29: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const _default_3: typeof _default_28 & {
    install: typeof install_2;
};
export { _default_3 as Container }
export { _default_3 as TrContainer }

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

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

declare const _default_32: DefineComponent<FeedbackProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
action: (name: string) => any;
operation: (name: string) => any;
}, string, PublicProps, Readonly<FeedbackProps> & Readonly<{
onAction?: ((name: string) => any) | undefined;
onOperation?: ((name: string) => any) | undefined;
}>, {
operationsLimit: number;
actionsLimit: number;
sourcesLinesLimit: number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const _default_33: <T extends HistoryItem>(__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 "onItem-click"?: ((item: T) => any) | undefined;
        readonly "onItem-title-change"?: ((newTitle: string, item: T) => any) | undefined;
        readonly "onItem-action"?: ((action: HistoryMenuItem, item: T) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onItem-click" | "onItem-title-change" | "onItem-action"> & HistoryProps<T> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: Readonly<HistorySlots<T>> & HistorySlots<T>;
    emit: ((evt: "item-click", item: T) => void) & ((evt: "item-title-change", newTitle: string, item: T) => void) & ((evt: "item-action", action: HistoryMenuItem, item: T) => void);
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

declare const _default_34: DefineComponent<IconButtonProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<IconButtonProps> & Readonly<{}>, {
size: string | number;
svgSize: string | number;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLButtonElement>;

declare const _default_35: DefineComponent<PromptProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<PromptProps> & Readonly<{}>, {
size: "small" | "medium" | "large";
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

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

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

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

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

declare const _default_4: typeof _default_29 & {
    install: typeof install_3;
};
export { _default_4 as Conversations }
export { _default_4 as TrConversations }

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

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

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

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

declare const _default_44: DefineComponent<McpAddFormProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
cancel: () => any;
confirm: (type: AddType, data: string | McpAddFormData) => any;
"update:addType": (value: AddType) => any;
}, string, PublicProps, Readonly<McpAddFormProps> & Readonly<{
onCancel?: (() => any) | undefined;
onConfirm?: ((type: AddType, data: string | McpAddFormData) => any) | undefined;
"onUpdate:addType"?: ((value: AddType) => any) | undefined;
}>, {
addType: AddType;
}, {}, {}, {}, string, ComponentProvideOptions, false, {}, HTMLDivElement>;

declare const _default_5: typeof _default_30 & {
    install: typeof install_4;
};
export { _default_5 as DragOverlay }
export { _default_5 as TrDragOverlay }

declare const _default_6: typeof _default_31 & {
    install: typeof install_5;
};
export { _default_6 as DropdownMenu }
export { _default_6 as TrDropdownMenu }

declare const _default_7: typeof _default_32 & {
    install: typeof install_6;
};
export { _default_7 as Feedback }
export { _default_7 as TrFeedback }

declare const _default_8: typeof _default_33 & {
    install: typeof install_7;
};
export { _default_8 as History }
export { _default_8 as TrHistory }

declare const _default_9: typeof _default_34 & {
    install: typeof install_8;
};
export { _default_9 as IconButton }
export { _default_9 as TrIconButton }

/**
 * 默认操作按钮配置
 *
 * 用于统一配置 Sender 的默认按钮（Clear、Submit）
 *
 * @example
 * ```typescript
 * const defaultActions = {
 *   submit: { disabled: !isValid, tooltip: '请完善表单' },
 *   clear: { tooltip: '清空内容' }
 * }
 * ```
 */
export declare interface DefaultActions {
    /**
     * 提交按钮配置
     */
    submit?: {
        /**
         * 是否禁用
         */
        disabled?: boolean;
        /**
         * 工具提示
         * - string: 简单文本
         * - () => string | VNode: 渲染函数，支持复杂内容
         */
        tooltip?: TooltipContent;
        /**
         * Tooltip 位置
         */
        tooltipPlacement?: TooltipPlacement;
    };
    /**
     * 清空按钮配置
     */
    clear?: {
        /**
         * 是否禁用
         */
        disabled?: boolean;
        /**
         * 工具提示
         * - string: 简单文本
         * - () => string | VNode: 渲染函数，支持复杂内容
         */
        tooltip?: TooltipContent;
        /**
         * Tooltip 位置
         */
        tooltipPlacement?: TooltipPlacement;
    };
}

export declare type DisplayVariant = 'picture' | 'card' | 'auto';

declare interface DragAwareElement extends HTMLElement {
    __vDropzoneHandlers__?: Handlers;
    __vDropzoneOptions__?: DragAwareOptions;
}

declare type DragAwareOptions = Omit<DropzoneBinding, 'onDraggingChange'>;

/**
 * 拖拽上传组件的属性
 */
export declare interface DragOverlayProps {
    /**
     * 覆盖层标题
     * @default ''
     */
    overlayTitle?: string;
    /**
     * 覆盖层描述文本数组
     * @default []
     */
    overlayDescription?: string[];
    /**
     * 控制拖拽覆盖层是否可见。这旨在与 v-dropzone 指令结合使用，由父组件控制。
     * @default false
     */
    isDragging?: boolean;
    /**
     * @description 拖拽目标元素，用于定位覆盖层
     * @default null
     */
    dragTarget?: HTMLElement | null;
    /**
     * @description 是否全屏模式，控制覆盖层的边框显示
     * @default false
     */
    fullscreen?: boolean;
}

export declare interface DragOverlaySlots {
    /**
     * 覆盖层插槽，用于自定义拖拽时的覆盖层内容
     */
    overlay?: (props: {
        isDragging: boolean;
    }) => unknown;
}

/**
 * 拖拽区域错误码
 */
declare enum DragZoneErrorCode {
    /**
     * 文件类型不允许
     */
    FileTypeNotAllowed = "file-type-not-allowed",
    /**
     * 文件大小超出限制
     */
    FileSizeExceeded = "file-size-exceeded",
    /**
     * 文件数量超出限制
     */
    FileCountExceeded = "file-count-exceeded"
}

export declare interface DropdownMenuEmits {
    (e: 'item-click', item: DropdownMenuItem): void;
    /**
     * 点击外部区域时触发, 仅在 trigger 为 'click' 或 'manual' 时有效
     */
    (e: 'click-outside', event: MouseEvent): void;
}

export declare interface DropdownMenuEventProps {
    onItemClick?: (item: DropdownMenuItem) => void;
    onClickOutside?: (event: MouseEvent) => void;
}

export declare interface DropdownMenuEvents {
    /**
     * @deprecated
     */
    itemClick?: (item: DropdownMenuItem) => void;
    /**
     * @deprecated
     */
    clickOutside?: (event: MouseEvent) => void;
}

export declare interface DropdownMenuItem {
    id: string;
    text: string;
}

export declare interface DropdownMenuProps {
    appendTo?: string | HTMLElement;
    items: DropdownMenuItem[];
    /**
     * 当 trigger 为 'click' 或 'hover' 时，是一个双向绑定的 model(v-model:show)，可在组件外部控制显示状态。
     * 否则当 trigger 为 'manual' 时，是一个单向绑定的 prop，组件内部无法修改 show 的值
     */
    show?: boolean;
    /**
     * 触发方式。默认值为 'click'
     */
    trigger?: 'click' | 'hover' | 'manual';
}

export declare interface DropdownMenuSlots {
    trigger?: () => VNode | VNode[];
}

/**
 * 拖拽上传组件的属性
 */
export declare interface DropzoneBinding {
    /**
     * 允许上传的文件类型, 与原生 input 的 accept 属性一致
     * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input/file#accept
     * @example '.jpg,.png,image/*'
     */
    accept?: string;
    /**
     * 是否允许多选
     * @default true
     */
    multiple?: boolean;
    /**
     * 是否禁用拖拽
     * @default false
     */
    disabled?: boolean;
    /**
     * 单个文件的最大大小（单位：字节）
     * @default 10 * 1024 * 1024 (10MB)
     */
    maxSize?: number;
    /**
     * 允许上传的最大文件数量
     * @default 3
     */
    maxFiles?: number;
    /**
     * 拖拽完成后的回调
     * @param files 上传的文件
     */
    onDrop: (files: File[]) => void;
    /**
     * 拖拽失败后的回调
     * @param rejection 拒绝信息
     */
    onError: (rejection: FileRejection) => void;
    /**
     * 拖拽开始时的回调
     * @param dragging 是否正在拖拽
     * @param element 拖拽目标元素
     */
    onDraggingChange: (dragging: boolean, element: HTMLElement | null) => void;
}

/**
 * 移动端虚拟键盘回车键提示
 *
 * 用于自定义移动端虚拟键盘上回车键的显示文本或图标
 *
 * - `enter`: 插入换行
 * - `done`: 完成
 * - `go`: 前往
 * - `next`: 下一项
 * - `previous`: 上一项
 * - `search`: 搜索
 * - `send`: 发送（推荐用于聊天场景）
 *
 * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/enterkeyhint
 */
export declare type EnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';

export declare interface FeedbackEvents {
    (e: 'operation', name: string): void;
    (e: 'action', name: string): void;
}

export declare interface FeedbackProps {
    operations?: {
        name: string;
        label: string;
        onClick?: () => void;
    }[];
    operationsLimit?: number;
    actions?: {
        name: string;
        label: string;
        icon?: 'copy' | 'refresh' | 'like' | 'dislike' | VNode | Component;
        onClick?: () => void;
    }[];
    actionsLimit?: number;
    sources?: {
        label: string;
        link: string;
    }[];
    sourcesLinesLimit?: number;
}

export declare interface FileCardEmits {
    (e: 'remove', file: Attachment): void;
    (e: 'preview', event: MouseEvent, file: Attachment): void;
    (e: 'download', event: MouseEvent, file: Attachment): void;
    (e: 'retry', file: Attachment): void;
    (e: 'action', payload: {
        action: ActionButton_2;
        file: Attachment;
    }): void;
}

export declare interface FileCardProps extends BaseCardProps {
    file: Attachment;
    variant: 'picture' | 'card';
    showStatus?: boolean;
}

/**
 * 文件拒绝信息
 */
export declare interface FileRejection extends RejectionReason {
    files: File[];
}

export declare type FileStatus = 'uploading' | 'success' | 'error';

export declare type FileType = BaseFileType | string;

export declare interface FileTypeMatcher {
    type: string;
    matcher: (file: File | string) => boolean;
    icon?: Component;
}

declare interface fileUploadConfig {
    accept?: string;
    multiple?: boolean;
    reset?: boolean;
}

export declare interface Handlers {
    handleDragEnter: (e: DragEvent) => void;
    handleDragOver: (e: DragEvent) => void;
    handleDragLeave: (e: DragEvent) => void;
    handleDrop: (e: DragEvent) => void;
}

/**
 * 高亮函数类型
 *
 * @param suggestionText - 建议项文本
 * @param inputText - 用户输入文本
 * @returns 包含文本片段和匹配状态的数组
 */
export declare type HighlightFunction = (suggestionText: string, inputText: string) => SuggestionTextPart[];

declare type HighlightFunction_2 = (suggestionText: string, inputText: string) => SuggestionTextPart_2[];

export declare type HistoryData<T extends HistoryItem> = T[] | HistoryGroup<T>[];

export declare interface HistoryGroup<T extends HistoryItem> {
    group: string | symbol;
    items: T[];
}

export declare interface HistoryItem {
    id?: string;
    title: string;
    icon?: Component | VNode;
    [x: string]: any;
}

export declare interface HistoryMenuItem {
    id: string;
    text: string;
    icon?: Component | VNode;
}

export declare type HistoryProps<T extends HistoryItem = HistoryItem> = {
    data: HistoryData<T>;
    selected?: string;
    showRenameControls?: boolean;
    renameControlOnClickOutside?: 'confirm' | 'cancel' | 'none';
    menuItems?: HistoryMenuItem[];
    menuListGap?: number;
};

export declare interface HistorySlots<T extends HistoryItem = HistoryItem> {
    'item-prefix'?: (slotProps: {
        item: T;
    }) => VNode | VNode[];
    'item-title'?: (slotProps: {
        item: T;
    }) => VNode | VNode[];
}

export declare interface IconButtonProps {
    icon: VNode | Component;
    size?: string | number;
    svgSize?: string | number;
    rounded?: boolean;
}

/**
 * 输入模式
 * - single: 单行模式，适用于简短输入
 * - multiple: 多行模式，适用于长文本输入
 */
export declare type InputMode = 'single' | 'multiple';

declare const install: <T>(app: App<T>) => void;

declare const install_10: <T>(app: App<T>) => void;

declare const install_11: <T>(app: App<T>) => void;

declare const install_12: <T>(app: App<T>) => void;

declare const install_13: <T>(app: App<T>) => void;

declare const install_14: <T>(app: App<T>) => void;

declare const install_15: <T>(app: App<T>) => void;

declare const install_2: <T>(app: App<T>) => void;

declare const install_3: <T>(app: App<T>) => void;

declare const install_4: <T>(app: App<T>) => void;

declare const install_5: <T>(app: App<T>) => void;

declare const install_6: <T>(app: App<T>) => void;

declare const install_7: <T>(app: App<T>) => void;

declare const install_8: <T>(app: App<T>) => void;

declare const install_9: <T>(app: App<T>) => void;

declare const installPillButton: <T>(app: App<T>) => void;

declare const installPrompt: <T>(app: App<T>) => void;

declare const installPrompts: <T>(app: App<T>) => void;

declare interface ISuggestionItem {
    content: string;
    highlights?: string[] | HighlightFunction_2;
}

/**
 * 键盘处理器接口
 */
export declare interface KeyboardHandlers {
    checkSubmitShortcut: (event: KeyboardEvent) => boolean;
    checkNewlineShortcut: (event: KeyboardEvent) => boolean;
    submit: () => void;
}

export declare interface MarketCategoryOption {
    value: string;
    label: string;
}

export declare interface McpAddFormData {
    name: string;
    description: string;
    type: 'sse' | 'streamableHttp';
    url: string;
    headers: string;
    thumbnail?: File | null;
}

export declare interface McpAddFormEmits {
    (e: 'update:addType', value: AddType): void;
    (e: 'confirm', type: AddType, data: McpAddFormData | string): void;
    (e: 'cancel'): void;
}

export declare interface McpAddFormProps {
    addType?: AddType;
    formData?: McpAddFormData;
    codeData?: string;
}

export declare interface McpServerPickerEmits {
    (e: 'market-category-change', category: string): void;
    (e: 'tab-change', activeTab: 'installed' | 'market'): void;
    (e: 'plugin-toggle', plugin: PluginInfo, enabled: boolean): void;
    (e: 'plugin-delete', plugin: PluginInfo): void;
    (e: 'plugin-add', plugin: PluginInfo): void;
    (e: 'plugin-create', type: 'form' | 'code', data: PluginCreationData): void;
    (e: 'tool-toggle', plugin: PluginInfo, toolId: string, enabled: boolean): void;
    (e: 'refresh', tab: 'installed' | 'market'): void;
    (e: 'update:activeCount', count: number): void;
    (e: 'update:visible', visible: boolean): void;
}

export declare interface McpServerPickerProps {
    installedPlugins?: PluginInfo[];
    marketPlugins?: PluginInfo[];
    searchPlaceholder?: string;
    enableSearch?: boolean;
    installedSearchFn?: (query: string, item: PluginInfo) => boolean;
    marketSearchFn?: (query: string, item: PluginInfo) => boolean;
    marketCategoryOptions?: MarketCategoryOption[];
    marketCategoryPlaceholder?: string;
    enableMarketCategoryFilter?: boolean;
    defaultActiveTab?: 'installed' | 'market';
    showInstalledTab?: boolean;
    showMarketTab?: boolean;
    visible?: boolean;
    popupConfig?: PopupConfig;
    activeCount?: number;
    installedTabTitle?: string;
    marketTabTitle?: string;
    title?: string;
    showCustomAddButton?: boolean;
    customAddButtonText?: string;
    allowPluginToggle?: boolean;
    allowToolToggle?: boolean;
    allowPluginDelete?: boolean;
    allowPluginAdd?: boolean;
    loading?: boolean;
    marketLoading?: boolean;
}

/**
 * 创建 Mention 扩展的便捷函数
 *
 * @param items - 提及项列表
 * @param char - 触发字符，默认 '@'
 * @param options - 其他配置项
 *
 * @example
 * ```typescript
 * const extensions = [mention(items)]
 * const extensions = [mention(items, '#')]
 * const extensions = [mention(items, '@', { allowSpaces: true })]
 * ```
 */
declare function mention(items: MentionItem[] | Ref<MentionItem[]>, char?: string, options?: Partial<Omit<MentionOptions, 'items' | 'char'>>): Node_2<MentionOptions, any>;

/**
 * 提及项数据结构（用户侧）
 *
 * 用户传入的数据格式，id 可选，插件会自动生成
 */
export declare interface MentionItem {
    /**
     * 唯一标识（可选）
     *
     * 如果不提供，插件会自动生成
     */
    id?: string;
    /**
     * 显示名称，如 "小小画家"（必传）
     */
    label: string;
    /**
     * 关联值（必传）
     *
     * 可以是任意字符串值，如 AI 提示词、用户 ID、标签内容等
     */
    value: string;
    /**
     * 图标（可选）
     */
    icon?: string;
}

/**
 * Mention 配置选项
 */
declare interface MentionOptions {
    /**
     * 提及项列表
     */
    items: MentionItem[] | Ref<MentionItem[]>;
    /**
     * 触发字符，默认 '@'
     */
    char: string;
    /**
     * 是否允许空格，默认 false
     */
    allowSpaces?: boolean;
    /**
     * HTML 属性
     */
    HTMLAttributes?: Record<string, unknown>;
}

/**
 * 结构化数据项（提交时返回）
 *
 * 用于表示文本和 mention 的混合结构
 */
declare type MentionStructuredItem = {
    type: 'text';
    content: string;
} | {
    type: 'mention';
    content: string;
    value: string;
};

export declare type PluginAddState = 'idle' | 'loading' | 'added';

export declare interface PluginCardEmits {
    (e: 'toggle-plugin', enabled: boolean): void;
    (e: 'toggle-tool', toolId: string, enabled: boolean): void;
    (e: 'add-plugin', plugin: PluginInfo): void;
    (e: 'delete-plugin'): void;
}

export declare type PluginCardMode = 'installed' | 'market';

export declare interface PluginCardProps {
    plugin: PluginInfo;
    mode?: PluginCardMode;
    showToolCount?: boolean;
}

export declare type PluginCreationData = PluginFormData | string;

export declare interface PluginFormData {
    name: string;
    description: string;
    type: 'sse' | 'streamableHttp';
    url: string;
    headers: string;
    thumbnail?: File | null;
}

export declare interface PluginInfo {
    id: string;
    name: string;
    icon: string;
    description: string;
    enabled: boolean;
    expanded?: boolean;
    tools: PluginTool[];
    addState?: PluginAddState;
    category?: string;
}

export declare interface PluginModalEmits {
    (e: 'update:visible', value: boolean): void;
    (e: 'confirm', type: 'form' | 'code', data: PluginCreationData): void;
}

export declare interface PluginTool {
    id: string;
    name: string;
    description: string;
    enabled: boolean;
}

export declare interface PopupConfig {
    type: 'fixed' | 'drawer';
    position?: {
        top?: string | number;
        left?: string | number;
        right?: string | number;
        bottom?: string | number;
    };
    drawer?: {
        direction: 'left' | 'right';
    };
}

declare const Prompt: typeof _default_35 & {
    install: typeof installPrompt;
};
export { Prompt }
export { Prompt as TrPrompt }

export declare interface PromptProps {
    /**
     * 提示标签，显示提示的主要内容
     */
    label: string;
    /**
     * 唯一标识用于区分每个提示项，用于 Prompts 列表。如果不传此参数，则使用 index 作为 key
     */
    id?: string;
    /**
     * 提示描述，提供额外的信息
     */
    description?: string;
    /**
     * 提示图标，显示在提示项的左侧
     */
    icon?: VNode;
    /**
     * 是否禁用。默认 false
     */
    disabled?: boolean;
    /**
     * 提示徽章，显示在提示项的右上角
     */
    badge?: string | VNode;
    /**
     * 提示项大小。默认 medium
     */
    size?: 'small' | 'medium' | 'large';
}

declare const Prompts: typeof _default_36 & {
    install: typeof installPrompts;
};
export { Prompts }
export { Prompts as TrPrompts }

export declare interface PromptsEvents {
    (e: 'item-click', ev: MouseEvent, item: PromptProps): void;
}

export declare interface PromptsProps {
    /**
     * 包含多个提示项的列表
     */
    items: PromptProps[];
    /**
     * 自定义样式，用于各个提示项的不同部分
     */
    itemStyle?: string | CSSProperties;
    /**
     *  自定义类名，用于各个提示项的不同部分
     */
    itemClass?: string | string[];
    /**
     * 提示列表是否垂直排列。默认 false
     */
    vertical?: boolean;
    /**
     * 提示列表是否折行。默认 false
     */
    wrap?: boolean;
}

export declare interface PromptsSlots {
    footer?: () => unknown;
}

export declare interface RawFileAttachment extends BaseAttachment {
    rawFile: File;
    url?: string;
    size?: number;
}

/**
 * 文件拒绝原因
 */
export declare interface RejectionReason {
    code: DragZoneErrorCode;
    message: string;
}

/**
 * 选择器选项
 */
export declare interface SelectOption {
    /**
     * 显示文本
     */
    label: string;
    /**
     * 选择后的值
     */
    value: string;
    /**
     * 自定义数据（可选）
     */
    data?: string;
}

declare const Sender: {
    new (...args: any[]): CreateComponentPublicInstanceWithMixins<Readonly<SenderProps> & Readonly<{
    onClear?: (() => any) | undefined;
    onInput?: ((value: string) => any) | undefined;
    onBlur?: ((event: FocusEvent) => any) | undefined;
    onCancel?: (() => any) | undefined;
    onFocus?: ((event: FocusEvent) => any) | undefined;
    onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
    }>, {
    submit: () => void;
    clear: () => void;
    cancel: () => void;
    focus: () => void;
    blur: () => void;
    setContent: (content: string) => void;
    getContent: () => string;
    editor: SenderContext["editor"];
    }, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
    clear: () => any;
    input: (value: string) => any;
    blur: (event: FocusEvent) => any;
    cancel: () => any;
    focus: (event: FocusEvent) => any;
    submit: (textContent: string, structuredData?: StructuredData | undefined) => any;
    "update:modelValue": (value: string) => any;
    }, PublicProps, {
    size: "normal" | "small";
    placeholder: string;
    mode: InputMode;
    enterkeyhint: EnterKeyHint;
    autoSize: AutoSize;
    extensions: Extension[] | any[];
    submitType: SubmitTrigger;
    }, false, {}, {}, GlobalComponents, GlobalDirectives, string, {}, HTMLDivElement, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<SenderProps> & Readonly<{
    onClear?: (() => any) | undefined;
    onInput?: ((value: string) => any) | undefined;
    onBlur?: ((event: FocusEvent) => any) | undefined;
    onCancel?: (() => any) | undefined;
    onFocus?: ((event: FocusEvent) => any) | undefined;
    onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
    }>, {
    submit: () => void;
    clear: () => void;
    cancel: () => void;
    focus: () => void;
    blur: () => void;
    setContent: (content: string) => void;
    getContent: () => string;
    editor: SenderContext["editor"];
    }, {}, {}, {}, {
    size: "normal" | "small";
    placeholder: string;
    mode: InputMode;
    enterkeyhint: EnterKeyHint;
    autoSize: AutoSize;
    extensions: Extension[] | any[];
    submitType: SubmitTrigger;
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & ComponentOptionsBase<Readonly<SenderProps> & Readonly<{
onClear?: (() => any) | undefined;
onInput?: ((value: string) => any) | undefined;
onBlur?: ((event: FocusEvent) => any) | undefined;
onCancel?: (() => any) | undefined;
onFocus?: ((event: FocusEvent) => any) | undefined;
onSubmit?: ((textContent: string, structuredData?: StructuredData | undefined) => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}>, {
submit: () => void;
clear: () => void;
cancel: () => void;
focus: () => void;
blur: () => void;
setContent: (content: string) => void;
getContent: () => string;
editor: SenderContext["editor"];
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {} & {
clear: () => any;
input: (value: string) => any;
blur: (event: FocusEvent) => any;
cancel: () => any;
focus: (event: FocusEvent) => any;
submit: (textContent: string, structuredData?: StructuredData | undefined) => any;
"update:modelValue": (value: string) => any;
}, string, {
size: "normal" | "small";
placeholder: string;
mode: InputMode;
enterkeyhint: EnterKeyHint;
autoSize: AutoSize;
extensions: Extension[] | any[];
submitType: SubmitTrigger;
}, {}, string, {}, GlobalComponents, GlobalDirectives, string, ComponentProvideOptions> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
    $slots: {
        header?(_: {}): any;
        header?(_: {}): any;
        prefix?(_: {}): any;
        prefix?(_: {}): any;
        content?(_: {
            editor: Editor | undefined;
        }): any;
        content?(_: {
            editor: Ref<Editor | undefined, Editor | undefined>;
        }): any;
        'actions-inline'?(_: {}): any;
        footer?(_: {}): any;
        'footer-right'?(_: {}): any;
    };
}) & {
    install: <T>(app: App<T>) => void;
    Mention: Node_2<MentionOptions, any>;
    Suggestion: Extension<SuggestionOptions, any>;
    Template: Extension<TemplateOptions, any>;
    mention: typeof mention;
    suggestion: typeof suggestion;
    template: typeof template;
};
export { Sender }
export { Sender as TrSender }

/**
 * Context Key
 *
 * 用于 provide/inject 的 key
 */
export declare const SENDER_CONTEXT_KEY: unique symbol;

/**
 * Sender Context
 *
 * 通过 provide/inject 在组件树中共享的状态和方法
 * 所有子组件都可以通过 inject 获取
 */
export declare interface SenderContext {
    /**
     * Tiptap 编辑器实例
     * 注意：Tiptap 的 useEditor 返回 ShallowRef<Editor | undefined>
     */
    editor: Ref<Editor | undefined>;
    /**
     * 编辑器 DOM 引用
     */
    editorRef: Ref<HTMLElement | null>;
    /**
     * 当前输入模式
     */
    mode: Ref<InputMode>;
    /**
     * 是否正在自动切换模式
     * 用于控制切换时的过渡动画
     */
    isAutoSwitching: Ref<boolean>;
    /**
     * 是否加载中
     */
    loading: Ref<boolean>;
    /**
     * 是否禁用
     */
    disabled: Ref<boolean>;
    /**
     * 是否有内容
     */
    hasContent: Ref<boolean>;
    /**
     * 是否可以提交
     *
     * 综合判断：
     * - !disabled
     * - !loading
     * - hasContent
     * - !isOverLimit
     * - !defaultActions.submit?.disabled
     */
    canSubmit: Ref<boolean>;
    /**
     * 是否超出字数限制
     */
    isOverLimit: Ref<boolean>;
    /**
     * 当前字符数
     */
    characterCount: Ref<number>;
    /**
     * 最大字符数限制
     */
    maxLength: Ref<number | undefined>;
    /**
     * 组件的尺寸
     */
    size: Ref<'small' | 'normal'>;
    /**
     * 是否显示字数限制
     */
    showWordLimit: Ref<boolean>;
    /**
     * 是否显示清空按钮
     */
    clearable: Ref<boolean>;
    /**
     * 默认操作按钮配置
     */
    defaultActions: Ref<DefaultActions | undefined>;
    /**
     * 提交触发方式
     */
    submitType: Ref<SubmitTrigger>;
    /**
     * 停止按钮文字
     */
    stopText: Ref<string | undefined>;
    /**
     * 提交内容
     */
    submit: () => void;
    /**
     * 清空内容
     */
    clear: () => void;
    /**
     * 取消操作
     *
     * 在 loading 状态下触发，用于取消正在进行的操作
     */
    cancel: () => void;
    /**
     * 聚焦编辑器
     */
    focus: () => void;
    /**
     * 失焦编辑器
     */
    blur: () => void;
    /**
     * 设置编辑器内容
     *
     * @param content - 内容（HTML 或 JSON）
     */
    setContent: (content: string) => void;
    /**
     * 获取编辑器内容
     *
     * @returns 内容（HTML）
     */
    getContent: () => string;
}

/**
 * Sender 组件 Emits
 */
export declare interface SenderEmits {
    /**
     * 更新输入内容
     *
     * @param e - 事件名
     * @param value - 新内容
     */
    (e: 'update:modelValue', value: string): void;
    /**
     * 提交内容（增强版）
     *
     * @param e - 事件名
     * @param textContent - 提交的内容（纯文本，如 "帮我分析 @张三 的周报"）
     * @param structuredData - 结构化数据（可选）
     *
     * @example
     * ```typescript
     * function handleSubmit(text: string, data?: StructuredData) {
     *   console.log('纯文本:', text)
     *
     *   if (data?.template) {
     *     // Template 场景
     *     console.log('模板数据:', data.template)
     *   }
     *
     *   if (data?.mentions) {
     *     // Mention 场景
     *     console.log('提及的人:', data.mentions)
     *   }
     * }
     * ```
     */
    (e: 'submit', textContent: string, structuredData?: StructuredData): void;
    /**
     * 聚焦事件
     *
     * @param e - 事件名
     * @param event - 原生事件
     */
    (e: 'focus', event: FocusEvent): void;
    /**
     * 失焦事件
     *
     * @param e - 事件名
     * @param event - 原生事件
     */
    (e: 'blur', event: FocusEvent): void;
    /**
     * 清空事件
     *
     * @param e - 事件名
     */
    (e: 'clear'): void;
    /**
     * 取消事件
     *
     * 在 loading 状态下点击停止按钮时触发
     * 用于取消正在进行的操作（如 AI 响应）
     *
     * @param e - 事件名
     */
    (e: 'cancel'): void;
    /**
     * 输入事件
     *
     * @param e - 事件名
     * @param value - 当前内容
     */
    (e: 'input', value: string): void;
}

/**
 * Sender 组件 Props
 */
export declare interface SenderProps {
    /**
     * 输入内容（双向绑定）
     *
     * 支持 v-model
     */
    modelValue?: string;
    /**
     * 默认值
     *
     * 仅在初始化时使用
     */
    defaultValue?: string;
    /**
     * 占位符文本
     *
     * @default '请输入内容...'
     */
    placeholder?: string;
    /**
     * 是否禁用
     *
     * @default false
     */
    disabled?: boolean;
    /**
     * 是否加载中
     *
     * 加载状态下显示停止按钮
     *
     * @default false
     */
    loading?: boolean;
    /**
     * 是否自动聚焦
     *
     * @default false
     */
    autofocus?: boolean;
    /**
     * 移动端虚拟键盘回车键提示
     *
     * 用于自定义移动端虚拟键盘上回车键的显示文本或图标
     *
     * @default 'send'
     */
    enterkeyhint?: EnterKeyHint;
    /**
     * 输入模式
     *
     * - single: 单行模式
     * - multiple: 多行模式
     *
     * @default 'single'
     */
    mode?: InputMode;
    /**
     * 自动调整高度
     *
     * - false: 不自动调整
     * - true: 自动调整（默认 1-3 行）
     * - { minRows, maxRows }: 自定义行数范围
     *
     * 仅在 mode === 'multiple' 时有效
     *
     * @default { minRows: 1, maxRows: 3 }
     */
    autoSize?: AutoSize;
    /**
     * 最大字符数
     *
     * @default Infinity
     */
    maxLength?: number;
    /**
     * 是否显示字数限制
     *
     * 仅在 maxLength 有值时有效
     *
     * @default false
     */
    showWordLimit?: boolean;
    /**
     * 是否显示清空按钮
     *
     * @default false
     */
    clearable?: boolean;
    /**
     * Tiptap 扩展配置
     *
     * 用于添加增强输入能力，如 Template、Mention、Suggestion 等
     *
     * @example 基础使用
     * ```typescript
     * import { Template } from '@tiny-robot/components/sender/extensions'
     *
     * <Sender :extensions="[Template]" />
     * ```
     *
     * @example 带配置的扩展（响应式推荐）
     * ```typescript
     * import { Mention, Suggestion } from '@tiny-robot/components/sender/extensions'
     *
     * const mentions = ref([...])
     * const suggestions = ref([...])
     *
     * const extensions = [
     *   Mention.configure({ items: mentions }),
     *   Suggestion.configure({ items: suggestions })
     * ]
     *
     * <Sender :extensions="extensions" />
     * ```
     */
    extensions?: Extension[] | any[];
    /**
     * 组件尺寸
     *
     * - normal: 正常尺寸（默认）
     * - small: 紧凑模式，更小的字体、间距和图标
     *
     * @default 'normal'
     */
    size?: 'normal' | 'small';
    /**
     * 停止按钮文字
     *
     * @default '停止响应'
     */
    stopText?: string;
    /**
     * 默认操作按钮配置
     *
     * 用于统一配置默认按钮（Clear、Submit）的状态和提示
     *
     * @example 基础使用
     * ```vue
     * <Sender
     *   :actions-config="{
     *     submit: { disabled: !isValid, tooltip: '请完善表单' }
     *   }"
     * />
     * ```
     *
     * @example 动态配置
     * ```vue
     * <script setup>
     * const defaultActions = computed(() => ({
     *   submit: {
     *     disabled: !canSubmit.value,
     *     tooltip: canSubmit.value ? '发送' : '请输入内容'
     *   },
     *   clear: { tooltip: '清空输入' }
     * }))
     * </script>
     *
     * <template>
     *   <Sender :actions-config="defaultActions" />
     * </template>
     * ```
     *
     * @default undefined
     */
    defaultActions?: DefaultActions;
    /**
     * 提交触发方式
     *
     * @default 'enter'
     */
    submitType?: SubmitTrigger;
}

declare interface SenderProps_2 {
    autofocus?: boolean;
    autoSize?: AutoSize;
    allowSpeech?: boolean;
    allowFiles?: boolean;
    clearable?: boolean;
    disabled?: boolean;
    defaultValue?: string | null;
    loading?: boolean;
    modelValue?: string;
    mode?: InputMode;
    maxLength?: number;
    buttonGroup?: ButtonGroupConfig;
    submitType?: SubmitTrigger;
    speech?: boolean | SpeechConfig;
    placeholder?: string;
    showWordLimit?: boolean;
    suggestions?: ISuggestionItem[];
    suggestionPopupWidth?: string | number;
    activeSuggestionKeys?: string[];
    theme?: ThemeType;
    templateData?: UserItem[];
    stopText?: string;
}

/**
 * Sender 组件 Slots
 */
export declare interface SenderSlots {
    /**
     * 头部插槽
     */
    header?: () => unknown;
    /**
     * 前缀插槽
     */
    prefix?: () => unknown;
    /**
     * 内容插槽
     *
     * @param props - 插槽属性
     * @param props.editor - 编辑器实例
     */
    content?: (props: {
        editor: unknown;
    }) => unknown;
    /**
     * 单行模式内联操作按钮插槽
     *
     * @example
     * ```vue
     * <sender>
     *   <template #actions-inline="{ insert, focus, disabled }">
     *     <voice-input @result="insert" :disabled="disabled" />
     *     <file-upload @select="handleFiles" />
     *   </template>
     * </sender>
     * ```
     */
    'actions-inline'?: (scope: SenderSlotScope) => unknown;
    /**
     * 底部插槽（多行模式）
     */
    footer?: (scope: SenderSlotScope) => unknown;
    /**
     * 底部右侧插槽（多行模式）
     */
    'footer-right'?: (scope: SenderSlotScope) => unknown;
}

/**
 * Sender 插槽作用域
 *
 * 通过插槽作用域暴露给外部组件的状态和方法
 * 主要为增强按钮（Upload、Voice 等）提供便捷的操作方法
 */
export declare interface SenderSlotScope {
    /**
     * Tiptap 编辑器实例
     * 用于高级操作
     */
    editor: Editor_2 | undefined;
    /**
     * 聚焦编辑器
     */
    focus: () => void;
    /**
     * 失焦编辑器
     */
    blur: () => void;
    /**
     * 插入内容到当前光标位置
     *
     * 适用场景：语音输入、快捷短语插入
     *
     * @param content - 要插入的内容
     * @example
     * ```vue
     * <template #actions-inline="{ insert }">
     *   <VoiceButton @speech-final="insert" />
     * </template>
     * ```
     */
    insert: (content: string) => void;
    /**
     * 追加内容到编辑器末尾
     *
     * 适用场景：连续语音输入、批量添加内容
     *
     * @param content - 要追加的内容
     */
    append: (content: string) => void;
    /**
     * 替换编辑器全部内容
     *
     * 适用场景：模板填充、内容重置
     *
     * @param content - 新内容
     */
    replace: (content: string) => void;
    /**
     * 是否禁用
     * 用于控制自定义按钮状态
     */
    disabled: boolean;
    /**
     * 是否加载中
     * 用于控制按钮加载状态和禁用
     */
    loading: boolean;
    /**
     * 是否有内容
     * 用于控制按钮显示/隐藏
     */
    hasContent: boolean;
}

/**
 * 建议项类型
 *
 * @example
 * ```typescript
 * // 自动匹配
 * { content: 'ECS-云服务器' }
 *
 * // 精确指定高亮
 * {
 *   content: 'ECS-云服务器',
 *   highlights: ['ECS', '云服务器']
 * }
 *
 * // 自定义高亮函数
 * {
 *   content: 'ECS-云服务器',
 *   highlights: (text, query) => [
 *     { text: 'ECS', isMatch: true },
 *     { text: '-云服务器', isMatch: false }
 *   ]
 * }
 * ```
 */
export declare interface SenderSuggestionItem {
    /**
     * 建议项内容（必填）
     */
    content: string;
    /**
     * 显示标签（可选）
     *
     * 默认使用 content
     */
    label?: string;
    /**
     * 高亮方式（可选）
     *
     * - undefined: 自动匹配（默认）
     * - string[]: 精确指定高亮片段
     * - function: 自定义高亮逻辑
     */
    highlights?: string[] | HighlightFunction;
    /**
     * 自定义数据（可选）
     *
     * 用于扩展功能
     */
    data?: Record<string, unknown>;
}

/**
 * 语音识别相关类型定义
 */
export declare interface SpeechCallbacks {
    onStart: () => void;
    onInterim: (transcript: string) => void;
    onFinal: (transcript: string) => void;
    onEnd: (transcript?: string) => void;
    onError: (error: Error) => void;
}

export declare interface SpeechConfig {
    customHandler?: SpeechHandler;
    lang?: string;
    continuous?: boolean;
    interimResults?: boolean;
    autoReplace?: boolean;
    onVoiceButtonClick?: (isRecording: boolean, preventDefault: () => void) => void | Promise<void>;
}

export declare interface SpeechHandler {
    start: (callbacks: SpeechCallbacks) => Promise<void> | void;
    stop: () => Promise<void> | void;
    isSupported: () => boolean;
}

export declare interface SpeechHandlerResult {
    speechState: SpeechState;
    start: () => void;
    stop: () => void;
}

export declare interface SpeechHookOptions extends SpeechConfig {
    onStart?: () => void;
    onEnd?: (transcript?: string) => void;
    onInterim?: (transcript: string) => void;
    onFinal?: (transcript: string) => void;
    onError?: (error: Error) => void;
}

export declare interface SpeechState {
    isRecording: boolean;
    isSupported: boolean;
    error?: Error;
}

/**
 * 结构化数据（联合类型）
 *
 * Submit 事件的第二个参数，根据使用的扩展直接返回对应的数据数组
 *
 * **设计理念**：
 * - 第一个参数 `text`：纯文本内容，适用于简单场景
 * - 第二个参数 `data`：结构化数据数组，直接使用无需解包
 *
 * **类型说明**：
 * - `TemplateItem[]`: 使用 Template 扩展时返回（混合结构）
 * - `MentionStructuredItem[]`: 使用 Mention 扩展时返回（混合结构）
 *
 * @example Template 场景
 * ```typescript
 * function handleSubmit(text: string, data?: StructuredData) {
 *   // text: "帮我分析 的周报"
 *   // data: [
 *   //   { type: 'text', content: '帮我分析 ' },
 *   //   { type: 'block', content: '张三' },
 *   //   { type: 'text', content: ' 的周报' }
 *   // ]
 *
 *   // 提取模板块（可编辑部分）
 *   if (data && data.some(item => item.type === 'block')) {
 *     const blocks = data.filter(item => item.type === 'block')
 *     console.log('模板块:', blocks)
 *   }
 *
 *   // 提取选择器
 *   if (data && data.some(item => item.type === 'select')) {
 *     const selects = data.filter(item => item.type === 'select')
 *     console.log('选择器:', selects)
 *   }
 * }
 * ```
 *
 * @example Mention 场景
 * ```typescript
 * function handleSubmit(text: string, data?: StructuredData) {
 *   // text: "帮我分析 @张三 的周报"
 *   // data: [
 *   //   { type: 'text', content: '帮我分析 ' },
 *   //   { type: 'mention', content: '张三', value: '...' },
 *   //   { type: 'text', content: ' 的周报' }
 *   // ]
 *
 *   // 统一使用 content 属性
 *   const allContent = data?.map(item => item.content).join('')
 *   console.log('完整内容:', allContent)
 *
 *   // 提取 mention（正确的类型守卫）
 *   if (data && data.some(item => item.type === 'mention')) {
 *     const mentions = data.filter(item => item.type === 'mention')
 *     console.log('提及的人:', mentions.map(m => m.content))
 *     console.log('关联值:', mentions.map(m => m.value))
 *   }
 * }
 * ```
 */
export declare type StructuredData = TemplateItem[] | MentionStructuredItem[];

/**
 * 提交触发方式
 * - enter: Enter 键提交
 * - ctrlEnter: Ctrl+Enter 提交
 * - shiftEnter: Shift+Enter 提交
 */
export declare type SubmitTrigger = 'enter' | 'ctrlEnter' | 'shiftEnter';

/**
 * 创建 Suggestion 扩展的便捷函数
 *
 * @param items - 建议项列表
 * @param options - 其他配置项
 *
 * @example
 * ```typescript
 * const extensions = [suggestion(suggestions)]
 * const extensions = [suggestion(suggestions, { popupWidth: 500 })]
 * ```
 */
declare function suggestion(items: SenderSuggestionItem[] | Ref<SenderSuggestionItem[]>, options?: Partial<Omit<SuggestionOptions, 'items'>>): Extension<SuggestionOptions, any>;

export declare interface SuggestionBaseItem {
    id: string;
    text: string;
}

export declare type SuggestionData<T = Record<string, unknown>> = (SuggestionItem<T> | SuggestionGroup<T>)[];

export declare interface SuggestionGroup<T = Record<string, unknown>> {
    group: string;
    label: string;
    icon?: VNode | Component;
    items: SuggestionItem<T>[];
}

export declare type SuggestionItem<T = Record<string, unknown>> = SuggestionBaseItem & T;

/**
 * SuggestionList Emits
 */
export declare interface SuggestionListEmits {
    /**
     * 选择建议
     *
     * @param suggestion - 建议内容
     */
    (e: 'select', suggestion: string): void;
    /**
     * 鼠标进入
     *
     * @param index - 索引
     */
    (e: 'mouse-enter', index: number): void;
    /**
     * 鼠标离开
     */
    (e: 'mouse-leave'): void;
}

/**
 * SuggestionList Props
 */
export declare interface SuggestionListProps {
    /**
     * 是否显示
     */
    show: boolean;
    /**
     * 建议列表
     */
    suggestions: SenderSuggestionItem[];
    /**
     * 键盘激活索引
     */
    activeKeyboardIndex: number;
    /**
     * 鼠标激活索引
     */
    activeMouseIndex: number;
    /**
     * 输入值
     */
    inputValue: string;
    /**
     * 弹窗样式
     */
    popupStyle?: Record<string, string | number>;
}

/**
 * 插件配置选项
 */
export declare interface SuggestionOptions {
    /**
     * 建议项列表（可选）
     *
     * 不传或传空数组时，建议功能不会显示
     *
     * @default []
     *
     * @example
     * ```typescript
     * const items = ref([
     *   { content: 'ECS-云服务器' },
     *   { content: 'RDS-数据库' }
     * ])
     * ```
     */
    items?: SenderSuggestionItem[] | Ref<SenderSuggestionItem[]>;
    /**
     * 自定义过滤函数（可选）
     *
     * - 不传：不过滤，直接显示所有项
     * - 传入：使用自定义过滤逻辑
     *
     * @default undefined（不过滤）
     *
     * @example 模糊匹配过滤
     * ```typescript
     * filterFn: (items, query) => {
     *   return items.filter(item =>
     *     item.content.toLowerCase().includes(query.toLowerCase())
     *   )
     * }
     * ```
     *
     * @example 前缀匹配过滤
     * ```typescript
     * filterFn: (items, query) => {
     *   return items.filter(item =>
     *     item.content.toLowerCase().startsWith(query.toLowerCase())
     *   )
     * }
     * ```
     */
    filterFn?: (suggestions: SenderSuggestionItem[], query: string) => SenderSuggestionItem[];
    /**
     * 选中建议项的按键
     *
     * 注意：Tab 键用于自动补全，不受此配置控制
     *
     * @default ['Enter']
     *
     * @example 只允许 Enter 选中
     * ```typescript
     * activeSuggestionKeys: ['Enter']
     * ```
     *
     * @example 允许 Enter 和 Space 选中
     * ```typescript
     * activeSuggestionKeys: ['Enter', ' ']  // 注意：空格键是 ' '
     * ```
     *
     * @example 禁用所有选中按键（只能点击）
     * ```typescript
     * activeSuggestionKeys: []
     * ```
     */
    activeSuggestionKeys?: string[];
    /**
     * 弹窗宽度
     *
     * @default 400
     */
    popupWidth?: number | string;
    /**
     * 是否显示自动补全提示
     *
     * @default true
     */
    showAutoComplete?: boolean;
    /**
     * 选中建议项的回调
     *
     * @param item - 选中的建议项（包含完整的 SenderSuggestionItem 信息）
     * @returns 返回 false 可阻止默认回填行为
     *
     * @example 默认行为（自动回填）
     * ```typescript
     * onSelect: (item) => {
     *   console.log('Selected:', item)
     *   // 不返回 false，内容会自动回填
     * }
     * ```
     *
     * @example 阻止默认行为并自定义回填
     * ```typescript
     * onSelect: (item) => {
     *   editor.commands.setContent(`前缀-${item.content}-后缀`)
     *   return false // 阻止默认回填
     * }
     * ```
     *
     * @example 条件性阻止
     * ```typescript
     * onSelect: (item) => {
     *   if (item.data?.needsValidation) {
     *     validateAndFill(item)
     *     return false
     *   }
     *   // 否则使用默认回填
     * }
     * ```
     */
    onSelect?: (item: SenderSuggestionItem) => void | false;
}

declare const SuggestionPillButton: typeof _default_38 & {
    install: typeof installPillButton;
};
export { SuggestionPillButton }
export { SuggestionPillButton as TrSuggestionPillButton }

export declare interface SuggestionPillButtonProps {
    item?: SuggestionPillItem;
}

export declare interface SuggestionPillButtonSlots {
    default?: () => unknown;
    icon?: () => unknown;
}

export declare type SuggestionPillItem = {
    text: string;
    icon?: VNode | Component;
} | {
    text?: string;
    icon: VNode | Component;
};

export declare interface SuggestionPillsEmits {
    (e: 'click-outside', event: MouseEvent): void;
}

export declare interface SuggestionPillsProps {
    /**
     * model:showAll
     */
    showAll?: boolean;
    /**
     * 显示更多按钮的时机
     * - hover: 鼠标悬停时显示
     * - always: 总是显示
     * @default 'hover'
     */
    showAllButtonOn?: 'hover' | 'always';
    /**
     * 控制多余按钮如何展示
     * - expand: 点击更多按钮展开所有项
     * - scroll: 横向滚动显示多余项
     * @default 'expand'
     */
    overflowMode?: 'expand' | 'scroll';
    /**
     * 鼠标悬停时是否自动滚动到可见区域
     */
    autoScrollOn?: 'mouseenter' | 'click';
}

export declare interface SuggestionPillsSlots {
    default?: () => VNode[];
}

export declare interface SuggestionPopoverEmits {
    (e: 'item-click', item: SuggestionItem): void;
    (e: 'group-click', group: SuggestionGroup): void;
    (e: 'open'): void;
    (e: 'close'): void;
    (e: 'click-outside', event: MouseEvent): void;
}

export declare interface SuggestionPopoverEventProps {
    onItemClick?: (item: SuggestionItem) => void;
    onGroupClick?: (group: SuggestionGroup) => void;
    onOpen?: () => void;
    onClose?: () => void;
    onClickOutside?: (event: MouseEvent) => void;
}

export declare interface SuggestionPopoverEvents {
    /**
     * @deprecated use onItemClick in props instead
     */
    itemClick?: (item: SuggestionItem) => void;
    /**
     * @deprecated use onGroupClick in props instead
     */
    groupClick?: (group: SuggestionGroup) => void;
    /**
     * @deprecated use onOpen in props instead
     */
    open?: () => void;
    /**
     * @deprecated use onClose in props instead
     */
    close?: () => void;
    /**
     * @deprecated use onClickOutside in props instead
     */
    clickOutside?: (event: MouseEvent) => void;
}

export declare interface SuggestionPopoverProps<T = Record<string, unknown>> {
    appendTo?: string | HTMLElement;
    data: SuggestionData<T>;
    title?: string;
    icon?: VNode | Component;
    /**
     * 是否显示弹窗，仅在 trigger 为 'manual' 时有效
     */
    show?: boolean;
    /**
     * 触发方式。默认值为 'click'
     */
    trigger?: 'click' | 'manual';
    /**
     * model:selectedGroup
     */
    selectedGroup?: string;
    groupShowMoreTrigger?: 'click' | 'hover';
    loading?: boolean;
    topOffset?: number;
}

export declare interface SuggestionPopoverSlots {
    trigger?: () => VNode | VNode[];
    item?: ({ item }: {
        item: SuggestionItem;
    }) => VNode | VNode[];
    loading?: () => VNode | VNode[];
    empty?: () => VNode | VNode[];
    header?: () => VNode | VNode[];
    body?: () => VNode | VNode[];
}

/**
 * 插件状态
 *
 * 管理建议列表的显示、过滤、选中等状态
 */
export declare interface SuggestionState {
    /**
     * 是否激活（有匹配的建议项）
     */
    active: boolean;
    /**
     * 匹配范围
     *
     * 全局模式：整个文档范围
     * 字符模式：触发字符到光标的范围
     */
    range: {
        from: number;
        to: number;
    } | null;
    /**
     * 查询文本
     *
     * 全局模式：整个输入内容
     * 字符模式：触发字符后的文本
     */
    query: string;
    /**
     * 过滤后的建议项
     */
    filteredSuggestions: SenderSuggestionItem[];
    /**
     * 当前选中的建议项索引
     *
     * -1 表示未选中
     */
    selectedIndex: number;
    /**
     * 自动补全文本
     *
     * 选中项的剩余部分
     */
    autoCompleteText: string;
    /**
     * 是否显示 Tab 提示
     */
    showTabIndicator: boolean;
}

/**
 * Suggestion 插件类型定义
 *
 * 包含建议项、高亮、插件配置和状态等类型定义
 */
/**
 * 高亮文本片段
 */
export declare interface SuggestionTextPart {
    text: string;
    isMatch: boolean;
}

declare interface SuggestionTextPart_2 {
    text: string;
    isMatch: boolean;
}

/**
 * 创建 Template 扩展的便捷函数
 *
 * @param items - 模板项列表
 * @param options - 其他配置项
 *
 * @example
 * ```typescript
 * const extensions = [template(templates)]
 * const extensions = [template(templates, { HTMLAttributes: { class: 'custom' } })]
 * ```
 */
declare function template(items: TemplateItem[] | Ref<TemplateItem[]>, options?: Partial<Omit<TemplateOptions, 'items'>>): Extension<TemplateOptions, any>;

/**
 * 模板项（用户侧）
 *
 * 用户传入的模板数据格式
 * 组件内部会转换为 Tiptap 节点格式
 */
export declare type TemplateItem = {
    /**
     * 模板 ID，可选
     * 如果不提供，组件会自动生成
     */
    id?: string;
    /**
     * 类型：普通文本
     */
    type: 'text';
    /**
     * 内容
     */
    content: string;
} | {
    /**
     * 模板 ID，可选
     * 如果不提供，组件会自动生成
     */
    id?: string;
    /**
     * 类型：模板块（可编辑）
     */
    type: 'block';
    /**
     * 内容
     */
    content: string;
} | {
    /**
     * 模板 ID，可选
     * 如果不提供，组件会自动生成
     */
    id?: string;
    /**
     * 类型：选择器
     */
    type: 'select';
    /**
     * 内容（选中的值）
     */
    content: string;
    /**
     * 占位文字（未选择时显示）
     */
    placeholder?: string;
    /**
     * 选项列表
     */
    options?: SelectOption[];
    /**
     * 当前选中的值
     */
    value?: string;
};

/**
 * Template 配置选项
 */
declare interface TemplateOptions {
    /**
     * 模板数据列表（推荐使用 ref 实现响应式）
     *
     * 支持两种配置方式：
     * 1. 传入 ref（推荐）：自动双向绑定，解决时序问题
     * 2. 传入数组：仅用于静态初始化
     *
     * @example 响应式配置（推荐）
     * ```typescript
     * const items = ref<TemplateItem[]>([
     *   { type: 'text', content: '帮我分析' },
     *   { type: 'template', content: '' }
     * ])
     * Template.configure({ items })  // 传入 ref，自动双向绑定
     * ```
     *
     * @example 静态配置
     * ```typescript
     * Template.configure({
     *   items: [
     *     { type: 'text', content: '帮我分析' },
     *     { type: 'template', content: '' }
     *   ]
     * })
     * ```
     */
    items?: TemplateItem[] | Ref<TemplateItem[]>;
    /**
     * HTML 属性
     */
    HTMLAttributes?: Record<string, unknown>;
}

export declare interface ThemeProviderProps {
    /**
     * 颜色模式(v-model:colorMode)，可选值：light、dark、auto，默认值：auto
     */
    colorMode?: ColorMode;
    /**
     * 应用主题属性选择器的目标元素，默认值：html。主题只会影响 targetElement 下的元素
     */
    targetElement?: string;
    /**
     * 主题(v-model:theme)
     */
    theme?: string;
    storage?: ThemeStorage;
    storageKey?: string;
}

export declare type ThemeStorage = Pick<Storage, 'getItem' | 'setItem'>;

declare type ThemeType = 'light' | 'dark';

/**
 * 工具调用接口（支持 OpenAI 格式）
 */
export declare interface ToolCall {
    id: string;
    type: 'function' | string;
    function: {
        name: string;
        arguments: string;
    };
    [x: string]: any;
}

declare type ToolCallStatus = (typeof toolCallStatus)[number];

declare const toolCallStatus: readonly ["running", "success", "failed", "cancelled"];

/**
 * Tooltip 内容类型
 * - string: 简单文本
 * - () => string | VNode: 渲染函数，支持复杂内容
 */
export declare type TooltipContent = string | (() => string | VNode);

declare interface TooltipContentProps {
    show?: boolean;
    content: string;
    trigger?: HTMLElement | null;
    disabled?: boolean;
    placement?: 'top' | 'bottom';
    delayOpen?: number;
    delayClose?: number;
}

/**
 * Tooltip 位置
 *
 * 支持 TinyTooltip 的所有位置选项
 */
export declare type TooltipPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'left-start' | 'left-end' | 'right' | 'right-start' | 'right-end';

declare type TooltipRender = () => VNode | string;

export declare interface UploadButtonEmits {
    /**
     * 文件选择
     */
    (e: 'select', files: File[]): void;
    /**
     * 文件验证失败
     */
    (e: 'error', error: Error, files?: File[]): void;
}

export declare interface UploadButtonProps {
    /**
     * 是否禁用
     */
    disabled?: boolean;
    /**
     * 接受的文件类型
     * @default '*'
     */
    accept?: string;
    /**
     * 是否支持多选
     * @default false
     */
    multiple?: boolean;
    /**
     * 是否在选择文件后重置 input
     * @default true
     */
    reset?: boolean;
    /**
     * 文件大小限制（MB）
     */
    maxSize?: number;
    /**
     * 最大文件数量
     */
    maxCount?: number;
    /**
     * 按钮提示文本
     */
    tooltip?: TooltipContent;
    /**
     * 按钮尺寸
     */
    size?: number | string;
    /**
     * 自定义图标
     */
    icon?: Component;
    /**
     * Tooltip 位置
     */
    tooltipPlacement?: TooltipPlacement;
}

export declare interface UrlAttachment extends BaseAttachment {
    url: string;
    size: number;
    rawFile?: File;
}

/**
 * 当目标滚动容器 `target` 接近底部时，且源数据 `source` 变化，自动滚动到底部
 * @param target 目标滚动容器的元素引用
 * @param source 监听的源数据，当该数据变化时会触发自动滚动
 * @param options 配置选项
 * @param options.scrollOnMount 是否在组件挂载时滚动到底部，默认为 true
 * @param options.bottomThreshold 判断接近底部的阈值（像素），默认为 20
 * @returns scrollToBottom 手动滚动到底部的方法
 */
export declare function useAutoScroll(target: MaybeComputedElementRef, source: MaybeRefOrGetter<any>, options?: {
    scrollOnMount?: boolean;
    scrollThrottle?: number;
    bottomThreshold?: number;
}): {
    scrollToBottom: (behavior?: ScrollBehavior) => Promise<void>;
    arrivedState: {
        left: boolean;
        right: boolean;
        top: boolean;
        bottom: boolean;
    };
};

export declare function useBubbleBoxRenderer(messages: MaybeRefOrGetter<BubbleMessage[]>, contentIndex?: number): ComputedRef<{
    renderer: Component;
    attributes?: Record<string, string>;
}>;

export declare function useBubbleContentRenderer(message: MaybeRefOrGetter<BubbleMessage>, contentIndex: number): ComputedRef<Component>;

export declare function useBubbleStateChangeFn(): (key: string, _value: unknown) => void;

/**
 * useEditor 返回类型
 */
export declare interface UseEditorReturn {
    /**
     * 编辑器实例
     * 注意:Tiptap 的 useEditor 返回 ShallowRef<Editor | undefined>
     */
    editor: Ref<Editor | undefined>;
    /**
     * 编辑器 DOM 引用
     */
    editorRef: Ref<HTMLElement | null>;
}

/**
 * useKeyboardShortcuts Hook 参数
 */
export declare interface UseKeyboardShortcutsParams {
    submitType: Ref<SubmitTrigger>;
    canSubmit: Ref<boolean>;
    mode: Ref<InputMode>;
    submit: () => void;
    setMode: (mode: InputMode) => void;
}

/**
 * useKeyboardShortcuts Hook 返回值
 */
export declare interface UseKeyboardShortcutsReturn {
    checkSubmitShortcut: (event: KeyboardEvent) => boolean;
    checkNewlineShortcut: (event: KeyboardEvent) => boolean;
}

export declare const useMessageContent: <T extends ChatMessageContent = ChatMessageContent>(props: Readonly<BubbleContentRendererProps<T>>) => {
    content: ComputedRef<ChatMessageContentItem>;
    contentText: ComputedRef<string>;
};

/**
 * useModeSwitch 返回类型
 */
export declare interface UseModeSwitchReturn {
    /**
     * 当前模式
     */
    currentMode: Ref<InputMode>;
    /**
     * 是否正在自动切换
     */
    isAutoSwitching: Ref<boolean>;
    /**
     * 设置模式
     *
     * @param mode - 输入模式
     */
    setMode: (mode: InputMode) => void;
    /**
     * 检查内容溢出
     *
     * 用于自动切换模式
     */
    checkOverflow: () => void;
}

/**
 * Omit specified fields from message and return computed props
 * @param props - The original props containing the message
 * @param fields - Array of field names to omit from the message
 * @returns An object containing restMessage and restProps computed refs
 */
export declare function useOmitMessageFields<P extends BubbleContentRendererProps, K extends keyof BubbleMessage>(props: P, fields: K[]): {
    restMessage: ComputedRef<Omit<BubbleMessage, K>>;
    restProps: ComputedRef<P>;
};

declare type UserItem = UserTextItem | UserTemplateItem;

declare type UserTemplateItem = Omit<Pick<CompatTemplateItem, 'type' | 'content'>, 'id'> & {
    id?: CompatTemplateItem['id'];
};

declare type UserTextItem = Omit<CompatTextItem, 'id'> & {
    id?: CompatTextItem['id'];
};

/**
 * 获取 Sender Context
 */
export declare function useSenderContext(): SenderContext;

/**
 * useSenderContext 返回类型
 */
export declare type UseSenderContextReturn = SenderContext;

/**
 * useSuggestion 返回类型
 */
export declare interface UseSuggestionReturn {
    /**
     * 弹窗是否可见
     */
    isPopupVisible: Ref<boolean>;
    /**
     * 当前激活的建议
     */
    activeSuggestion: Ref<string>;
    /**
     * 键盘导航的激活索引
     */
    activeKeyboardIndex: Ref<number>;
    /**
     * 鼠标悬停的激活索引
     */
    activeMouseIndex: Ref<number>;
    /**
     * 自动补全文本
     */
    autoCompleteText: Ref<string>;
    /**
     * 是否显示 Tab 提示器
     */
    showTabIndicator: Ref<boolean>;
    /**
     * 应用建议
     *
     * @param suggestion - 建议内容
     */
    applySuggestion: (suggestion: string) => void;
    /**
     * 键盘导航
     *
     * @param direction - 方向（上/下）
     */
    navigateWithKeyboard: (direction: 'up' | 'down') => void;
    /**
     * 鼠标进入
     *
     * @param index - 建议项索引
     */
    handleMouseEnter: (index: number) => void;
    /**
     * 鼠标离开
     */
    handleMouseLeave: () => void;
    /**
     * 关闭弹窗
     */
    closePopup: () => void;
}

export declare const useTheme: () => {
    theme: Ref<string, string> | undefined;
    colorMode: Ref<ColorMode, ColorMode> | undefined;
    resolvedColorMode: Readonly<Ref<"light" | "dark", "light" | "dark">> | undefined;
    systemColorMode: Readonly<Ref<"light" | "dark", "light" | "dark">> | undefined;
    setTheme: (newTheme: string) => boolean;
    toggleColorMode: () => boolean;
    setColorMode: (mode: ColorMode) => boolean;
};

export declare const useToolCall: (props: BubbleContentRendererProps<ChatMessageContent, {
    toolCall?: Record<string, {
        status?: ToolCallStatus;
        open?: boolean;
    }>;
}> & {
    toolCallIndex: number;
}) => {
    toolCall: ComputedRef<ToolCall | undefined>;
    toolCallWithResult: Readonly<Ref<    {
    readonly arguments?: any;
    readonly result?: any;
    }, {
    readonly arguments?: any;
    readonly result?: any;
    }>>;
    state: ComputedRef<    {
    status: "success" | "running" | "failed" | "cancelled" | undefined;
    open: boolean | undefined;
    }>;
};

export declare function useTouchDevice(): {
    isTouchDevice: Ref<boolean, boolean>;
};

/**
 * 拖拽区域指令
 * @param el 元素
 * @param binding 绑定
 */
export declare const vDropzone: Directive<DragAwareElement, DropzoneBinding>;

declare interface VoiceButtonConfig {
    icon?: VNode | Component;
}

/**
 * VoiceButton 组件 Emits
 */
export declare interface VoiceButtonEmits {
    (e: 'speech-start'): void;
    (e: 'speech-interim', transcript: string): void;
    (e: 'speech-final', transcript: string): void;
    (e: 'speech-end', transcript?: string): void;
    (e: 'speech-error', error: Error): void;
}

/**
 * VoiceButton 组件 Props
 */
export declare interface VoiceButtonProps {
    /**
     * 自定义未录音状态的图标
     *
     * @default IconVoice
     *
     * @example 基础使用
     * ```vue
     * <VoiceButton :icon="IconMicrophone" />
     * ```
     */
    icon?: VNode | Component;
    /**
     * 自定义录音中状态的图标
     *
     * @default IconRecordingWave
     *
     * @example 自定义录音中图标
     * ```vue
     * <VoiceButton :recording-icon="MyRecordingIcon" />
     * ```
     */
    recordingIcon?: VNode | Component;
    /**
     * 是否禁用(会与 Context 的 disabled 合并)
     */
    disabled?: boolean;
    /**
     * 按钮尺寸
     */
    size?: 'small' | 'normal';
    /**
     * Tooltip 文本
     */
    tooltip?: TooltipContent;
    /**
     * Tooltip 位置
     */
    tooltipPlacement?: TooltipPlacement;
    /**
     * 语音配置
     */
    speechConfig?: SpeechConfig;
    /**
     * 是否自动插入识别结果到编辑器
     * @default true
     */
    autoInsert?: boolean;
    /**
     * 按钮点击拦截器(用于自定义 UI)
     */
    onButtonClick?: (isRecording: boolean, preventDefault: () => void) => void | Promise<void>;
}

export declare interface WelcomeProps {
    title: string;
    description: string;
    align?: 'left' | 'center' | 'right' | string;
    icon?: VNode;
}

export declare interface WelcomeSlots {
    footer: () => unknown;
}

/**
 * WordCounter Props
 */
export declare interface WordCounterProps {
    /**
     * 当前字符数
     */
    current: number;
    /**
     * 最大字符数
     */
    max: number;
    /**
     * 是否超出限制
     */
    isOverLimit: boolean;
}

export { }


/**
 * 扩展 Tiptap Commands 接口
 *
 * 使 TypeScript 能够识别自定义命令
 */
declare module '@tiptap/core' {
    interface Commands<ReturnType> {
        mention: {
            /**
             * 插入 mention 节点
             */
            insertMention: (attrs: Partial<MentionAttrs>) => ReturnType;
            /**
             * 删除 mention 节点
             */
            deleteMention: (id: string) => ReturnType;
        };
    }
}


/**
 * 扩展 Tiptap Commands 接口
 *
 * 使 TypeScript 能够识别自定义命令
 */
declare module '@tiptap/core' {
    interface Commands<ReturnType> {
        template: {
            /**
             * 设置模板数据（批量）
             */
            setTemplateData: (items: TemplateItem[]) => ReturnType;
            /**
             * 插入模板块
             */
            insertTemplate: (attrs: Partial<TemplateAttrs>) => ReturnType;
            /**
             * 聚焦到第一个模板块
             */
            focusFirstTemplate: () => ReturnType;
            /**
             * 插入选择器
             */
            insertTemplateSelect: (attrs: Partial<TemplateSelectAttrs>) => ReturnType;
        };
    }
}