@vunk/plus 1.6.8 → 1.6.9

package/components/bubble-list/src/index.vue.d.ts

@@ -0,0 +1,810 @@
+import type { VNode } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    items: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    elRef: {
+        type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
+        default: import("@vunk/shared").AnyFunc;
+    };
+    textToSpeech: {
+        type: import("vue").PropType<import("../../broadcasting-markdown/src/types").TextToSpeech>;
+    };
+}>, {
+    getContentWraper: (e: VNode) => import("vue").RendererNode | null;
+    readonly VkBubbleTemplates: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        textToSpeech: {
+            type: import("vue").PropType<import("../../broadcasting-markdown/src/types").TextToSpeech>;
+        };
+        modules: {
+            type: import("vue").PropType<import("../../agent-chat-provider/src/types").BubbleItemModule[]>;
+            default: () => string[];
+        };
+    }>, {
+        setRef: (emitSetData: (e: import("@vunk/core").SetDataEvent) => void, props: import("./types").Item, el: any) => void;
+        initRenderData: (emitSetData: (e: import("@vunk/core").SetDataEvent) => void, props: import("./types").Item) => void;
+        readonly VkBroadcastingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            render: {
+                type: import("vue").PropType<(text: string) => string>;
+                default: typeof import("../../broadcasting-markdown").defaultRender;
+            };
+            data: {
+                type: {
+                    (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    new (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    new (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: undefined;
+            };
+            source: {
+                type: StringConstructor;
+                default: string;
+            };
+            delay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            separators: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: () => string[];
+            };
+            keepRead: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            textToSpeech: {
+                type: import("vue").PropType<import("../../broadcasting-markdown/src/types").TextToSpeech>;
+                default: undefined;
+            };
+            processing: {
+                type: import("vue").PropType<(paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => void>;
+                default: import("@vunk/shared").AnyFunc;
+            };
+            status: {
+                type: import("vue").PropType<import("@vunk/shared/enum").TickerStatus>;
+                default: import("@vunk/shared/enum").TickerStatus;
+            };
+            paragraphMinlength: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>, {
+            theData: import("vue").ComputedRef<import("../../broadcasting-markdown/src/types").Paragraph[]>;
+            ParagraphStatus: typeof import("../../broadcasting-markdown").ParagraphStatus;
+            fulfilledTextValue: import("vue").ComputedRef<string>;
+            isPrevParagraphFulfilled: (currentIndex: number) => boolean;
+            isParagraphEnabled: (currentIndex: number) => boolean;
+            processingParagraph: (paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => Promise<void> | undefined;
+            isInterrupted: import("vue").Ref<boolean, boolean>;
+            setData: (obj: any, e: import("@vunk/core").SetDataEvent) => void;
+            Broadcast: typeof import("@vunk/shared/enum").TickerStatus;
+            isPaused: import("vue").ComputedRef<boolean>;
+            isTypingFinished: import("vue").Ref<boolean, boolean>;
+            currentParagraph: import("vue").ComputedRef<import("../../broadcasting-markdown/src/types").Paragraph | undefined>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            setData: (e: import("@vunk/core").SetDataEvent) => import("@vunk/core").SetDataEvent;
+            interrupt: null;
+            'update:broadcasting': (_: boolean) => boolean;
+            'update:completed': (_: boolean) => boolean;
+            'update:error': (_: boolean) => boolean;
+            'update:status': (_: import("@vunk/shared/enum").TickerStatus) => boolean;
+            paragraphLoad: (_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => boolean;
+        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            render: {
+                type: import("vue").PropType<(text: string) => string>;
+                default: typeof import("../../broadcasting-markdown").defaultRender;
+            };
+            data: {
+                type: {
+                    (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    new (arrayLength: number): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    new (...items: import("../../broadcasting-markdown/src/types").Paragraph[]): import("../../broadcasting-markdown/src/types").Paragraph[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: undefined;
+            };
+            source: {
+                type: StringConstructor;
+                default: string;
+            };
+            delay: {
+                type: NumberConstructor;
+                default: number;
+            };
+            separators: {
+                type: {
+                    (arrayLength: number): string[];
+                    (...items: string[]): string[];
+                    new (arrayLength: number): string[];
+                    new (...items: string[]): string[];
+                    isArray(arg: any): arg is any[];
+                    readonly prototype: any[];
+                    from<T>(arrayLike: ArrayLike<T>): T[];
+                    from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+                    from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+                    of<T>(...items: T[]): T[];
+                    fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+                    fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+                    readonly [Symbol.species]: ArrayConstructor;
+                };
+                default: () => string[];
+            };
+            keepRead: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            textToSpeech: {
+                type: import("vue").PropType<import("../../broadcasting-markdown/src/types").TextToSpeech>;
+                default: undefined;
+            };
+            processing: {
+                type: import("vue").PropType<(paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => void>;
+                default: import("@vunk/shared").AnyFunc;
+            };
+            status: {
+                type: import("vue").PropType<import("@vunk/shared/enum").TickerStatus>;
+                default: import("@vunk/shared/enum").TickerStatus;
+            };
+            paragraphMinlength: {
+                type: NumberConstructor;
+                default: number;
+            };
+        }>> & Readonly<{
+            onSetData?: ((e: import("@vunk/core").SetDataEvent) => any) | undefined;
+            "onUpdate:status"?: ((_: import("@vunk/shared/enum").TickerStatus) => any) | undefined;
+            onInterrupt?: ((...args: any[]) => any) | undefined;
+            "onUpdate:broadcasting"?: ((_: boolean) => any) | undefined;
+            "onUpdate:completed"?: ((_: boolean) => any) | undefined;
+            "onUpdate:error"?: ((_: boolean) => any) | undefined;
+            onParagraphLoad?: ((_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => any) | undefined;
+        }>, {
+            processing: (paragraph: import("../../broadcasting-markdown/src/types").Paragraph) => void;
+            source: string;
+            delay: number;
+            render: (text: string) => string;
+            data: import("../../broadcasting-markdown/src/types").Paragraph[];
+            status: import("@vunk/shared/enum").TickerStatus;
+            separators: string[];
+            keepRead: boolean;
+            textToSpeech: import("../../broadcasting-markdown/src/types").TextToSpeech;
+            paragraphMinlength: number;
+        }, {}, {
+            ParagraphView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                enable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                status: {
+                    type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
+                    default: import("../../broadcasting-markdown").ParagraphStatus;
+                };
+                processing: {
+                    type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
+                    default: import("@vunk/shared").AnyFunc;
+                };
+                retryTimes: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>, {
+                props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                    enable: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    status: {
+                        type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
+                        default: import("../../broadcasting-markdown").ParagraphStatus;
+                    };
+                    processing: {
+                        type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
+                        default: import("@vunk/shared").AnyFunc;
+                    };
+                    retryTimes: {
+                        type: NumberConstructor;
+                        default: number;
+                    };
+                }>> & Readonly<{
+                    "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+                }> & {}>;
+                emit: (event: "update:status", ...args: any[]) => void;
+                theDef: import("vue").ShallowRef<import("@vunk/shared/promise").Deferred<any> | undefined, import("@vunk/shared/promise").Deferred<any> | undefined>;
+                retryTimes: number;
+                processingDef: {
+                    _ref: import("vue").ShallowRef<unknown, unknown>;
+                    readonly value: unknown;
+                    promise: Promise<unknown>;
+                    resolve: import("@vunk/core").AnyFunc;
+                    reject: (reason?: any) => void;
+                };
+                init: () => Promise<void>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:status"[], "update:status", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                enable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                status: {
+                    type: import("vue").PropType<import("../../broadcasting-markdown").ParagraphStatus>;
+                    default: import("../../broadcasting-markdown").ParagraphStatus;
+                };
+                processing: {
+                    type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
+                    default: import("@vunk/shared").AnyFunc;
+                };
+                retryTimes: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+            }>> & Readonly<{
+                "onUpdate:status"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                processing: import("@vunk/shared").AnyFunc;
+                status: import("../../broadcasting-markdown").ParagraphStatus;
+                enable: boolean;
+                retryTimes: number;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            VkTypingMarkdown: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                source: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                delay: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                pause: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                markdownItSetup: {
+                    type: import("vue").PropType<(md: import("markdown-it-async").MarkdownItAsync) => void>;
+                    default: null;
+                };
+                finished: {
+                    type: BooleanConstructor;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                htmlText: import("vue").Ref<string, string>;
+                isDebouncedTyping: Readonly<import("vue").Ref<boolean, boolean>>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                typing: null;
+                'update:finished': null;
+            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                source: {
+                    type: StringConstructor;
+                    default: string;
+                };
+                delay: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                pause: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disabled: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                markdownItSetup: {
+                    type: import("vue").PropType<(md: import("markdown-it-async").MarkdownItAsync) => void>;
+                    default: null;
+                };
+                finished: {
+                    type: BooleanConstructor;
+                };
+                loading: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{
+                onTyping?: ((...args: any[]) => any) | undefined;
+                "onUpdate:finished"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                source: string;
+                delay: number;
+                pause: boolean;
+                disabled: boolean;
+                markdownItSetup: (md: import("markdown-it-async").MarkdownItAsync) => void;
+                finished: boolean;
+                loading: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            HowlerSpeechView: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                data: {
+                    type: import("vue").PropType<import("../../broadcasting-markdown/src/types").Paragraph>;
+                    default: () => {};
+                };
+                deferred: {
+                    type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
+                    required: true;
+                };
+                render: {
+                    type: import("vue").PropType<(text: string) => string>;
+                    default: typeof import("../../broadcasting-markdown").defaultRender;
+                };
+            }>, (() => null) | (() => JSX.Element), {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                setData: (e: import("@vunk/core").SetDataEvent<keyof import("../../broadcasting-markdown/src/types").Paragraph>) => import("@vunk/core").SetDataEvent<keyof import("../../broadcasting-markdown/src/types").Paragraph>;
+                load: (_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => boolean;
+            }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                data: {
+                    type: import("vue").PropType<import("../../broadcasting-markdown/src/types").Paragraph>;
+                    default: () => {};
+                };
+                deferred: {
+                    type: import("vue").PropType<import("@vunk/shared/promise").Deferred<any>>;
+                    required: true;
+                };
+                render: {
+                    type: import("vue").PropType<(text: string) => string>;
+                    default: typeof import("../../broadcasting-markdown").defaultRender;
+                };
+            }>> & Readonly<{
+                onSetData?: ((e: import("@vunk/core").SetDataEvent<keyof import("../../broadcasting-markdown/src/types").Paragraph>) => any) | undefined;
+                onLoad?: ((_: import("../../broadcasting-markdown/src/types").ParagraphLoadEvent) => any) | undefined;
+            }>, {
+                render: (text: string) => string;
+                data: import("../../broadcasting-markdown/src/types").Paragraph;
+            }, {}, {
+                SpeechError: import("vue").DefineComponent<{}, {
+                    readonly CloseBold: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                    readonly ElIcon: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+                        readonly size: {
+                            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly color: {
+                            readonly type: import("vue").PropType<string>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                    }, {
+                        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                            readonly size: {
+                                readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                                readonly required: false;
+                                readonly validator: ((val: unknown) => boolean) | undefined;
+                                __epPropKey: true;
+                            };
+                            readonly color: {
+                                readonly type: import("vue").PropType<string>;
+                                readonly required: false;
+                                readonly validator: ((val: unknown) => boolean) | undefined;
+                                __epPropKey: true;
+                            };
+                        }>> & {
+                            [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any) | undefined;
+                        }>>;
+                        ns: {
+                            namespace: import("vue").ComputedRef<string>;
+                            b: (blockSuffix?: string) => string;
+                            e: (element?: string | undefined) => string;
+                            m: (modifier?: string | undefined) => string;
+                            be: (blockSuffix?: string | undefined, element?: string | undefined) => string;
+                            em: (element?: string | undefined, modifier?: string | undefined) => string;
+                            bm: (blockSuffix?: string | undefined, modifier?: string | undefined) => string;
+                            bem: (blockSuffix?: string | undefined, element?: string | undefined, modifier?: string | undefined) => string;
+                            is: {
+                                (name: string, state: boolean | undefined): string;
+                                (name: string): string;
+                            };
+                            cssVar: (object: Record<string, string>) => Record<string, string>;
+                            cssVarName: (name: string) => string;
+                            cssVarBlock: (object: Record<string, string>) => Record<string, string>;
+                            cssVarBlockName: (name: string) => string;
+                        };
+                        style: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+                        readonly size: {
+                            readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => (string | number) & {}) | (() => string | number) | ((new (...args: any[]) => (string | number) & {}) | (() => string | number))[], unknown, unknown>>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                        readonly color: {
+                            readonly type: import("vue").PropType<string>;
+                            readonly required: false;
+                            readonly validator: ((val: unknown) => boolean) | undefined;
+                            __epPropKey: true;
+                        };
+                    }>>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        readonly VkRendererTemplate: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: boolean;
+                default: string;
+            };
+        }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            type: {
+                type: StringConstructor;
+                required: boolean;
+                default: string;
+            };
+        }>> & Readonly<{}>, {
+            type: string;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        readonly Thinking: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue-element-plus-x/./types/Thinking").ThinkingProps> & Readonly<{
+                onChange?: ((value: {
+                    value: boolean;
+                    status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+                }) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                change: (value: {
+                    value: boolean;
+                    status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+                }) => any;
+                "update:modelValue": (value: boolean) => any;
+            }, import("vue").PublicProps, {
+                maxWidth: string;
+                status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+                color: string;
+                content: string;
+                disabled: boolean;
+                duration: string;
+                backgroundColor: string;
+                modelValue: boolean;
+                autoCollapse: boolean;
+                buttonWidth: string;
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, HTMLDivElement, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue-element-plus-x/./types/Thinking").ThinkingProps> & Readonly<{
+                onChange?: ((value: {
+                    value: boolean;
+                    status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+                }) => any) | undefined;
+                "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+            }>, {}, {}, {}, {}, {
+                maxWidth: string;
+                status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+                color: string;
+                content: string;
+                disabled: boolean;
+                duration: string;
+                backgroundColor: string;
+                modelValue: boolean;
+                autoCollapse: boolean;
+                buttonWidth: string;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue-element-plus-x/./types/Thinking").ThinkingProps> & Readonly<{
+            onChange?: ((value: {
+                value: boolean;
+                status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+            }) => any) | undefined;
+            "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            change: (value: {
+                value: boolean;
+                status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+            }) => any;
+            "update:modelValue": (value: boolean) => any;
+        }, string, {
+            maxWidth: string;
+            status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+            color: string;
+            content: string;
+            disabled: boolean;
+            duration: string;
+            backgroundColor: string;
+            modelValue: boolean;
+            autoCollapse: boolean;
+            buttonWidth: string;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                'status-icon'?(_: {
+                    status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+                }): any;
+                label?(_: {
+                    status: import("vue-element-plus-x/./types/Thinking").ThinkingStatus;
+                }): any;
+                arrow?(_: {}): any;
+                content?(_: {
+                    content: string;
+                }): any;
+                error?(_: {
+                    errorContent: string;
+                }): any;
+            };
+        });
+        readonly Typewriter: import("vue").DefineComponent<import("vue-element-plus-x/./types/Typewriter").TypewriterProps, {
+            interrupt: () => void;
+            continue: () => void;
+            restart: () => void;
+            destroy: () => void;
+            renderedContent: import("vue").ComputedRef<string>;
+            isTyping: Ref<boolean>;
+            progress: import("vue").ComputedRef<number>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            start: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
+            finish: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
+            writing: (instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any;
+        }, string, import("vue").PublicProps, Readonly<import("vue-element-plus-x/./types/Typewriter").TypewriterProps> & Readonly<{
+            onStart?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
+            onFinish?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
+            onWriting?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance) => any) | undefined;
+        }>, {
+            content: string;
+            isMarkdown: boolean;
+            typing: boolean | import("vue-element-plus-x/./types/Typewriter").TypingConfig;
+            isFog: boolean | import("vue-element-plus-x/./types/Typewriter").TypingFogfig;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {
+            typeWriterRef: HTMLDivElement;
+            markdownContentRef: HTMLDivElement;
+        }, HTMLDivElement>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        textToSpeech: {
+            type: import("vue").PropType<import("../../broadcasting-markdown/src/types").TextToSpeech>;
+        };
+        modules: {
+            type: import("vue").PropType<import("../../agent-chat-provider/src/types").BubbleItemModule[]>;
+            default: () => string[];
+        };
+    }>> & Readonly<{}>, {
+        modules: "Thinking"[];
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    readonly VkRenderer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        source: {
+            type: import("vue").PropType<import("@vunk/core/components/renderer/src/types").SourceItem[]>;
+            default: () => any[];
+        };
+        templateInstances: {
+            type: import("vue").PropType<Record<string, import("vue").ComponentInternalInstance>>;
+            default: any;
+        };
+        k: {
+            type: import("vue").PropType<(string | number)[]>;
+            default: () => any[];
+        };
+    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        source: {
+            type: import("vue").PropType<import("@vunk/core/components/renderer/src/types").SourceItem[]>;
+            default: () => any[];
+        };
+        templateInstances: {
+            type: import("vue").PropType<Record<string, import("vue").ComponentInternalInstance>>;
+            default: any;
+        };
+        k: {
+            type: import("vue").PropType<(string | number)[]>;
+            default: () => any[];
+        };
+    }>> & Readonly<{}>, {
+        source: import("@vunk/core/components/renderer/src/types").SourceItem[];
+        templateInstances: Record<string, import("vue").ComponentInternalInstance>;
+        k: (string | number)[];
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    readonly VkRendererTemplateInstancesProvider: import("vue").DefineComponent<{}, (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[]) | (() => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>[][]), {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    readonly VkSpreadTo: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<import("@vunk/core").NormalObject>;
+            required: boolean;
+        };
+        type: {
+            type: import("vue").PropType<"class" | "style">;
+            default: string;
+        };
+        target: {
+            type: import("vue").PropType<import("@vunk/core").AnyFunc>;
+            default: (e: any) => any;
+        };
+    }>, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        data: {
+            type: import("vue").PropType<import("@vunk/core").NormalObject>;
+            required: boolean;
+        };
+        type: {
+            type: import("vue").PropType<"class" | "style">;
+            default: string;
+        };
+        target: {
+            type: import("vue").PropType<import("@vunk/core").AnyFunc>;
+            default: (e: any) => any;
+        };
+    }>> & Readonly<{}>, {
+        type: "class" | "style";
+        target: import("@vunk/core").AnyFunc;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    readonly ElAutoResizer: import("element-plus/es/utils").SFCWithInstall<import("vue").DefineComponent<{
+        readonly disableWidth: BooleanConstructor;
+        readonly disableHeight: BooleanConstructor;
+        readonly onResize: {
+            readonly type: import("vue").PropType<(event: {
+                height: number;
+                width: number;
+            }) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly disableWidth: BooleanConstructor;
+        readonly disableHeight: BooleanConstructor;
+        readonly onResize: {
+            readonly type: import("vue").PropType<(event: {
+                height: number;
+                width: number;
+            }) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>>, {
+        readonly disableWidth: boolean;
+        readonly disableHeight: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>> & Record<string, any>;
+    readonly BubbleList: <T extends import("vue-element-plus-x/./types/Bubble").BubbleProps>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+        slots: {
+            avatar?(_: {
+                item: T;
+            }): any;
+            header?(_: {
+                item: T;
+            }): any;
+            content?(_: {
+                item: T;
+            }): any;
+            footer?(_: {
+                item: T;
+            }): any;
+            loading?(_: {
+                item: T;
+            }): any;
+            backToBottom?(_: {}): any;
+        };
+        emit: import("vue-element-plus-x/./types/BubbleList").BubbleListEmits;
+        attrs: any;
+    }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: {
+            readonly onComplete?: ((instance: import("vue-element-plus-x/./types/Typewriter").TypewriterInstance, index: number) => any) | undefined | undefined;
+            list: T[];
+            maxHeight?: string | undefined;
+            triggerIndices?: "only-last" | "all" | number[] | undefined;
+            showBackButton?: boolean | undefined;
+            backButtonThreshold?: number | undefined;
+            backButtonPosition?: import("vue-element-plus-x/./types/BubbleList").BackButtonPosition | undefined;
+            alwaysShowScrollbar?: boolean | undefined;
+            btnLoading?: boolean | undefined;
+            btnColor?: string | undefined;
+            btnIconSize?: number | undefined;
+        } & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{
+            scrollToTop: () => void;
+            scrollToBottom: () => void;
+            scrollToBubble: (index: number) => void;
+        }>): void;
+        attrs: any;
+        slots: {
+            avatar?(_: {
+                item: T;
+            }): any;
+            header?(_: {
+                item: T;
+            }): any;
+            content?(_: {
+                item: T;
+            }): any;
+            footer?(_: {
+                item: T;
+            }): any;
+            loading?(_: {
+                item: T;
+            }): any;
+            backToBottom?(_: {}): any;
+        };
+        emit: import("vue-element-plus-x/./types/BubbleList").BubbleListEmits;
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    items: {
+        type: {
+            (arrayLength: number): any[];
+            (...items: any[]): any[];
+            new (arrayLength: number): any[];
+            new (...items: any[]): any[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            from<T>(iterable: Iterable<T> | ArrayLike<T>): T[];
+            from<T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[];
+            of<T>(...items: T[]): T[];
+            fromAsync<T>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T | PromiseLike<T>> | ArrayLike<T | PromiseLike<T>>): Promise<T[]>;
+            fromAsync<T, U>(iterableOrArrayLike: AsyncIterable<T> | Iterable<T> | ArrayLike<T>, mapFn: (value: Awaited<T>, index: number) => U, thisArg?: any): Promise<Awaited<U>[]>;
+            readonly [Symbol.species]: ArrayConstructor;
+        };
+        default: () => never[];
+    };
+    elRef: {
+        type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
+        default: import("@vunk/shared").AnyFunc;
+    };
+    textToSpeech: {
+        type: import("vue").PropType<import("../../broadcasting-markdown/src/types").TextToSpeech>;
+    };
+}>> & Readonly<{}>, {
+    items: any[];
+    elRef: import("@vunk/shared").AnyFunc;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;