@vunk/plus 1.8.3 → 1.8.4

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

@@ -23,6 +23,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
         default: import("@vunk/shared").AnyFunc;
     };
+    scrollbarAppendTo: null;
 }>, {
     getContentWraper: (e: VNode) => import("vue").RendererNode | null;
     readonly VkBubbleRenderer: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
@@ -390,69 +391,1585 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         readonly disableWidth: boolean;
         readonly disableHeight: boolean;
     }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
-    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<{
+    BubbleList: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        list: {
+            type: import("vue").PropType<import("../../agent-chat-provider/src/types").BubbleItem[]>;
+            default: () => never[];
+        };
+        autoScroll: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxHeight: {
+            type: StringConstructor;
+            default: string;
+        };
+        alwaysShowScrollbar: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        backButtonThreshold: {
+            type: NumberConstructor;
+            default: number;
+        };
+        showBackButton: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        backButtonPosition: {
+            type: import("vue").PropType<{
+                bottom: string;
+                left: string;
+            }>;
+            default: () => {
+                bottom: string;
+                left: string;
+            };
+        };
+        btnLoading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        btnColor: {
+            type: StringConstructor;
+            default: string;
+        };
+        btnIconSize: {
+            type: NumberConstructor;
+            default: number;
+        };
+        scrollbarAppendTo: {
+            type: import("vue").PropType<import("vue").TeleportProps["to"]>;
+            default: undefined;
+        };
+    }>, {
+        props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+            list: {
+                type: import("vue").PropType<import("../../agent-chat-provider/src/types").BubbleItem[]>;
+                default: () => never[];
+            };
+            autoScroll: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            maxHeight: {
+                type: StringConstructor;
+                default: string;
+            };
+            alwaysShowScrollbar: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            backButtonThreshold: {
+                type: NumberConstructor;
+                default: number;
+            };
+            showBackButton: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            backButtonPosition: {
+                type: import("vue").PropType<{
+                    bottom: string;
+                    left: string;
+                }>;
+                default: () => {
+                    bottom: string;
+                    left: string;
+                };
+            };
+            btnLoading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            btnColor: {
+                type: StringConstructor;
+                default: string;
+            };
+            btnIconSize: {
+                type: NumberConstructor;
+                default: number;
+            };
+            scrollbarAppendTo: {
+                type: import("vue").PropType<import("vue").TeleportProps["to"]>;
+                default: undefined;
+            };
+        }>> & Readonly<{
+            onComplete?: ((...args: any[]) => any) | undefined;
+        }> & {}>;
+        scrollbarRef: import("vue").Ref<({
+            scrollToBottom: () => void;
             scrollToTop: () => void;
+        } & {
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly height: string | number;
+                readonly maxHeight: string | number;
+                readonly always: boolean;
+                readonly tabindex: string | number;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly tag: string;
+                readonly native: boolean;
+                readonly noresize: boolean;
+            }> & Omit<{
+                readonly always: boolean;
+                readonly height: string | number;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly maxHeight: string | number;
+                readonly native: boolean;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly noresize: boolean;
+                readonly tag: string;
+                readonly ariaLabel?: string | undefined;
+                readonly ariaOrientation?: string | undefined;
+                readonly tabindex?: (string | number) | undefined;
+                readonly id?: string | undefined;
+                readonly role?: string | undefined;
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined | undefined;
+                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "always" | "height" | "minSize" | "distance" | "maxHeight" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "noresize" | "tag" | "tabindex">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "scroll", args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void) & ((event: "end-reached", direction: import("element-plus").ScrollbarDirection) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly ariaOrientation: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly distance: {
+                    readonly type: import("vue").PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly height: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly maxHeight: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly native: BooleanConstructor;
+                readonly wrapStyle: {
+                    readonly type: import("vue").PropType<import("vue").StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly wrapClass: {
+                    readonly type: import("vue").PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewClass: {
+                    readonly type: import("vue").PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewStyle: {
+                    readonly type: import("vue").PropType<string | Record<string, any> | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly noresize: BooleanConstructor;
+                readonly tag: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly always: BooleanConstructor;
+                readonly minSize: {
+                    readonly type: import("vue").PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 20;
+                };
+                readonly tabindex: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly id: StringConstructor;
+                readonly role: StringConstructor;
+            }>> & {
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+            }, {
+                wrapRef: import("vue").Ref<HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                scroll: (args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => void;
+                "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
+            }, string, {
+                readonly height: string | number;
+                readonly maxHeight: string | number;
+                readonly always: boolean;
+                readonly tabindex: string | number;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly tag: string;
+                readonly native: boolean;
+                readonly noresize: boolean;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly always: boolean;
+            readonly tabindex: string | number;
+            readonly minSize: number;
+            readonly distance: number;
+            readonly wrapStyle: import("vue").StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | Record<string, any> | unknown[];
+            readonly tag: string;
+            readonly native: boolean;
+            readonly noresize: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly distance: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly height: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: BooleanConstructor;
+            readonly wrapStyle: {
+                readonly type: import("vue").PropType<import("vue").StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: import("vue").PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly noresize: BooleanConstructor;
+            readonly tag: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & {
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+        }, "always" | "height" | "minSize" | "handleScroll" | "update" | "distance" | "maxHeight" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "noresize" | "tag" | "tabindex" | "wrapRef" | "scrollTo" | "setScrollTop" | "setScrollLeft"> & import("vue").ShallowUnwrapRef<{
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | undefined, ({
             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>;
-    };
+            scrollToTop: () => void;
+        } & {
+            $: import("vue").ComponentInternalInstance;
+            $data: {};
+            $props: Partial<{
+                readonly height: string | number;
+                readonly maxHeight: string | number;
+                readonly always: boolean;
+                readonly tabindex: string | number;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly tag: string;
+                readonly native: boolean;
+                readonly noresize: boolean;
+            }> & Omit<{
+                readonly always: boolean;
+                readonly height: string | number;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly maxHeight: string | number;
+                readonly native: boolean;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly noresize: boolean;
+                readonly tag: string;
+                readonly ariaLabel?: string | undefined;
+                readonly ariaOrientation?: string | undefined;
+                readonly tabindex?: (string | number) | undefined;
+                readonly id?: string | undefined;
+                readonly role?: string | undefined;
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined | undefined;
+                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined | undefined;
+            } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "always" | "height" | "minSize" | "distance" | "maxHeight" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "noresize" | "tag" | "tabindex">;
+            $attrs: {
+                [x: string]: unknown;
+            };
+            $refs: {
+                [x: string]: unknown;
+            };
+            $slots: Readonly<{
+                [name: string]: import("vue").Slot<any> | undefined;
+            }>;
+            $root: import("vue").ComponentPublicInstance | null;
+            $parent: import("vue").ComponentPublicInstance | null;
+            $host: Element | null;
+            $emit: ((event: "scroll", args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void) & ((event: "end-reached", direction: import("element-plus").ScrollbarDirection) => void);
+            $el: any;
+            $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+                readonly ariaLabel: StringConstructor;
+                readonly ariaOrientation: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly distance: {
+                    readonly type: import("vue").PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                readonly height: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly maxHeight: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly native: BooleanConstructor;
+                readonly wrapStyle: {
+                    readonly type: import("vue").PropType<import("vue").StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly wrapClass: {
+                    readonly type: import("vue").PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewClass: {
+                    readonly type: import("vue").PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly viewStyle: {
+                    readonly type: import("vue").PropType<string | Record<string, any> | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                readonly noresize: BooleanConstructor;
+                readonly tag: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                readonly always: BooleanConstructor;
+                readonly minSize: {
+                    readonly type: import("vue").PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 20;
+                };
+                readonly tabindex: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                readonly id: StringConstructor;
+                readonly role: StringConstructor;
+            }>> & {
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+            }, {
+                wrapRef: import("vue").Ref<HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                scroll: (args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => void;
+                "end-reached": (direction: import("element-plus").ScrollbarDirection) => void;
+            }, string, {
+                readonly height: string | number;
+                readonly maxHeight: string | number;
+                readonly always: boolean;
+                readonly tabindex: string | number;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: string | unknown[];
+                readonly viewClass: string | unknown[];
+                readonly viewStyle: string | Record<string, any> | unknown[];
+                readonly tag: string;
+                readonly native: boolean;
+                readonly noresize: boolean;
+            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").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: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+                errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+            };
+            $forceUpdate: () => void;
+            $nextTick: typeof import("vue").nextTick;
+            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+        } & Readonly<{
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly always: boolean;
+            readonly tabindex: string | number;
+            readonly minSize: number;
+            readonly distance: number;
+            readonly wrapStyle: import("vue").StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | Record<string, any> | unknown[];
+            readonly tag: string;
+            readonly native: boolean;
+            readonly noresize: boolean;
+        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly distance: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly height: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: BooleanConstructor;
+            readonly wrapStyle: {
+                readonly type: import("vue").PropType<import("vue").StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: import("vue").PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly noresize: BooleanConstructor;
+            readonly tag: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & {
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+        }, "always" | "height" | "minSize" | "handleScroll" | "update" | "distance" | "maxHeight" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "noresize" | "tag" | "tabindex" | "wrapRef" | "scrollTo" | "setScrollTop" | "setScrollLeft"> & import("vue").ShallowUnwrapRef<{
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }> & {} & import("vue").ComponentCustomProperties & {} & {
+            $slots: {
+                default?(_: {}): any;
+            };
+        }) | undefined>;
+        initStyle: () => void;
+        distanceToBottom: import("vue").Ref<number | undefined, number | undefined>;
+        btnShow: import("vue").ComputedRef<boolean>;
+        getDistanceToBottom: () => void;
+        scrollToBottom: () => void;
+        scrollToBubble: (index: number) => void;
+        readonly ArrowDownBold: 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 VkScrollbar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            appendTo: null;
+            ariaLabel: StringConstructor;
+            ariaOrientation: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            distance: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            height: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            maxHeight: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            native: BooleanConstructor;
+            wrapStyle: {
+                readonly type: import("vue").PropType<import("vue").StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            wrapClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            viewClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            viewStyle: {
+                readonly type: import("vue").PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            noresize: BooleanConstructor;
+            tag: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            always: BooleanConstructor;
+            minSize: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            tabindex: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            id: StringConstructor;
+            role: StringConstructor;
+        }>, {
+            props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                appendTo: null;
+                ariaLabel: StringConstructor;
+                ariaOrientation: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                distance: {
+                    readonly type: import("vue").PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                height: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                maxHeight: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                native: BooleanConstructor;
+                wrapStyle: {
+                    readonly type: import("vue").PropType<import("vue").StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                wrapClass: {
+                    readonly type: import("vue").PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                viewClass: {
+                    readonly type: import("vue").PropType<string | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                viewStyle: {
+                    readonly type: import("vue").PropType<string | Record<string, any> | unknown[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                noresize: BooleanConstructor;
+                tag: {
+                    readonly type: import("vue").PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "div";
+                };
+                always: BooleanConstructor;
+                minSize: {
+                    readonly type: import("vue").PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 20;
+                };
+                tabindex: {
+                    readonly type: import("vue").PropType<string | number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                id: StringConstructor;
+                role: StringConstructor;
+            }>> & Readonly<{
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+            }> & {}>;
+            emit: ((event: "scroll", args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void) & ((event: "end-reached", direction: import("element-plus").ScrollbarDirection) => void);
+            COMPONENT_NAME: string;
+            ns: {
+                namespace: import("vue").ComputedRef<string>;
+                b: (blockSuffix?: string) => string;
+                e: (element?: string) => string;
+                m: (modifier?: string) => string;
+                be: (blockSuffix?: string, element?: string) => string;
+                em: (element?: string, modifier?: string) => string;
+                bm: (blockSuffix?: string, modifier?: string) => string;
+                bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+            };
+            stopResizeObserver: (() => void) | undefined;
+            stopWrapResizeObserver: (() => void) | undefined;
+            stopResizeListener: (() => void) | undefined;
+            wrapScrollTop: number;
+            wrapScrollLeft: number;
+            direction: import("element-plus").ScrollbarDirection;
+            distanceScrollState: {
+                bottom: boolean;
+                top: boolean;
+                right: boolean;
+                left: boolean;
+            };
+            scrollbarRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            resizeRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+            barRef: import("vue").Ref<import("../../scrollbar/src/bar").BarInstance | undefined, import("../../scrollbar/src/bar").BarInstance | undefined>;
+            wrapStyle: import("vue").ComputedRef<import("vue").StyleValue>;
+            wrapKls: import("vue").ComputedRef<(string | unknown[] | {
+                [x: string]: boolean;
+            })[]>;
+            resizeKls: import("vue").ComputedRef<(string | unknown[])[]>;
+            shouldSkipDirection: (direction: import("element-plus").ScrollbarDirection) => boolean;
+            DIRECTION_PAIRS: Record<import("element-plus").ScrollbarDirection, import("element-plus").ScrollbarDirection>;
+            updateTriggerStatus: (arrivedStates: Record<string, boolean>) => void;
+            handleScroll: () => void;
+            scrollTo: (arg1: any, arg2?: number) => void;
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            update: () => void;
+            scrollToBottom: (options?: ScrollToOptions) => void;
+            scrollToTop: (options?: ScrollToOptions) => void;
+            readonly VkAsyncTeleport: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                to: {
+                    type: import("vue").PropType<string | import("vue").RendererElement>;
+                    default: any;
+                };
+                sleep: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                await: {
+                    type: PromiseConstructor;
+                    default: any;
+                };
+                teleport: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                ready: import("vue").Ref<boolean, boolean>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                to: {
+                    type: import("vue").PropType<string | import("vue").RendererElement>;
+                    default: any;
+                };
+                sleep: {
+                    type: NumberConstructor;
+                    default: number;
+                };
+                await: {
+                    type: PromiseConstructor;
+                    default: any;
+                };
+                teleport: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                to: string | import("vue").RendererElement;
+                sleep: number;
+                await: Promise<unknown>;
+                teleport: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            Bar: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                always: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                minSize: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+            }>, {
+                props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                    always: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    minSize: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                }>> & Readonly<{}> & {}>;
+                scrollbar: import("element-plus").ScrollbarContext | undefined;
+                moveX: import("vue").Ref<number, number>;
+                moveY: import("vue").Ref<number, number>;
+                sizeWidth: import("vue").Ref<string, string>;
+                sizeHeight: import("vue").Ref<string, string>;
+                ratioY: import("vue").Ref<number, number>;
+                ratioX: import("vue").Ref<number, number>;
+                handleScroll: (wrap: HTMLDivElement) => void;
+                update: () => void;
+                Thumb: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                    vertical: BooleanConstructor;
+                    size: StringConstructor;
+                    move: NumberConstructor;
+                    ratio: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    always: BooleanConstructor;
+                }>, {
+                    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+                        vertical: BooleanConstructor;
+                        size: StringConstructor;
+                        move: NumberConstructor;
+                        ratio: {
+                            type: NumberConstructor;
+                            required: true;
+                        };
+                        always: BooleanConstructor;
+                    }>> & Readonly<{}> & {}>;
+                    scrollbar: import("element-plus").ScrollbarContext;
+                    ns: {
+                        namespace: import("vue").ComputedRef<string>;
+                        b: (blockSuffix?: string) => string;
+                        e: (element?: string) => string;
+                        m: (modifier?: string) => string;
+                        be: (blockSuffix?: string, element?: string) => string;
+                        em: (element?: string, modifier?: string) => string;
+                        bm: (blockSuffix?: string, modifier?: string) => string;
+                        bem: (blockSuffix?: string, element?: string, modifier?: string) => 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;
+                    };
+                    instance: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                    thumb: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                    thumbState: import("vue").Ref<{
+                        X?: number | undefined;
+                        Y?: number | undefined;
+                    }, Partial<Record<"X" | "Y", number>> | {
+                        X?: number | undefined;
+                        Y?: number | undefined;
+                    }>;
+                    visible: import("vue").Ref<boolean, boolean>;
+                    cursorDown: boolean;
+                    cursorLeave: boolean;
+                    baseScrollHeight: number;
+                    baseScrollWidth: number;
+                    originalOnSelectStart: ((this: GlobalEventHandlers, ev: Event) => any) | null;
+                    bar: import("vue").ComputedRef<{
+                        readonly offset: "offsetHeight";
+                        readonly scroll: "scrollTop";
+                        readonly scrollSize: "scrollHeight";
+                        readonly size: "height";
+                        readonly key: "vertical";
+                        readonly axis: "Y";
+                        readonly client: "clientY";
+                        readonly direction: "top";
+                    } | {
+                        readonly offset: "offsetWidth";
+                        readonly scroll: "scrollLeft";
+                        readonly scrollSize: "scrollWidth";
+                        readonly size: "width";
+                        readonly key: "horizontal";
+                        readonly axis: "X";
+                        readonly client: "clientX";
+                        readonly direction: "left";
+                    }>;
+                    thumbStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+                    offsetRatio: import("vue").ComputedRef<number>;
+                    clickThumbHandler: (e: MouseEvent) => void;
+                    clickTrackHandler: (e: MouseEvent) => void;
+                    startDrag: (e: MouseEvent) => void;
+                    mouseMoveDocumentHandler: (e: MouseEvent) => void;
+                    mouseUpDocumentHandler: () => void;
+                    mouseMoveScrollbarHandler: () => void;
+                    mouseLeaveScrollbarHandler: () => void;
+                    restoreOnselectstart: () => void;
+                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                    vertical: BooleanConstructor;
+                    size: StringConstructor;
+                    move: NumberConstructor;
+                    ratio: {
+                        type: NumberConstructor;
+                        required: true;
+                    };
+                    always: BooleanConstructor;
+                }>> & Readonly<{}>, {
+                    vertical: boolean;
+                    always: boolean;
+                }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                always: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                minSize: {
+                    type: NumberConstructor;
+                    required: true;
+                };
+            }>> & Readonly<{}>, {
+                always: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "end-reached": (direction: import("element-plus").ScrollbarDirection) => boolean;
+            scroll: ({ scrollTop, scrollLeft, }: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => boolean;
+        }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            appendTo: null;
+            ariaLabel: StringConstructor;
+            ariaOrientation: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            distance: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            height: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            maxHeight: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            native: BooleanConstructor;
+            wrapStyle: {
+                readonly type: import("vue").PropType<import("vue").StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            wrapClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            viewClass: {
+                readonly type: import("vue").PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            viewStyle: {
+                readonly type: import("vue").PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            noresize: BooleanConstructor;
+            tag: {
+                readonly type: import("vue").PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            always: BooleanConstructor;
+            minSize: {
+                readonly type: import("vue").PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            tabindex: {
+                readonly type: import("vue").PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            id: StringConstructor;
+            role: StringConstructor;
+        }>> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("element-plus").ScrollbarDirection) => any) | undefined;
+        }>, {
+            always: boolean;
+            height: string | number;
+            minSize: number;
+            distance: number;
+            maxHeight: string | number;
+            native: boolean;
+            wrapStyle: import("vue").StyleValue;
+            wrapClass: string | unknown[];
+            viewClass: string | unknown[];
+            viewStyle: string | Record<string, any> | unknown[];
+            noresize: boolean;
+            tag: string;
+            tabindex: string | number;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        readonly Bubble: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & 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;
+                onAvatarError?: ((e: Event) => any) | undefined;
+            }>, {
+                interrupt: () => void;
+                continue: () => void;
+                restart: () => void;
+                destroy: () => void;
+                renderedContent: ComputedRef<string>;
+                isTyping: Ref<boolean>;
+                progress: 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;
+                avatarError: (e: Event) => any;
+            }, import("vue").PublicProps, {
+                maxWidth: string;
+                noStyle: boolean;
+                content: string;
+                placement: "start" | "end";
+                avatar: string;
+                variant: "filled" | "borderless" | "outlined" | "shadow";
+                avatarSize: string;
+                avatarGap: string;
+                avatarShape: "circle" | "square";
+                avatarSrcSet: string;
+                avatarAlt: string;
+                avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
+                typewriterRef: import("vue").CreateComponentPublicInstanceWithMixins<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;
+                }>, {
+                    interrupt: () => void;
+                    continue: () => void;
+                    restart: () => void;
+                    destroy: () => void;
+                    renderedContent: ComputedRef<string>;
+                    isTyping: Ref<boolean>;
+                    progress: 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;
+                }, import("vue").PublicProps, {
+                    content: string;
+                    isMarkdown: boolean;
+                    typing: boolean | import("vue-element-plus-x/./types/Typewriter").TypingConfig;
+                    isFog: boolean | import("vue-element-plus-x/./types/Typewriter").TypingFogfig;
+                }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {
+                    typeWriterRef: HTMLDivElement;
+                    markdownContentRef: HTMLDivElement;
+                }, HTMLDivElement, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, 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;
+                }>, {
+                    interrupt: () => void;
+                    continue: () => void;
+                    restart: () => void;
+                    destroy: () => void;
+                    renderedContent: ComputedRef<string>;
+                    isTyping: Ref<boolean>;
+                    progress: ComputedRef<number>;
+                }, {}, {}, {}, {
+                    content: string;
+                    isMarkdown: boolean;
+                    typing: boolean | import("vue-element-plus-x/./types/Typewriter").TypingConfig;
+                    isFog: boolean | import("vue-element-plus-x/./types/Typewriter").TypingFogfig;
+                }> | null;
+            }, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & 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;
+                onAvatarError?: ((e: Event) => any) | undefined;
+            }>, {
+                interrupt: () => void;
+                continue: () => void;
+                restart: () => void;
+                destroy: () => void;
+                renderedContent: ComputedRef<string>;
+                isTyping: Ref<boolean>;
+                progress: ComputedRef<number>;
+            }, {}, {}, {}, {
+                maxWidth: string;
+                noStyle: boolean;
+                content: string;
+                placement: "start" | "end";
+                avatar: string;
+                variant: "filled" | "borderless" | "outlined" | "shadow";
+                avatarSize: string;
+                avatarGap: string;
+                avatarShape: "circle" | "square";
+                avatarSrcSet: string;
+                avatarAlt: string;
+                avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue-element-plus-x/./types/Bubble").BubbleProps> & 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;
+            onAvatarError?: ((e: Event) => any) | undefined;
+        }>, {
+            interrupt: () => void;
+            continue: () => void;
+            restart: () => void;
+            destroy: () => void;
+            renderedContent: ComputedRef<string>;
+            isTyping: Ref<boolean>;
+            progress: 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;
+            avatarError: (e: Event) => any;
+        }, string, {
+            maxWidth: string;
+            noStyle: boolean;
+            content: string;
+            placement: "start" | "end";
+            avatar: string;
+            variant: "filled" | "borderless" | "outlined" | "shadow";
+            avatarSize: string;
+            avatarGap: string;
+            avatarShape: "circle" | "square";
+            avatarSrcSet: string;
+            avatarAlt: string;
+            avatarFit: "cover" | "contain" | "fill" | "none" | "scale-down";
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                avatar?(_: {}): any;
+                header?(_: {}): any;
+                content?(_: {}): any;
+                loading?(_: {}): any;
+                footer?(_: {}): any;
+            };
+        });
+        loadingBg: {
+            new (...args: any[]): any;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<Record<string | symbol, any>>>, Record<string | symbol, any>, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            [x: string]: any;
+            [x: symbol]: any;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+            install(app: import("vue").App): void;
+        };
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        complete: null;
+    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        list: {
+            type: import("vue").PropType<import("../../agent-chat-provider/src/types").BubbleItem[]>;
+            default: () => never[];
+        };
+        autoScroll: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        maxHeight: {
+            type: StringConstructor;
+            default: string;
+        };
+        alwaysShowScrollbar: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        backButtonThreshold: {
+            type: NumberConstructor;
+            default: number;
+        };
+        showBackButton: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        backButtonPosition: {
+            type: import("vue").PropType<{
+                bottom: string;
+                left: string;
+            }>;
+            default: () => {
+                bottom: string;
+                left: string;
+            };
+        };
+        btnLoading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        btnColor: {
+            type: StringConstructor;
+            default: string;
+        };
+        btnIconSize: {
+            type: NumberConstructor;
+            default: number;
+        };
+        scrollbarAppendTo: {
+            type: import("vue").PropType<import("vue").TeleportProps["to"]>;
+            default: undefined;
+        };
+    }>> & Readonly<{
+        onComplete?: ((...args: any[]) => any) | undefined;
+    }>, {
+        maxHeight: string;
+        list: import("../../agent-chat-provider/src/types").BubbleItem[];
+        autoScroll: boolean;
+        alwaysShowScrollbar: boolean;
+        backButtonThreshold: number;
+        showBackButton: boolean;
+        backButtonPosition: {
+            bottom: string;
+            left: string;
+        };
+        btnLoading: boolean;
+        btnColor: string;
+        btnIconSize: number;
+        scrollbarAppendTo: string | import("vue").RendererElement | null | undefined;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     items: {
         type: {
@@ -477,6 +1994,7 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         type: import("vue").PropType<import("@vunk/shared").AnyFunc>;
         default: import("@vunk/shared").AnyFunc;
     };
+    scrollbarAppendTo: null;
 }>> & Readonly<{}>, {
     items: any[];
     elRef: import("@vunk/shared").AnyFunc;