ep-craft 0.1.33 → 0.1.34

package/dist/components/dropdown/index.d.ts

@@ -1,4 +1,3018 @@
-import type { Plugin } from 'vue';
-import { ElDropdown } from 'element-plus';
-export declare const EpDropdown: typeof ElDropdown & Plugin;
+export declare const EpDropdownItem: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly divided: BooleanConstructor;
+        readonly textValue: StringConstructor;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        onPointerleave?: ((...args: any[]) => any) | undefined;
+        onPointermove?: ((...args: any[]) => any) | undefined;
+    }>, {
+        handleClick: (event: PointerEvent) => void;
+        handlePointerMove: (event: PointerEvent) => void;
+        handlePointerLeave: (event: PointerEvent) => void;
+        propsAndAttrs: import("vue").ComputedRef<{
+            class?: import("vue").ClassValue;
+            style?: import("vue").StyleValue;
+            disabled: boolean;
+            command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+            divided: boolean;
+            icon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown> | undefined;
+            textValue: string | undefined;
+            onClick: ((...args: any[]) => any) | undefined;
+            onPointerleave: ((...args: any[]) => any) | undefined;
+            onPointermove: ((...args: any[]) => any) | undefined;
+        }>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], import("vue").PublicProps, {
+        readonly disabled: boolean;
+        readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly divided: boolean;
+    }, true, {}, {}, {
+        ElRovingFocusItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            focusable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            active: BooleanConstructor;
+        }>, {
+            id: import("vue").Ref<string, string>;
+            handleKeydown: (event: Event) => void;
+            handleFocus: (event: Event) => void;
+            handleMousedown: (event: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "keydown" | "mousedown")[], "focus" | "keydown" | "mousedown", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            focusable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            active: BooleanConstructor;
+        }>> & Readonly<{
+            onFocus?: ((...args: any[]) => any) | undefined;
+            onKeydown?: ((...args: any[]) => any) | undefined;
+            onMousedown?: ((...args: any[]) => any) | undefined;
+        }>, {
+            active: boolean;
+            focusable: boolean;
+        }, {}, {
+            ElRovingFocusCollectionItem: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                name: string;
+                setup(_: unknown, { attrs }: import("vue").SetupContext): void;
+            };
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElDropdownItemImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly divided: BooleanConstructor;
+            readonly textValue: StringConstructor;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>, {
+            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;
+            };
+            itemRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+            dataset: {
+                "data-el-collection-item": string;
+            };
+            role: import("vue").ComputedRef<string>;
+            tabIndex: import("vue").Ref<number, number>;
+            handleFocus: (e: Event) => void;
+            handleKeydown: (event: KeyboardEvent) => void;
+            handleMousedown: (e: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove" | "clickimpl")[], "click" | "pointerleave" | "pointermove" | "clickimpl", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly divided: BooleanConstructor;
+            readonly textValue: StringConstructor;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onPointerleave?: ((...args: any[]) => any) | undefined;
+            onPointermove?: ((...args: any[]) => any) | undefined;
+            onClickimpl?: ((...args: any[]) => any) | undefined;
+        }>, {
+            readonly disabled: boolean;
+            readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly divided: boolean;
+        }, {}, {
+            ElIcon: import("../../utils").SFCWithInstall<{
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            })>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly divided: BooleanConstructor;
+        readonly textValue: StringConstructor;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        onPointerleave?: ((...args: any[]) => any) | undefined;
+        onPointermove?: ((...args: any[]) => any) | undefined;
+    }>, {
+        handleClick: (event: PointerEvent) => void;
+        handlePointerMove: (event: PointerEvent) => void;
+        handlePointerLeave: (event: PointerEvent) => void;
+        propsAndAttrs: import("vue").ComputedRef<{
+            class?: import("vue").ClassValue;
+            style?: import("vue").StyleValue;
+            disabled: boolean;
+            command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+            divided: boolean;
+            icon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown> | undefined;
+            textValue: string | undefined;
+            onClick: ((...args: any[]) => any) | undefined;
+            onPointerleave: ((...args: any[]) => any) | undefined;
+            onPointermove: ((...args: any[]) => any) | undefined;
+        }>;
+    }, {}, {}, {}, {
+        readonly disabled: boolean;
+        readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly divided: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly divided: BooleanConstructor;
+    readonly textValue: StringConstructor;
+    readonly icon: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+    onPointerleave?: ((...args: any[]) => any) | undefined;
+    onPointermove?: ((...args: any[]) => any) | undefined;
+}>, {
+    handleClick: (event: PointerEvent) => void;
+    handlePointerMove: (event: PointerEvent) => void;
+    handlePointerLeave: (event: PointerEvent) => void;
+    propsAndAttrs: import("vue").ComputedRef<{
+        class?: import("vue").ClassValue;
+        style?: import("vue").StyleValue;
+        disabled: boolean;
+        command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        divided: boolean;
+        icon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown> | undefined;
+        textValue: string | undefined;
+        onClick: ((...args: any[]) => any) | undefined;
+        onPointerleave: ((...args: any[]) => any) | undefined;
+        onPointermove: ((...args: any[]) => any) | undefined;
+    }>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", {
+    readonly disabled: boolean;
+    readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+    readonly divided: boolean;
+}, {}, string, {}, {
+    ElRovingFocusItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        focusable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        active: BooleanConstructor;
+    }>, {
+        id: import("vue").Ref<string, string>;
+        handleKeydown: (event: Event) => void;
+        handleFocus: (event: Event) => void;
+        handleMousedown: (event: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "keydown" | "mousedown")[], "focus" | "keydown" | "mousedown", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        focusable: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        active: BooleanConstructor;
+    }>> & Readonly<{
+        onFocus?: ((...args: any[]) => any) | undefined;
+        onKeydown?: ((...args: any[]) => any) | undefined;
+        onMousedown?: ((...args: any[]) => any) | undefined;
+    }>, {
+        active: boolean;
+        focusable: boolean;
+    }, {}, {
+        ElRovingFocusCollectionItem: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+            name: string;
+            setup(_: unknown, { attrs }: import("vue").SetupContext): void;
+        };
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElDropdownItemImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly divided: BooleanConstructor;
+        readonly textValue: StringConstructor;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>, {
+        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;
+        };
+        itemRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+        dataset: {
+            "data-el-collection-item": string;
+        };
+        role: import("vue").ComputedRef<string>;
+        tabIndex: import("vue").Ref<number, number>;
+        handleFocus: (e: Event) => void;
+        handleKeydown: (event: KeyboardEvent) => void;
+        handleMousedown: (e: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove" | "clickimpl")[], "click" | "pointerleave" | "pointermove" | "clickimpl", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly divided: BooleanConstructor;
+        readonly textValue: StringConstructor;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        onPointerleave?: ((...args: any[]) => any) | undefined;
+        onPointermove?: ((...args: any[]) => any) | undefined;
+        onClickimpl?: ((...args: any[]) => any) | undefined;
+    }>, {
+        readonly disabled: boolean;
+        readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly divided: boolean;
+    }, {}, {
+        ElIcon: import("../../utils").SFCWithInstall<{
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        })>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+} & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
+export declare const EpDropdownMenu: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        onKeydown: {
+            readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{}>, {
+        size: import("vue").ComputedRef<string> | undefined;
+        rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue, import("vue").StyleValue>;
+        dropdownKls: import("vue").ComputedRef<string[]>;
+        role: import("vue").ComputedRef<"listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation" | undefined>;
+        triggerId: import("vue").ComputedRef<string>;
+        dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+        handleKeydown: (event: KeyboardEvent) => void;
+        onBlur: (e: Event) => void;
+        handleFocus: (e: FocusEvent) => void;
+        onMousedown: (e: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        onKeydown: {
+            readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{}>, {
+        size: import("vue").ComputedRef<string> | undefined;
+        rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue, import("vue").StyleValue>;
+        dropdownKls: import("vue").ComputedRef<string[]>;
+        role: import("vue").ComputedRef<"listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation" | undefined>;
+        triggerId: import("vue").ComputedRef<string>;
+        dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+        handleKeydown: (event: KeyboardEvent) => void;
+        onBlur: (e: Event) => void;
+        handleFocus: (e: FocusEvent) => void;
+        onMousedown: (e: Event) => void;
+    }, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+}>> & Readonly<{}>, {
+    size: import("vue").ComputedRef<string> | undefined;
+    rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue, import("vue").StyleValue>;
+    dropdownKls: import("vue").ComputedRef<string[]>;
+    role: import("vue").ComputedRef<"listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation" | undefined>;
+    triggerId: import("vue").ComputedRef<string>;
+    dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+    handleKeydown: (event: KeyboardEvent) => void;
+    onBlur: (e: Event) => void;
+    handleFocus: (e: FocusEvent) => void;
+    onMousedown: (e: Event) => void;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
+export declare const EpDropdown: ({
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly trigger: {
+            readonly type: import("vue").PropType<import("../../utils").Arrayable<"click" | "contextmenu" | "hover">>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            readonly __epPropKey: true;
+            readonly default: "hover";
+        };
+        readonly triggerKeys: import("../../utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | (((new (...args: any[]) => string[]) | (() => string[])) | null)[], unknown, unknown, () => string[], boolean>;
+        readonly virtualTriggering: BooleanConstructor;
+        readonly virtualRef: {
+            readonly type: import("vue").PropType<import("../popper").Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly effect: {
+            readonly default: "light";
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            readonly __epPropKey: true;
+        };
+        readonly type: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("../button").ButtonType) | (((new (...args: any[]) => "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("../button").ButtonType)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly placement: import("../../utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], unknown, unknown, "bottom", boolean>;
+        readonly popperOptions: import("../../utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+        readonly id: StringConstructor;
+        readonly size: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly splitButton: BooleanConstructor;
+        readonly hideOnClick: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly loop: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showArrow: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showTimeout: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+        readonly hideTimeout: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+        readonly tabindex: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+        readonly maxHeight: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, "", boolean>;
+        readonly popperClass: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly popperStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly role: import("../../utils").EpPropFinalized<StringConstructor, "listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation", unknown, "menu", boolean>;
+        readonly buttonProps: {
+            readonly type: import("vue").PropType<Partial<import("../button").ButtonProps>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly teleported: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly appendTo: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly persistent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        "onVisible-change"?: ((...args: any[]) => any) | undefined;
+        onCommand?: ((...args: any[]) => any) | undefined;
+    }>, {
+        t: import("../../hooks").Translator;
+        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;
+        };
+        scrollbar: import("vue").Ref<null, null>;
+        wrapStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+        dropdownTriggerKls: import("vue").ComputedRef<string[]>;
+        dropdownSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+        triggerId: import("vue").ComputedRef<string>;
+        currentTabId: import("vue").Ref<string | null, string | null>;
+        handleCurrentTabIdChange: (id: string) => void;
+        handlerMainButtonClick: (event: MouseEvent) => void;
+        handleClose: () => void;
+        handleOpen: () => void;
+        handleBeforeShowTooltip: () => void;
+        handleShowTooltip: (event?: Event) => void;
+        handleBeforeHideTooltip: () => void;
+        popperRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+        contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        triggeringElementRef: import("vue").Ref<any, any>;
+        referenceElementRef: import("vue").Ref<any, any>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "visible-change" | "command")[], import("vue").PublicProps, {
+        readonly size: string;
+        readonly maxHeight: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+        readonly disabled: boolean;
+        readonly tabindex: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+        readonly teleported: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly placement: import("../../utils").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], unknown, unknown>;
+        readonly effect: import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>;
+        readonly role: import("../../utils").EpPropMergeType<StringConstructor, "listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation", unknown>;
+        readonly trigger: import("../../utils").Arrayable<"click" | "contextmenu" | "hover">;
+        readonly virtualTriggering: boolean;
+        readonly loop: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly popperOptions: Partial<import("element-plus").Options>;
+        readonly popperStyle: import("vue").StyleValue;
+        readonly triggerKeys: string[];
+        readonly persistent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showArrow: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly hideOnClick: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showTimeout: number;
+        readonly hideTimeout: number;
+        readonly splitButton: boolean;
+    }, true, {}, {}, {
+        EpButton: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<"" | "large" | "default" | "small" | "mini">;
+                    readonly values: readonly ["", "large", "default", "small", "mini"];
+                };
+                readonly disabled: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly type: {
+                    readonly type: import("vue").PropType<typeof import("../button/button").buttonTypes[number]>;
+                    readonly values: readonly ["default", "primary", "success", "warning", "info", "danger", "text", ""];
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly type: import("vue").PropType<any>;
+                };
+                readonly nativeType: {
+                    readonly type: import("vue").PropType<typeof import("../button/button").buttonNativeTypes[number]>;
+                    readonly values: readonly ["button", "submit", "reset"];
+                    readonly default: "button";
+                };
+                readonly loading: BooleanConstructor;
+                readonly loadingIcon: {
+                    readonly type: import("vue").PropType<any>;
+                    readonly default: () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                };
+                readonly plain: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly text: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly link: BooleanConstructor;
+                readonly bg: BooleanConstructor;
+                readonly autofocus: BooleanConstructor;
+                readonly round: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly circle: BooleanConstructor;
+                readonly dashed: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly color: StringConstructor;
+                readonly dark: BooleanConstructor;
+                readonly autoInsertSpace: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly tag: {
+                    readonly type: import("vue").PropType<string | object>;
+                    readonly default: "button";
+                };
+            }>> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+                type: import("vue").ComputedRef<any>;
+                disabled: import("vue").ComputedRef<boolean>;
+                shouldAddSpace: import("vue").ComputedRef<boolean>;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                click: (evt: MouseEvent) => void;
+            }, import("vue").PublicProps, {
+                readonly link: boolean;
+                readonly text: boolean;
+                readonly round: boolean;
+                readonly dashed: boolean;
+                readonly dark: boolean;
+                readonly circle: boolean;
+                readonly disabled: boolean;
+                readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
+                readonly loading: boolean;
+                readonly tag: string | object;
+                readonly autofocus: boolean;
+                readonly nativeType: "button" | "reset" | "submit";
+                readonly loadingIcon: any;
+                readonly plain: boolean;
+                readonly bg: boolean;
+                readonly autoInsertSpace: boolean;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                readonly size: {
+                    readonly type: import("vue").PropType<"" | "large" | "default" | "small" | "mini">;
+                    readonly values: readonly ["", "large", "default", "small", "mini"];
+                };
+                readonly disabled: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly type: {
+                    readonly type: import("vue").PropType<typeof import("../button/button").buttonTypes[number]>;
+                    readonly values: readonly ["default", "primary", "success", "warning", "info", "danger", "text", ""];
+                    readonly default: "";
+                };
+                readonly icon: {
+                    readonly type: import("vue").PropType<any>;
+                };
+                readonly nativeType: {
+                    readonly type: import("vue").PropType<typeof import("../button/button").buttonNativeTypes[number]>;
+                    readonly values: readonly ["button", "submit", "reset"];
+                    readonly default: "button";
+                };
+                readonly loading: BooleanConstructor;
+                readonly loadingIcon: {
+                    readonly type: import("vue").PropType<any>;
+                    readonly default: () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+                };
+                readonly plain: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly text: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly link: BooleanConstructor;
+                readonly bg: BooleanConstructor;
+                readonly autofocus: BooleanConstructor;
+                readonly round: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly circle: BooleanConstructor;
+                readonly dashed: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly color: StringConstructor;
+                readonly dark: BooleanConstructor;
+                readonly autoInsertSpace: {
+                    readonly type: BooleanConstructor;
+                    readonly default: undefined;
+                };
+                readonly tag: {
+                    readonly type: import("vue").PropType<string | object>;
+                    readonly default: "button";
+                };
+            }>> & Readonly<{
+                onClick?: ((evt: MouseEvent) => any) | undefined;
+            }>, {
+                ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+                size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+                type: import("vue").ComputedRef<any>;
+                disabled: import("vue").ComputedRef<boolean>;
+                shouldAddSpace: import("vue").ComputedRef<boolean>;
+            }, {}, {}, {}, {
+                readonly link: boolean;
+                readonly text: boolean;
+                readonly round: boolean;
+                readonly dashed: boolean;
+                readonly dark: boolean;
+                readonly circle: boolean;
+                readonly disabled: boolean;
+                readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
+                readonly loading: boolean;
+                readonly tag: string | object;
+                readonly autofocus: boolean;
+                readonly nativeType: "button" | "reset" | "submit";
+                readonly loadingIcon: any;
+                readonly plain: boolean;
+                readonly bg: boolean;
+                readonly autoInsertSpace: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<"" | "large" | "default" | "small" | "mini">;
+                readonly values: readonly ["", "large", "default", "small", "mini"];
+            };
+            readonly disabled: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly type: {
+                readonly type: import("vue").PropType<typeof import("../button/button").buttonTypes[number]>;
+                readonly values: readonly ["default", "primary", "success", "warning", "info", "danger", "text", ""];
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly type: import("vue").PropType<any>;
+            };
+            readonly nativeType: {
+                readonly type: import("vue").PropType<typeof import("../button/button").buttonNativeTypes[number]>;
+                readonly values: readonly ["button", "submit", "reset"];
+                readonly default: "button";
+            };
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: {
+                readonly type: import("vue").PropType<any>;
+                readonly default: () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            };
+            readonly plain: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly text: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly circle: BooleanConstructor;
+            readonly dashed: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly tag: {
+                readonly type: import("vue").PropType<string | object>;
+                readonly default: "button";
+            };
+        }>> & Readonly<{
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }>, {
+            ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+            size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+            type: import("vue").ComputedRef<any>;
+            disabled: import("vue").ComputedRef<boolean>;
+            shouldAddSpace: import("vue").ComputedRef<boolean>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+        }, string, {
+            readonly link: boolean;
+            readonly text: boolean;
+            readonly round: boolean;
+            readonly dashed: boolean;
+            readonly dark: boolean;
+            readonly circle: boolean;
+            readonly disabled: boolean;
+            readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
+            readonly loading: boolean;
+            readonly tag: string | object;
+            readonly autofocus: boolean;
+            readonly nativeType: "button" | "reset" | "submit";
+            readonly loadingIcon: any;
+            readonly plain: boolean;
+            readonly bg: boolean;
+            readonly autoInsertSpace: boolean;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                loading?: (props: {}) => any;
+            } & {
+                icon?: (props: {}) => any;
+            } & {
+                default?: (props: {}) => any;
+            };
+        }) & import("vue").Plugin;
+        EpButtonGroup: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../button-group").ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                direction: "horizontal" | "vertical";
+                type: import("../button").ButtonProps["type"];
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../button-group").ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+                direction: "horizontal" | "vertical";
+                type: import("../button").ButtonProps["type"];
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../button-group").ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+            direction: "horizontal" | "vertical";
+            type: import("../button").ButtonProps["type"];
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) & import("vue").Plugin;
+        ElScrollbar: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<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: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+                readonly height: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly maxHeight: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly native: BooleanConstructor;
+                readonly wrapStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+                readonly wrapClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+                readonly viewClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+                readonly viewStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+                readonly noresize: BooleanConstructor;
+                readonly tag: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+                readonly always: BooleanConstructor;
+                readonly minSize: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+                readonly tabindex: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+                readonly id: StringConstructor;
+                readonly role: StringConstructor;
+            }>> & Readonly<{
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+            }>, {
+                wrapRef: import("vue").Ref<HTMLDivElement | undefined, 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").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                scroll: (args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => void;
+                "end-reached": (direction: import("../scrollbar").ScrollbarDirection) => void;
+            }, import("vue").PublicProps, {
+                readonly always: boolean;
+                readonly height: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly maxHeight: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly tabindex: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly tag: string;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+                readonly viewClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+                readonly viewStyle: import("vue").StyleValue;
+                readonly native: boolean;
+                readonly noresize: boolean;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, 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: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+                readonly height: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly maxHeight: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+                readonly native: BooleanConstructor;
+                readonly wrapStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+                readonly wrapClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+                readonly viewClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+                readonly viewStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+                readonly noresize: BooleanConstructor;
+                readonly tag: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+                readonly always: BooleanConstructor;
+                readonly minSize: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+                readonly tabindex: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+                readonly id: StringConstructor;
+                readonly role: StringConstructor;
+            }>> & Readonly<{
+                onScroll?: ((args_0: {
+                    scrollTop: number;
+                    scrollLeft: number;
+                }) => any) | undefined;
+                "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+            }>, {
+                wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+                update: () => void;
+                scrollTo: {
+                    (xCord: number, yCord?: number): void;
+                    (options: ScrollToOptions): void;
+                };
+                setScrollTop: (value: number) => void;
+                setScrollLeft: (value: number) => void;
+                handleScroll: () => void;
+            }, {}, {}, {}, {
+                readonly always: boolean;
+                readonly height: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly maxHeight: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly tabindex: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly tag: string;
+                readonly minSize: number;
+                readonly distance: number;
+                readonly wrapStyle: import("vue").StyleValue;
+                readonly wrapClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+                readonly viewClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+                readonly viewStyle: import("vue").StyleValue;
+                readonly native: boolean;
+                readonly noresize: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & 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: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly height: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly maxHeight: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly native: BooleanConstructor;
+            readonly wrapStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+            readonly wrapClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+            readonly noresize: BooleanConstructor;
+            readonly tag: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly always: BooleanConstructor;
+            readonly minSize: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+            readonly tabindex: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+        }>, {
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined, 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").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: import("../scrollbar").ScrollbarDirection) => void;
+        }, string, {
+            readonly always: boolean;
+            readonly height: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly maxHeight: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly tabindex: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly tag: string;
+            readonly minSize: number;
+            readonly distance: number;
+            readonly wrapStyle: import("vue").StyleValue;
+            readonly wrapClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewStyle: import("vue").StyleValue;
+            readonly native: boolean;
+            readonly noresize: boolean;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) & import("vue").Plugin;
+        ElTooltip: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+                onHide?: ((...args: any[]) => any) | undefined;
+                onShow?: ((...args: any[]) => any) | undefined;
+                onOpen?: ((...args: any[]) => any) | undefined;
+                onClose?: ((...args: any[]) => any) | undefined;
+                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+                "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+                contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event, delay?: number) => void;
+                onClose: (event?: Event, delay?: number) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+                hide: (...args: any[]) => void;
+                show: (...args: any[]) => void;
+                open: (...args: any[]) => void;
+                close: (...args: any[]) => void;
+                "update:visible": (...args: any[]) => void;
+                "before-show": (...args: any[]) => void;
+                "before-hide": (...args: any[]) => void;
+            }, import("vue").PublicProps, {
+                content: string;
+                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                visible: boolean | null;
+                offset: number;
+                teleported: boolean;
+                placement: import("element-plus").Placement;
+                strategy: "fixed" | "absolute";
+                effect: import("../popper").PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                role: typeof import("../popper").roleTypes[number];
+                trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+                virtualTriggering: boolean;
+                loop: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                gpuAcceleration: boolean;
+                popperOptions: Partial<import("element-plus").Options>;
+                enterable: boolean;
+                pure: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                stopPopperMouseEvent: boolean;
+                triggerKeys: string[];
+                showArrow: boolean;
+            }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+                onHide?: ((...args: any[]) => any) | undefined;
+                onShow?: ((...args: any[]) => any) | undefined;
+                onOpen?: ((...args: any[]) => any) | undefined;
+                onClose?: ((...args: any[]) => any) | undefined;
+                "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+                "onBefore-show"?: ((...args: any[]) => any) | undefined;
+                "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+            }>, {
+                popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+                contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event, delay?: number) => void;
+                onClose: (event?: Event, delay?: number) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, {
+                content: string;
+                style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                visible: boolean | null;
+                offset: number;
+                teleported: boolean;
+                placement: import("element-plus").Placement;
+                strategy: "fixed" | "absolute";
+                effect: import("../popper").PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                role: typeof import("../popper").roleTypes[number];
+                trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+                virtualTriggering: boolean;
+                loop: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                gpuAcceleration: boolean;
+                popperOptions: Partial<import("element-plus").Options>;
+                enterable: boolean;
+                pure: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+                stopPopperMouseEvent: boolean;
+                triggerKeys: string[];
+                showArrow: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+            contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            open: (...args: any[]) => void;
+            close: (...args: any[]) => void;
+            "update:visible": (...args: any[]) => void;
+            "before-show": (...args: any[]) => void;
+            "before-hide": (...args: any[]) => void;
+        }, string, {
+            content: string;
+            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            visible: boolean | null;
+            offset: number;
+            teleported: boolean;
+            placement: import("element-plus").Placement;
+            strategy: "fixed" | "absolute";
+            effect: import("../popper").PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            role: typeof import("../popper").roleTypes[number];
+            trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+            virtualTriggering: boolean;
+            loop: boolean;
+            arrowOffset: number;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            popperOptions: Partial<import("element-plus").Options>;
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            triggerKeys: string[];
+            showArrow: boolean;
+        }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            } & {
+                content?: (props: {}) => any;
+            };
+        }) & import("vue").Plugin;
+        ElRovingFocusGroup: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+            ElFocusGroupCollection: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                name: string;
+                setup(): void;
+            };
+            ElRovingFocusGroupImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                style: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+                currentTabId: {
+                    readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                defaultCurrentTabId: StringConstructor;
+                loop: BooleanConstructor;
+                dir: import("../../utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+                orientation: {
+                    readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: FunctionConstructor;
+                onFocus: FunctionConstructor;
+                onMousedown: FunctionConstructor;
+            }>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("currentTabIdChange" | "entryFocus")[], "currentTabIdChange" | "entryFocus", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                style: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+                currentTabId: {
+                    readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                defaultCurrentTabId: StringConstructor;
+                loop: BooleanConstructor;
+                dir: import("../../utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+                orientation: {
+                    readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: FunctionConstructor;
+                onFocus: FunctionConstructor;
+                onMousedown: FunctionConstructor;
+            }>> & Readonly<{
+                onCurrentTabIdChange?: ((...args: any[]) => any) | undefined;
+                onEntryFocus?: ((...args: any[]) => any) | undefined;
+            }>, {
+                style: import("vue").StyleValue;
+                dir: string;
+                loop: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElOnlyChild: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+            [key: string]: any;
+        }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElIcon: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default?: (props: {}) => any;
+            };
+        }) & import("vue").Plugin;
+        ArrowDown: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly trigger: {
+            readonly type: import("vue").PropType<import("../../utils").Arrayable<"click" | "contextmenu" | "hover">>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            readonly __epPropKey: true;
+            readonly default: "hover";
+        };
+        readonly triggerKeys: import("../../utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | (((new (...args: any[]) => string[]) | (() => string[])) | null)[], unknown, unknown, () => string[], boolean>;
+        readonly virtualTriggering: BooleanConstructor;
+        readonly virtualRef: {
+            readonly type: import("vue").PropType<import("../popper").Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly effect: {
+            readonly default: "light";
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            readonly __epPropKey: true;
+        };
+        readonly type: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("../button").ButtonType) | (((new (...args: any[]) => "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("../button").ButtonType)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly placement: import("../../utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], unknown, unknown, "bottom", boolean>;
+        readonly popperOptions: import("../../utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+        readonly id: StringConstructor;
+        readonly size: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+        readonly splitButton: BooleanConstructor;
+        readonly hideOnClick: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly loop: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showArrow: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly showTimeout: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+        readonly hideTimeout: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+        readonly tabindex: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+        readonly maxHeight: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, "", boolean>;
+        readonly popperClass: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | (string | {
+                [x: string]: boolean;
+            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly popperStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly role: import("../../utils").EpPropFinalized<StringConstructor, "listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation", unknown, "menu", boolean>;
+        readonly buttonProps: {
+            readonly type: import("vue").PropType<Partial<import("../button").ButtonProps>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly teleported: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+        readonly appendTo: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly persistent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        "onVisible-change"?: ((...args: any[]) => any) | undefined;
+        onCommand?: ((...args: any[]) => any) | undefined;
+    }>, {
+        t: import("../../hooks").Translator;
+        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;
+        };
+        scrollbar: import("vue").Ref<null, null>;
+        wrapStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+        dropdownTriggerKls: import("vue").ComputedRef<string[]>;
+        dropdownSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+        triggerId: import("vue").ComputedRef<string>;
+        currentTabId: import("vue").Ref<string | null, string | null>;
+        handleCurrentTabIdChange: (id: string) => void;
+        handlerMainButtonClick: (event: MouseEvent) => void;
+        handleClose: () => void;
+        handleOpen: () => void;
+        handleBeforeShowTooltip: () => void;
+        handleShowTooltip: (event?: Event) => void;
+        handleBeforeHideTooltip: () => void;
+        popperRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+        contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        triggeringElementRef: import("vue").Ref<any, any>;
+        referenceElementRef: import("vue").Ref<any, any>;
+    }, {}, {}, {}, {
+        readonly size: string;
+        readonly maxHeight: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+        readonly disabled: boolean;
+        readonly tabindex: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+        readonly teleported: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly placement: import("../../utils").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], unknown, unknown>;
+        readonly effect: import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>;
+        readonly role: import("../../utils").EpPropMergeType<StringConstructor, "listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation", unknown>;
+        readonly trigger: import("../../utils").Arrayable<"click" | "contextmenu" | "hover">;
+        readonly virtualTriggering: boolean;
+        readonly loop: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly popperOptions: Partial<import("element-plus").Options>;
+        readonly popperStyle: import("vue").StyleValue;
+        readonly triggerKeys: string[];
+        readonly persistent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showArrow: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly hideOnClick: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+        readonly showTimeout: number;
+        readonly hideTimeout: number;
+        readonly splitButton: boolean;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly trigger: {
+        readonly type: import("vue").PropType<import("../../utils").Arrayable<"click" | "contextmenu" | "hover">>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+        readonly default: "hover";
+    };
+    readonly triggerKeys: import("../../utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | (((new (...args: any[]) => string[]) | (() => string[])) | null)[], unknown, unknown, () => string[], boolean>;
+    readonly virtualTriggering: BooleanConstructor;
+    readonly virtualRef: {
+        readonly type: import("vue").PropType<import("../popper").Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly effect: {
+        readonly default: "light";
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    readonly type: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("../button").ButtonType) | (((new (...args: any[]) => "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger") | (() => import("../button").ButtonType)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly placement: import("../../utils").EpPropFinalized<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], unknown, unknown, "bottom", boolean>;
+    readonly popperOptions: import("../../utils").EpPropFinalized<(new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>) | (((new (...args: any[]) => Partial<import("element-plus").Options>) | (() => Partial<import("element-plus").Options>)) | null)[], unknown, unknown, () => {}, boolean>;
+    readonly id: StringConstructor;
+    readonly size: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
+    readonly splitButton: BooleanConstructor;
+    readonly hideOnClick: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly loop: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showArrow: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly showTimeout: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly hideTimeout: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 150, boolean>;
+    readonly tabindex: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, 0, boolean>;
+    readonly maxHeight: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown, "", boolean>;
+    readonly popperClass: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (((new (...args: any[]) => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]) | (() => string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | (string | {
+            [x: string]: boolean;
+        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[])) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly popperStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+    readonly disabled: BooleanConstructor;
+    readonly role: import("../../utils").EpPropFinalized<StringConstructor, "listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation", unknown, "menu", boolean>;
+    readonly buttonProps: {
+        readonly type: import("vue").PropType<Partial<import("../button").ButtonProps>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly teleported: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    readonly appendTo: {
+        readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement) | (((new (...args: any[]) => string | HTMLElement) | (() => string | HTMLElement)) | null)[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly persistent: import("../../utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+}>> & Readonly<{
+    onClick?: ((...args: any[]) => any) | undefined;
+    "onVisible-change"?: ((...args: any[]) => any) | undefined;
+    onCommand?: ((...args: any[]) => any) | undefined;
+}>, {
+    t: import("../../hooks").Translator;
+    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;
+    };
+    scrollbar: import("vue").Ref<null, null>;
+    wrapStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+    dropdownTriggerKls: import("vue").ComputedRef<string[]>;
+    dropdownSize: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+    triggerId: import("vue").ComputedRef<string>;
+    currentTabId: import("vue").Ref<string | null, string | null>;
+    handleCurrentTabIdChange: (id: string) => void;
+    handlerMainButtonClick: (event: MouseEvent) => void;
+    handleClose: () => void;
+    handleOpen: () => void;
+    handleBeforeShowTooltip: () => void;
+    handleShowTooltip: (event?: Event) => void;
+    handleBeforeHideTooltip: () => void;
+    popperRef: import("vue").Ref<import("../tooltip").TooltipInstance | undefined, import("../tooltip").TooltipInstance | undefined>;
+    contentRef: import("vue").Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    triggeringElementRef: import("vue").Ref<any, any>;
+    referenceElementRef: import("vue").Ref<any, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "visible-change" | "command")[], "click" | "visible-change" | "command", {
+    readonly size: string;
+    readonly maxHeight: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+    readonly disabled: boolean;
+    readonly tabindex: import("../../utils").EpPropMergeType<(new (...args: any[]) => string | number) | (() => string | number) | (((new (...args: any[]) => string | number) | (() => string | number)) | null)[], unknown, unknown>;
+    readonly teleported: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly placement: import("../../utils").EpPropMergeType<(new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement) | (((new (...args: any[]) => "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end") | (() => import("element-plus").Placement)) | null)[], unknown, unknown>;
+    readonly effect: import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => import("../popper").PopperEffect) | (((new (...args: any[]) => string) | (() => import("../popper").PopperEffect)) | null)[], unknown, unknown>;
+    readonly role: import("../../utils").EpPropMergeType<StringConstructor, "listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation", unknown>;
+    readonly trigger: import("../../utils").Arrayable<"click" | "contextmenu" | "hover">;
+    readonly virtualTriggering: boolean;
+    readonly loop: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly popperOptions: Partial<import("element-plus").Options>;
+    readonly popperStyle: import("vue").StyleValue;
+    readonly triggerKeys: string[];
+    readonly persistent: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showArrow: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly hideOnClick: import("../../utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    readonly showTimeout: number;
+    readonly hideTimeout: number;
+    readonly splitButton: boolean;
+}, {}, string, {}, {
+    EpButton: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<"" | "large" | "default" | "small" | "mini">;
+                readonly values: readonly ["", "large", "default", "small", "mini"];
+            };
+            readonly disabled: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly type: {
+                readonly type: import("vue").PropType<typeof import("../button/button").buttonTypes[number]>;
+                readonly values: readonly ["default", "primary", "success", "warning", "info", "danger", "text", ""];
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly type: import("vue").PropType<any>;
+            };
+            readonly nativeType: {
+                readonly type: import("vue").PropType<typeof import("../button/button").buttonNativeTypes[number]>;
+                readonly values: readonly ["button", "submit", "reset"];
+                readonly default: "button";
+            };
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: {
+                readonly type: import("vue").PropType<any>;
+                readonly default: () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            };
+            readonly plain: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly text: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly circle: BooleanConstructor;
+            readonly dashed: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly tag: {
+                readonly type: import("vue").PropType<string | object>;
+                readonly default: "button";
+            };
+        }>> & Readonly<{
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }>, {
+            ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+            size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+            type: import("vue").ComputedRef<any>;
+            disabled: import("vue").ComputedRef<boolean>;
+            shouldAddSpace: import("vue").ComputedRef<boolean>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+        }, import("vue").PublicProps, {
+            readonly link: boolean;
+            readonly text: boolean;
+            readonly round: boolean;
+            readonly dashed: boolean;
+            readonly dark: boolean;
+            readonly circle: boolean;
+            readonly disabled: boolean;
+            readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
+            readonly loading: boolean;
+            readonly tag: string | object;
+            readonly autofocus: boolean;
+            readonly nativeType: "button" | "reset" | "submit";
+            readonly loadingIcon: any;
+            readonly plain: boolean;
+            readonly bg: boolean;
+            readonly autoInsertSpace: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            readonly size: {
+                readonly type: import("vue").PropType<"" | "large" | "default" | "small" | "mini">;
+                readonly values: readonly ["", "large", "default", "small", "mini"];
+            };
+            readonly disabled: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly type: {
+                readonly type: import("vue").PropType<typeof import("../button/button").buttonTypes[number]>;
+                readonly values: readonly ["default", "primary", "success", "warning", "info", "danger", "text", ""];
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly type: import("vue").PropType<any>;
+            };
+            readonly nativeType: {
+                readonly type: import("vue").PropType<typeof import("../button/button").buttonNativeTypes[number]>;
+                readonly values: readonly ["button", "submit", "reset"];
+                readonly default: "button";
+            };
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: {
+                readonly type: import("vue").PropType<any>;
+                readonly default: () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            };
+            readonly plain: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly text: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly circle: BooleanConstructor;
+            readonly dashed: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: {
+                readonly type: BooleanConstructor;
+                readonly default: undefined;
+            };
+            readonly tag: {
+                readonly type: import("vue").PropType<string | object>;
+                readonly default: "button";
+            };
+        }>> & Readonly<{
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }>, {
+            ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+            size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+            type: import("vue").ComputedRef<any>;
+            disabled: import("vue").ComputedRef<boolean>;
+            shouldAddSpace: import("vue").ComputedRef<boolean>;
+        }, {}, {}, {}, {
+            readonly link: boolean;
+            readonly text: boolean;
+            readonly round: boolean;
+            readonly dashed: boolean;
+            readonly dark: boolean;
+            readonly circle: boolean;
+            readonly disabled: boolean;
+            readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
+            readonly loading: boolean;
+            readonly tag: string | object;
+            readonly autofocus: boolean;
+            readonly nativeType: "button" | "reset" | "submit";
+            readonly loadingIcon: any;
+            readonly plain: boolean;
+            readonly bg: boolean;
+            readonly autoInsertSpace: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        readonly size: {
+            readonly type: import("vue").PropType<"" | "large" | "default" | "small" | "mini">;
+            readonly values: readonly ["", "large", "default", "small", "mini"];
+        };
+        readonly disabled: {
+            readonly type: BooleanConstructor;
+            readonly default: undefined;
+        };
+        readonly type: {
+            readonly type: import("vue").PropType<typeof import("../button/button").buttonTypes[number]>;
+            readonly values: readonly ["default", "primary", "success", "warning", "info", "danger", "text", ""];
+            readonly default: "";
+        };
+        readonly icon: {
+            readonly type: import("vue").PropType<any>;
+        };
+        readonly nativeType: {
+            readonly type: import("vue").PropType<typeof import("../button/button").buttonNativeTypes[number]>;
+            readonly values: readonly ["button", "submit", "reset"];
+            readonly default: "button";
+        };
+        readonly loading: BooleanConstructor;
+        readonly loadingIcon: {
+            readonly type: import("vue").PropType<any>;
+            readonly default: () => import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        };
+        readonly plain: {
+            readonly type: BooleanConstructor;
+            readonly default: undefined;
+        };
+        readonly text: {
+            readonly type: BooleanConstructor;
+            readonly default: undefined;
+        };
+        readonly link: BooleanConstructor;
+        readonly bg: BooleanConstructor;
+        readonly autofocus: BooleanConstructor;
+        readonly round: {
+            readonly type: BooleanConstructor;
+            readonly default: undefined;
+        };
+        readonly circle: BooleanConstructor;
+        readonly dashed: {
+            readonly type: BooleanConstructor;
+            readonly default: undefined;
+        };
+        readonly color: StringConstructor;
+        readonly dark: BooleanConstructor;
+        readonly autoInsertSpace: {
+            readonly type: BooleanConstructor;
+            readonly default: undefined;
+        };
+        readonly tag: {
+            readonly type: import("vue").PropType<string | object>;
+            readonly default: "button";
+        };
+    }>> & Readonly<{
+        onClick?: ((evt: MouseEvent) => any) | undefined;
+    }>, {
+        ref: import("vue").Ref<HTMLButtonElement | undefined, HTMLButtonElement | undefined>;
+        size: import("vue").ComputedRef<"" | "small" | "default" | "large">;
+        type: import("vue").ComputedRef<any>;
+        disabled: import("vue").ComputedRef<boolean>;
+        shouldAddSpace: import("vue").ComputedRef<boolean>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        click: (evt: MouseEvent) => void;
+    }, string, {
+        readonly link: boolean;
+        readonly text: boolean;
+        readonly round: boolean;
+        readonly dashed: boolean;
+        readonly dark: boolean;
+        readonly circle: boolean;
+        readonly disabled: boolean;
+        readonly type: "" | "default" | "text" | "primary" | "success" | "warning" | "info" | "danger";
+        readonly loading: boolean;
+        readonly tag: string | object;
+        readonly autofocus: boolean;
+        readonly nativeType: "button" | "reset" | "submit";
+        readonly loadingIcon: any;
+        readonly plain: boolean;
+        readonly bg: boolean;
+        readonly autoInsertSpace: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            loading?: (props: {}) => any;
+        } & {
+            icon?: (props: {}) => any;
+        } & {
+            default?: (props: {}) => any;
+        };
+    }) & import("vue").Plugin;
+    EpButtonGroup: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../button-group").ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+            direction: "horizontal" | "vertical";
+            type: import("../button").ButtonProps["type"];
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("../button-group").ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, {
+            direction: "horizontal" | "vertical";
+            type: import("../button").ButtonProps["type"];
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("../button-group").ButtonGroupProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        direction: "horizontal" | "vertical";
+        type: import("../button").ButtonProps["type"];
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) & import("vue").Plugin;
+    ElScrollbar: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<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: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly height: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly maxHeight: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly native: BooleanConstructor;
+            readonly wrapStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+            readonly wrapClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+            readonly noresize: BooleanConstructor;
+            readonly tag: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly always: BooleanConstructor;
+            readonly minSize: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+            readonly tabindex: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+        }>, {
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined, 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").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: import("../scrollbar").ScrollbarDirection) => void;
+        }, import("vue").PublicProps, {
+            readonly always: boolean;
+            readonly height: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly maxHeight: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly tabindex: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly tag: string;
+            readonly minSize: number;
+            readonly distance: number;
+            readonly wrapStyle: import("vue").StyleValue;
+            readonly wrapClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewStyle: import("vue").StyleValue;
+            readonly native: boolean;
+            readonly noresize: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, 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: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+            readonly height: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly maxHeight: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+            readonly native: BooleanConstructor;
+            readonly wrapStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+            readonly wrapClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+            readonly viewStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+            readonly noresize: BooleanConstructor;
+            readonly tag: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+            readonly always: BooleanConstructor;
+            readonly minSize: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+            readonly tabindex: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & Readonly<{
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+        }>, {
+            wrapRef: import("vue").Ref<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, {}, {}, {}, {
+            readonly always: boolean;
+            readonly height: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly maxHeight: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly tabindex: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly tag: string;
+            readonly minSize: number;
+            readonly distance: number;
+            readonly wrapStyle: import("vue").StyleValue;
+            readonly wrapClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+            readonly viewStyle: import("vue").StyleValue;
+            readonly native: boolean;
+            readonly noresize: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & 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: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
+        readonly height: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        readonly maxHeight: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+        readonly native: BooleanConstructor;
+        readonly wrapStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+        readonly wrapClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+        readonly viewClass: import("../../utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
+        readonly viewStyle: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, "", boolean>;
+        readonly noresize: BooleanConstructor;
+        readonly tag: import("../../utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
+        readonly always: BooleanConstructor;
+        readonly minSize: import("../../utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
+        readonly tabindex: import("../../utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, undefined, boolean>;
+        readonly id: StringConstructor;
+        readonly role: StringConstructor;
+    }>> & Readonly<{
+        onScroll?: ((args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => any) | undefined;
+        "onEnd-reached"?: ((direction: import("../scrollbar").ScrollbarDirection) => any) | undefined;
+    }>, {
+        wrapRef: import("vue").Ref<HTMLDivElement | undefined, 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").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        scroll: (args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void;
+        "end-reached": (direction: import("../scrollbar").ScrollbarDirection) => void;
+    }, string, {
+        readonly always: boolean;
+        readonly height: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly maxHeight: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly tabindex: import("../../utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly tag: string;
+        readonly minSize: number;
+        readonly distance: number;
+        readonly wrapStyle: import("vue").StyleValue;
+        readonly wrapClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+        readonly viewClass: import("../../utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
+        readonly viewStyle: import("vue").StyleValue;
+        readonly native: boolean;
+        readonly noresize: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) & import("vue").Plugin;
+    ElTooltip: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+            contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            hide: (...args: any[]) => void;
+            show: (...args: any[]) => void;
+            open: (...args: any[]) => void;
+            close: (...args: any[]) => void;
+            "update:visible": (...args: any[]) => void;
+            "before-show": (...args: any[]) => void;
+            "before-hide": (...args: any[]) => void;
+        }, import("vue").PublicProps, {
+            content: string;
+            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            visible: boolean | null;
+            offset: number;
+            teleported: boolean;
+            placement: import("element-plus").Placement;
+            strategy: "fixed" | "absolute";
+            effect: import("../popper").PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            role: typeof import("../popper").roleTypes[number];
+            trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+            virtualTriggering: boolean;
+            loop: boolean;
+            arrowOffset: number;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            popperOptions: Partial<import("element-plus").Options>;
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            triggerKeys: string[];
+            showArrow: boolean;
+        }, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+            onHide?: ((...args: any[]) => any) | undefined;
+            onShow?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+            "onBefore-show"?: ((...args: any[]) => any) | undefined;
+            "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+        }>, {
+            popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+            contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event, delay?: number) => void;
+            onClose: (event?: Event, delay?: number) => void;
+            hide: (event?: Event) => void;
+        }, {}, {}, {}, {
+            content: string;
+            style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            visible: boolean | null;
+            offset: number;
+            teleported: boolean;
+            placement: import("element-plus").Placement;
+            strategy: "fixed" | "absolute";
+            effect: import("../popper").PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            role: typeof import("../popper").roleTypes[number];
+            trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+            virtualTriggering: boolean;
+            loop: boolean;
+            arrowOffset: number;
+            boundariesPadding: number;
+            gpuAcceleration: boolean;
+            popperOptions: Partial<import("element-plus").Options>;
+            enterable: boolean;
+            pure: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+            stopPopperMouseEvent: boolean;
+            triggerKeys: string[];
+            showArrow: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("../tooltip").UseTooltipProps> & Readonly<{
+        onHide?: ((...args: any[]) => any) | undefined;
+        onShow?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        onClose?: ((...args: any[]) => any) | undefined;
+        "onUpdate:visible"?: ((...args: any[]) => any) | undefined;
+        "onBefore-show"?: ((...args: any[]) => any) | undefined;
+        "onBefore-hide"?: ((...args: any[]) => any) | undefined;
+    }>, {
+        popperRef: import("vue").Ref<import("../popper").PopperInstance | undefined, import("../popper").PopperInstance | undefined>;
+        contentRef: import("vue").Ref<import("../tooltip").TooltipContentInstance | undefined, import("../tooltip").TooltipContentInstance | undefined>;
+        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+        updatePopper: () => void;
+        onOpen: (event?: Event, delay?: number) => void;
+        onClose: (event?: Event, delay?: number) => void;
+        hide: (event?: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        hide: (...args: any[]) => void;
+        show: (...args: any[]) => void;
+        open: (...args: any[]) => void;
+        close: (...args: any[]) => void;
+        "update:visible": (...args: any[]) => void;
+        "before-show": (...args: any[]) => void;
+        "before-hide": (...args: any[]) => void;
+    }, string, {
+        content: string;
+        style: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        visible: boolean | null;
+        offset: number;
+        teleported: boolean;
+        placement: import("element-plus").Placement;
+        strategy: "fixed" | "absolute";
+        effect: import("../popper").PopperEffect;
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        role: typeof import("../popper").roleTypes[number];
+        trigger: import("../../utils").Arrayable<import("../tooltip").TooltipTriggerType>;
+        virtualTriggering: boolean;
+        loop: boolean;
+        arrowOffset: number;
+        boundariesPadding: number;
+        gpuAcceleration: boolean;
+        popperOptions: Partial<import("element-plus").Options>;
+        enterable: boolean;
+        pure: boolean;
+        focusOnShow: boolean;
+        trapping: boolean;
+        popperStyle: string | false | import("vue").CSSProperties | import("vue").StyleValue[] | null;
+        stopPopperMouseEvent: boolean;
+        triggerKeys: string[];
+        showArrow: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        } & {
+            content?: (props: {}) => any;
+        };
+    }) & import("vue").Plugin;
+    ElRovingFocusGroup: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {
+        ElFocusGroupCollection: {
+            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+            name: string;
+            setup(): void;
+        };
+        ElRovingFocusGroupImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            style: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+            currentTabId: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            defaultCurrentTabId: StringConstructor;
+            loop: BooleanConstructor;
+            dir: import("../../utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+            orientation: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: FunctionConstructor;
+            onFocus: FunctionConstructor;
+            onMousedown: FunctionConstructor;
+        }>, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("currentTabIdChange" | "entryFocus")[], "currentTabIdChange" | "entryFocus", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            style: import("../../utils").EpPropFinalized<(new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue) | (((new (...args: any[]) => string | false | import("vue").CSSProperties | import("vue").StyleValue[]) | (() => import("vue").StyleValue)) | null)[], unknown, unknown, undefined, boolean>;
+            currentTabId: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => string) | (() => string | null) | (((new (...args: any[]) => string) | (() => string | null)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            defaultCurrentTabId: StringConstructor;
+            loop: BooleanConstructor;
+            dir: import("../../utils").EpPropFinalized<StringConstructor, string, unknown, string, boolean>;
+            orientation: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined) | (((new (...args: any[]) => "horizontal" | "vertical") | (() => "horizontal" | "vertical" | undefined)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: FunctionConstructor;
+            onFocus: FunctionConstructor;
+            onMousedown: FunctionConstructor;
+        }>> & Readonly<{
+            onCurrentTabIdChange?: ((...args: any[]) => any) | undefined;
+            onEntryFocus?: ((...args: any[]) => any) | undefined;
+        }>, {
+            style: import("vue").StyleValue;
+            dir: string;
+            loop: boolean;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElOnlyChild: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    ElIcon: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: {
+            default?: (props: {}) => any;
+        };
+    }) & import("vue").Plugin;
+    ArrowDown: import("vue").DefineComponent<{}, void, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+} & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin) & {
+    DropdownItem: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly divided: BooleanConstructor;
+            readonly textValue: StringConstructor;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onPointerleave?: ((...args: any[]) => any) | undefined;
+            onPointermove?: ((...args: any[]) => any) | undefined;
+        }>, {
+            handleClick: (event: PointerEvent) => void;
+            handlePointerMove: (event: PointerEvent) => void;
+            handlePointerLeave: (event: PointerEvent) => void;
+            propsAndAttrs: import("vue").ComputedRef<{
+                class?: import("vue").ClassValue;
+                style?: import("vue").StyleValue;
+                disabled: boolean;
+                command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+                divided: boolean;
+                icon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown> | undefined;
+                textValue: string | undefined;
+                onClick: ((...args: any[]) => any) | undefined;
+                onPointerleave: ((...args: any[]) => any) | undefined;
+                onPointermove: ((...args: any[]) => any) | undefined;
+            }>;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], import("vue").PublicProps, {
+            readonly disabled: boolean;
+            readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly divided: boolean;
+        }, true, {}, {}, {
+            ElRovingFocusItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                focusable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                active: BooleanConstructor;
+            }>, {
+                id: import("vue").Ref<string, string>;
+                handleKeydown: (event: Event) => void;
+                handleFocus: (event: Event) => void;
+                handleMousedown: (event: Event) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "keydown" | "mousedown")[], "focus" | "keydown" | "mousedown", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                focusable: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                active: BooleanConstructor;
+            }>> & Readonly<{
+                onFocus?: ((...args: any[]) => any) | undefined;
+                onKeydown?: ((...args: any[]) => any) | undefined;
+                onMousedown?: ((...args: any[]) => any) | undefined;
+            }>, {
+                active: boolean;
+                focusable: boolean;
+            }, {}, {
+                ElRovingFocusCollectionItem: {
+                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                    name: string;
+                    setup(_: unknown, { attrs }: import("vue").SetupContext): void;
+                };
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+            ElDropdownItemImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+                readonly disabled: BooleanConstructor;
+                readonly divided: BooleanConstructor;
+                readonly textValue: StringConstructor;
+                readonly icon: {
+                    readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>, {
+                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;
+                };
+                itemRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+                dataset: {
+                    "data-el-collection-item": string;
+                };
+                role: import("vue").ComputedRef<string>;
+                tabIndex: import("vue").Ref<number, number>;
+                handleFocus: (e: Event) => void;
+                handleKeydown: (event: KeyboardEvent) => void;
+                handleMousedown: (e: Event) => void;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove" | "clickimpl")[], "click" | "pointerleave" | "pointermove" | "clickimpl", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+                readonly disabled: BooleanConstructor;
+                readonly divided: BooleanConstructor;
+                readonly textValue: StringConstructor;
+                readonly icon: {
+                    readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+            }>> & Readonly<{
+                onClick?: ((...args: any[]) => any) | undefined;
+                onPointerleave?: ((...args: any[]) => any) | undefined;
+                onPointermove?: ((...args: any[]) => any) | undefined;
+                onClickimpl?: ((...args: any[]) => any) | undefined;
+            }>, {
+                readonly disabled: boolean;
+                readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+                readonly divided: boolean;
+            }, {}, {
+                ElIcon: import("../../utils").SFCWithInstall<{
+                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                        P: {};
+                        B: {};
+                        D: {};
+                        C: {};
+                        M: {};
+                        Defaults: {};
+                    }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                    __isFragment?: never;
+                    __isTeleport?: never;
+                    __isSuspense?: never;
+                } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                    $slots: {
+                        default?: (props: {}) => any;
+                    };
+                })>;
+            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly divided: BooleanConstructor;
+            readonly textValue: StringConstructor;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onPointerleave?: ((...args: any[]) => any) | undefined;
+            onPointermove?: ((...args: any[]) => any) | undefined;
+        }>, {
+            handleClick: (event: PointerEvent) => void;
+            handlePointerMove: (event: PointerEvent) => void;
+            handlePointerLeave: (event: PointerEvent) => void;
+            propsAndAttrs: import("vue").ComputedRef<{
+                class?: import("vue").ClassValue;
+                style?: import("vue").StyleValue;
+                disabled: boolean;
+                command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+                divided: boolean;
+                icon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown> | undefined;
+                textValue: string | undefined;
+                onClick: ((...args: any[]) => any) | undefined;
+                onPointerleave: ((...args: any[]) => any) | undefined;
+                onPointermove: ((...args: any[]) => any) | undefined;
+            }>;
+        }, {}, {}, {}, {
+            readonly disabled: boolean;
+            readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly divided: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+        readonly disabled: BooleanConstructor;
+        readonly divided: BooleanConstructor;
+        readonly textValue: StringConstructor;
+        readonly icon: {
+            readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{
+        onClick?: ((...args: any[]) => any) | undefined;
+        onPointerleave?: ((...args: any[]) => any) | undefined;
+        onPointermove?: ((...args: any[]) => any) | undefined;
+    }>, {
+        handleClick: (event: PointerEvent) => void;
+        handlePointerMove: (event: PointerEvent) => void;
+        handlePointerLeave: (event: PointerEvent) => void;
+        propsAndAttrs: import("vue").ComputedRef<{
+            class?: import("vue").ClassValue;
+            style?: import("vue").StyleValue;
+            disabled: boolean;
+            command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+            divided: boolean;
+            icon: import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown> | undefined;
+            textValue: string | undefined;
+            onClick: ((...args: any[]) => any) | undefined;
+            onPointerleave: ((...args: any[]) => any) | undefined;
+            onPointermove: ((...args: any[]) => any) | undefined;
+        }>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", {
+        readonly disabled: boolean;
+        readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+        readonly divided: boolean;
+    }, {}, string, {}, {
+        ElRovingFocusItem: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            focusable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            active: BooleanConstructor;
+        }>, {
+            id: import("vue").Ref<string, string>;
+            handleKeydown: (event: Event) => void;
+            handleFocus: (event: Event) => void;
+            handleMousedown: (event: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focus" | "keydown" | "mousedown")[], "focus" | "keydown" | "mousedown", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            focusable: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            active: BooleanConstructor;
+        }>> & Readonly<{
+            onFocus?: ((...args: any[]) => any) | undefined;
+            onKeydown?: ((...args: any[]) => any) | undefined;
+            onMousedown?: ((...args: any[]) => any) | undefined;
+        }>, {
+            active: boolean;
+            focusable: boolean;
+        }, {}, {
+            ElRovingFocusCollectionItem: {
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+                name: string;
+                setup(_: unknown, { attrs }: import("vue").SetupContext): void;
+            };
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        ElDropdownItemImpl: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+            readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly divided: BooleanConstructor;
+            readonly textValue: StringConstructor;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>, {
+            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;
+            };
+            itemRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+            dataset: {
+                "data-el-collection-item": string;
+            };
+            role: import("vue").ComputedRef<string>;
+            tabIndex: import("vue").Ref<number, number>;
+            handleFocus: (e: Event) => void;
+            handleKeydown: (event: KeyboardEvent) => void;
+            handleMousedown: (e: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove" | "clickimpl")[], "click" | "pointerleave" | "pointermove" | "clickimpl", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+            readonly command: import("../../utils").EpPropFinalized<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown, () => {}, boolean>;
+            readonly disabled: BooleanConstructor;
+            readonly divided: BooleanConstructor;
+            readonly textValue: StringConstructor;
+            readonly icon: {
+                readonly type: import("vue").PropType<import("../../utils").EpPropMergeType<(new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component) | (((new (...args: any[]) => (string | import("vue").Component) & {}) | (() => string | import("vue").Component)) | null)[], unknown, unknown>>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{
+            onClick?: ((...args: any[]) => any) | undefined;
+            onPointerleave?: ((...args: any[]) => any) | undefined;
+            onPointermove?: ((...args: any[]) => any) | undefined;
+            onClickimpl?: ((...args: any[]) => any) | undefined;
+        }>, {
+            readonly disabled: boolean;
+            readonly command: import("../../utils").EpPropMergeType<readonly [ObjectConstructor, StringConstructor, NumberConstructor], unknown, unknown>;
+            readonly divided: boolean;
+        }, {}, {
+            ElIcon: import("../../utils").SFCWithInstall<{
+                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, false, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                    P: {};
+                    B: {};
+                    D: {};
+                    C: {};
+                    M: {};
+                    Defaults: {};
+                }, Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("vue").ComponentOptionsBase<Readonly<import("../icon").IconProps> & Readonly<{}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    default?: (props: {}) => any;
+                };
+            })>;
+        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
+    DropdownMenu: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            onKeydown: {
+                readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{}>, {
+            size: import("vue").ComputedRef<string> | undefined;
+            rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue, import("vue").StyleValue>;
+            dropdownKls: import("vue").ComputedRef<string[]>;
+            role: import("vue").ComputedRef<"listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation" | undefined>;
+            triggerId: import("vue").ComputedRef<string>;
+            dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+            handleKeydown: (event: KeyboardEvent) => void;
+            onBlur: (e: Event) => void;
+            handleFocus: (e: FocusEvent) => void;
+            onMousedown: (e: Event) => void;
+        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            onKeydown: {
+                readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+        }>> & Readonly<{}>, {
+            size: import("vue").ComputedRef<string> | undefined;
+            rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue, import("vue").StyleValue>;
+            dropdownKls: import("vue").ComputedRef<string[]>;
+            role: import("vue").ComputedRef<"listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation" | undefined>;
+            triggerId: import("vue").ComputedRef<string>;
+            dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+            handleKeydown: (event: KeyboardEvent) => void;
+            onBlur: (e: Event) => void;
+            handleFocus: (e: FocusEvent) => void;
+            onMousedown: (e: Event) => void;
+        }, {}, {}, {}, {}>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        onKeydown: {
+            readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+    }>> & Readonly<{}>, {
+        size: import("vue").ComputedRef<string> | undefined;
+        rovingFocusGroupRootStyle: import("vue").Ref<import("vue").StyleValue, import("vue").StyleValue>;
+        dropdownKls: import("vue").ComputedRef<string[]>;
+        role: import("vue").ComputedRef<"listbox" | "grid" | "menu" | "tooltip" | "dialog" | "tree" | "group" | "navigation" | undefined>;
+        triggerId: import("vue").ComputedRef<string>;
+        dropdownListWrapperRef: (el: Element | import("vue").ComponentPublicInstance | null) => void;
+        handleKeydown: (event: KeyboardEvent) => void;
+        onBlur: (e: Event) => void;
+        handleFocus: (e: FocusEvent) => void;
+        onMousedown: (e: Event) => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin;
+};
 export default EpDropdown;
+export * from './src/dropdown';
+export * from './src/instance';
+export * from './src/tokens';