@vunk/plus 1.8.3 → 1.8.4

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

@@ -0,0 +1,1582 @@
+import type { __VkAgentChatProvider } from '@vunk/plus/components/agent-chat-provider';
+import type { PropType, TeleportProps } from 'vue';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    list: {
+        type: PropType<__VkAgentChatProvider.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: 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: PropType<TeleportProps["to"]>;
+        default: undefined;
+    };
+}>, {
+    props: import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        list: {
+            type: PropType<__VkAgentChatProvider.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: 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: PropType<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: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly distance: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly height: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: BooleanConstructor;
+            readonly wrapStyle: {
+                readonly type: PropType<import("vue").StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: 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: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: 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: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly distance: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly height: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly native: BooleanConstructor;
+        readonly wrapStyle: {
+            readonly type: PropType<import("vue").StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly wrapClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewStyle: {
+            readonly type: 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: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "div";
+        };
+        readonly always: BooleanConstructor;
+        readonly minSize: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 20;
+        };
+        readonly tabindex: {
+            readonly type: 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;
+        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: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly distance: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            readonly height: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: BooleanConstructor;
+            readonly wrapStyle: {
+                readonly type: PropType<import("vue").StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: 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: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: 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: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly distance: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        readonly height: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly native: BooleanConstructor;
+        readonly wrapStyle: {
+            readonly type: PropType<import("vue").StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly wrapClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewStyle: {
+            readonly type: 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: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "div";
+        };
+        readonly always: BooleanConstructor;
+        readonly minSize: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 20;
+        };
+        readonly tabindex: {
+            readonly type: 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: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        distance: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        height: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        native: BooleanConstructor;
+        wrapStyle: {
+            readonly type: PropType<import("vue").StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        wrapClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        viewClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        viewStyle: {
+            readonly type: PropType<string | Record<string, any> | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        noresize: BooleanConstructor;
+        tag: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "div";
+        };
+        always: BooleanConstructor;
+        minSize: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 20;
+        };
+        tabindex: {
+            readonly type: 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: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            distance: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            height: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            maxHeight: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            native: BooleanConstructor;
+            wrapStyle: {
+                readonly type: PropType<import("vue").StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            wrapClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            viewClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            viewStyle: {
+                readonly type: PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            noresize: BooleanConstructor;
+            tag: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            always: BooleanConstructor;
+            minSize: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            tabindex: {
+                readonly type: 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: 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: 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: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        distance: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        height: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        native: BooleanConstructor;
+        wrapStyle: {
+            readonly type: PropType<import("vue").StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        wrapClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        viewClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        viewStyle: {
+            readonly type: PropType<string | Record<string, any> | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        noresize: BooleanConstructor;
+        tag: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "div";
+        };
+        always: BooleanConstructor;
+        minSize: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 20;
+        };
+        tabindex: {
+            readonly type: 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: PropType<__VkAgentChatProvider.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: 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: PropType<TeleportProps["to"]>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onComplete?: ((...args: any[]) => any) | undefined;
+}>, {
+    maxHeight: string;
+    list: __VkAgentChatProvider.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>;
+export default _default;