import { PropType } from 'vue';
import { EleDropdownProps } from '../../ele-app/plus';
import { TabPaneItem, TabEventOption, ContextMenus } from '../../ele-tabs/types';
import { TabStyle } from '../types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    /** 页签数据 */
    tabs: PropType<TabPaneItem[]>;
    /** 页签选中 */
    active: StringConstructor;
    /** 是否需要固定的主页页签 */
    fixedHome: BooleanConstructor;
    /** 主页路由地址 */
    homePath: StringConstructor;
    /** 当前路由是否是主页 */
    isHome: BooleanConstructor;
    /** 页签风格 */
    tabStyle: PropType<TabStyle>;
    /** 是否支持右键菜单 */
    tabContextMenu: PropType<boolean | EleDropdownProps>;
    /** 右键菜单 */
    tabContextMenus: PropType<ContextMenus>;
    /** 是否支持拖动排序 */
    tabSortable: BooleanConstructor;
}>, {
    handleTabRemove: (name: string) => void;
    handleTabItemClick: (option: TabEventOption) => void;
    handleTabContextMenu: (option: TabEventOption) => void;
    handleTabSortChange: (data: TabPaneItem[]) => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    tabClick: (_option: TabEventOption) => true;
    tabRemove: (_name: string) => true;
    tabContextMenu: (_option: TabEventOption) => true;
    tabSortChange: (_data: TabPaneItem[]) => true;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    /** 页签数据 */
    tabs: PropType<TabPaneItem[]>;
    /** 页签选中 */
    active: StringConstructor;
    /** 是否需要固定的主页页签 */
    fixedHome: BooleanConstructor;
    /** 主页路由地址 */
    homePath: StringConstructor;
    /** 当前路由是否是主页 */
    isHome: BooleanConstructor;
    /** 页签风格 */
    tabStyle: PropType<TabStyle>;
    /** 是否支持右键菜单 */
    tabContextMenu: PropType<boolean | EleDropdownProps>;
    /** 右键菜单 */
    tabContextMenus: PropType<ContextMenus>;
    /** 是否支持拖动排序 */
    tabSortable: BooleanConstructor;
}>> & Readonly<{
    onTabContextMenu?: ((_option: TabEventOption) => any) | undefined;
    onTabSortChange?: ((_data: TabPaneItem[]) => any) | undefined;
    onTabClick?: ((_option: TabEventOption) => any) | undefined;
    onTabRemove?: ((_name: string) => any) | undefined;
}>, {
    fixedHome: boolean;
    isHome: boolean;
    tabSortable: boolean;
}, {}, {
    ElIcon: {
        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, 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: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, {}, {}, {}, {}>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
        readonly size: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly color: {
            readonly type: PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    }) & import('vue').Plugin;
    HomeOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleTabWrap: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        size: PropType<import('../../ele-tabs/types').TabSize>;
        type: PropType<import('../../ele-tabs/types').TabType>;
    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        size: PropType<import('../../ele-tabs/types').TabSize>;
        type: PropType<import('../../ele-tabs/types').TabType>;
    }>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleTabTool: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        tab: BooleanConstructor;
        active: BooleanConstructor;
        tabName: (StringConstructor | NumberConstructor)[];
    }>, {
        handleItemClick: (e: MouseEvent) => void;
        handleItemContextmenu: (e: MouseEvent) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        tab: BooleanConstructor;
        active: BooleanConstructor;
        tabName: (StringConstructor | NumberConstructor)[];
    }>> & Readonly<{}>, {
        tab: boolean;
        active: boolean;
    }, {}, {
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, 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: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
        CornerLeftFilled: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        CornerRightFilled: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleTabs: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        items: {
            type: PropType<TabPaneItem[]>;
            required: boolean;
        };
        size: PropType<import('../../ele-tabs/types').TabSize>;
        type: PropType<import('../../ele-tabs/types').TabType>;
        center: BooleanConstructor;
        contextMenu: PropType<boolean | EleDropdownProps>;
        contextMenus: PropType<ContextMenus>;
        sortable: BooleanConstructor;
        mousewheel: BooleanConstructor;
        handleClick: BooleanConstructor;
        flexTable: BooleanConstructor;
        closable: BooleanConstructor;
        addable: BooleanConstructor;
        modelValue: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        editable: BooleanConstructor;
        tabPosition: {
            readonly type: PropType<"top" | "bottom" | "left" | "right">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "top";
        };
        beforeLeave: {
            readonly type: PropType<(newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => true;
        };
        stretch: BooleanConstructor;
    }>, {
        omit: typeof import('../../utils/core').omit;
        tabRef: import('vue').Ref<import('../../ele-app/el').ElTabsInstance, import('../../ele-app/el').ElTabsInstance>;
        isOnlyTab: import('vue').ComputedRef<boolean>;
        tabSize: import('vue').ComputedRef<import('../../ele-tabs/types').TabSize | undefined>;
        tabType: import('vue').ComputedRef<import('../../ele-tabs/types').TabType | undefined>;
        tabProps: import('vue').ComputedRef<Omit<import('../../ele-app/el').ElTabsProps, "type">>;
        ctxMenuDropdownRef: import('vue').Ref<import('../../ele-app/plus').EleDropdownInstance, import('../../ele-app/plus').EleDropdownInstance>;
        ctxMenuDropdownItems: import('vue').ShallowRef<import('../../ele-dropdown/types').DropdownItem[], import('../../ele-dropdown/types').DropdownItem[]>;
        ctxMenuDropdownVirtualRef: import('vue').Ref<any, any>;
        updateModelValue: (name: import('element-plus').TabPaneName) => void;
        handleContextmenu: (e: MouseEvent) => void;
        handleTabClick: (pane: import('element-plus').TabsPaneContext, e: Event) => void;
        handleTabChange: (name: import('element-plus').TabPaneName) => void;
        handleTabRemove: (name: import('element-plus').TabPaneName) => void;
        handleTabAdd: () => void;
        handleEdit: (name: import('element-plus').TabPaneName | undefined, action: "remove" | "add") => void;
        handleItemClick: (item: TabPaneItem | undefined, tabName: string | number | undefined, e: MouseEvent) => void;
        handleItemCtxMenuVisible: (visible: boolean) => void;
        handleItemCtxMenuClick: (command: string) => void;
        handleItemContextmenu: (item: TabPaneItem | undefined, tabName: string | number | undefined, e: MouseEvent) => void;
        hideAllDropdown: () => void;
        updateActiveBar: () => void;
        scrollTabs: (direction: "prev" | "next", done?: () => void) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        tabItemClick: (_opt: TabEventOption) => boolean;
        tabContextMenu: (_opt: TabEventOption) => boolean;
        tabContextOpen: (_ref: import('../../ele-app/plus').EleDropdownInstance, _item?: TabPaneItem | null, _name?: string | number | null) => boolean;
        tabSortChange: (_data: TabPaneItem[]) => boolean;
        "update:modelValue": (name: import('element-plus').TabPaneName) => name is string | number;
        tabClick: (pane: import('element-plus').TabsPaneContext, ev: Event) => boolean;
        tabChange: (name: import('element-plus').TabPaneName) => name is string | number;
        edit: (paneName: import('element-plus').TabPaneName | undefined, action: "remove" | "add") => boolean;
        tabRemove: (name: import('element-plus').TabPaneName) => name is string | number;
        tabAdd: () => boolean;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        items: {
            type: PropType<TabPaneItem[]>;
            required: boolean;
        };
        size: PropType<import('../../ele-tabs/types').TabSize>;
        type: PropType<import('../../ele-tabs/types').TabType>;
        center: BooleanConstructor;
        contextMenu: PropType<boolean | EleDropdownProps>;
        contextMenus: PropType<ContextMenus>;
        sortable: BooleanConstructor;
        mousewheel: BooleanConstructor;
        handleClick: BooleanConstructor;
        flexTable: BooleanConstructor;
        closable: BooleanConstructor;
        addable: BooleanConstructor;
        modelValue: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        editable: BooleanConstructor;
        tabPosition: {
            readonly type: PropType<"top" | "bottom" | "left" | "right">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "top";
        };
        beforeLeave: {
            readonly type: PropType<(newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => true;
        };
        stretch: BooleanConstructor;
    }>> & Readonly<{
        onTabContextMenu?: ((_opt: TabEventOption) => any) | undefined;
        "onUpdate:modelValue"?: ((name: import('element-plus').TabPaneName) => any) | undefined;
        onTabItemClick?: ((_opt: TabEventOption) => any) | undefined;
        onTabContextOpen?: ((_ref: import('../../ele-app/plus').EleDropdownInstance, _item?: TabPaneItem | null | undefined, _name?: string | number | null | undefined) => any) | undefined;
        onTabSortChange?: ((_data: TabPaneItem[]) => any) | undefined;
        onTabClick?: ((pane: {
            uid: number;
            slots: import('vue').Slots;
            props: {
                readonly label: string;
                readonly closable: boolean;
                readonly disabled: boolean;
                readonly lazy: boolean;
                readonly name?: (string | number) | undefined;
            };
            paneName: string | number | undefined;
            active: boolean;
            index: string | undefined;
            isClosable: boolean;
        }, ev: Event) => any) | undefined;
        onTabChange?: ((name: import('element-plus').TabPaneName) => any) | undefined;
        onEdit?: ((paneName: import('element-plus').TabPaneName | undefined, action: "add" | "remove") => any) | undefined;
        onTabRemove?: ((name: import('element-plus').TabPaneName) => any) | undefined;
        onTabAdd?: (() => any) | undefined;
    }>, {
        mousewheel: boolean;
        closable: boolean;
        center: boolean;
        sortable: boolean;
        addable: boolean;
        editable: boolean;
        tabPosition: "top" | "bottom" | "left" | "right";
        beforeLeave: (newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>;
        stretch: boolean;
        handleClick: boolean;
        flexTable: boolean;
    }, {}, {
        ElTabs: ({
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly type: {
                    readonly type: PropType<"" | "card" | "border-card">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly closable: BooleanConstructor;
                readonly addable: BooleanConstructor;
                readonly modelValue: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly editable: BooleanConstructor;
                readonly tabPosition: {
                    readonly type: PropType<"top" | "bottom" | "left" | "right">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "top";
                };
                readonly beforeLeave: {
                    readonly type: PropType<(newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => true;
                };
                readonly stretch: BooleanConstructor;
            }>> & {
                "onUpdate:modelValue"?: ((name: import('element-plus').TabPaneName) => any) | undefined;
                onTabClick?: ((pane: {
                    uid: number;
                    slots: import('vue').Slots;
                    props: {
                        readonly label: string;
                        readonly disabled: boolean;
                        readonly closable: boolean;
                        readonly lazy: boolean;
                        readonly name?: (string | number) | undefined;
                    };
                    paneName: string | number | undefined;
                    active: boolean;
                    index: string | undefined;
                    isClosable: boolean;
                }, ev: Event) => any) | undefined;
                onTabRemove?: ((name: import('element-plus').TabPaneName) => any) | undefined;
                onTabChange?: ((name: import('element-plus').TabPaneName) => any) | undefined;
                onEdit?: ((paneName: import('element-plus').TabPaneName | undefined, action: "add" | "remove") => any) | undefined;
                onTabAdd?: (() => any) | undefined;
            }, () => JSX.Element, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                "update:modelValue": (name: import('element-plus').TabPaneName) => name is string | number;
                tabClick: (pane: import('element-plus').TabsPaneContext, ev: Event) => boolean;
                tabChange: (name: import('element-plus').TabPaneName) => name is string | number;
                edit: (paneName: import('element-plus').TabPaneName | undefined, action: "remove" | "add") => boolean;
                tabRemove: (name: import('element-plus').TabPaneName) => name is string | number;
                tabAdd: () => boolean;
            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly stretch: boolean;
                readonly type: "" | "card" | "border-card";
                readonly closable: boolean;
                readonly beforeLeave: (newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>;
                readonly editable: boolean;
                readonly tabPosition: "top" | "bottom" | "left" | "right";
                readonly addable: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly type: {
                    readonly type: PropType<"" | "card" | "border-card">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly closable: BooleanConstructor;
                readonly addable: BooleanConstructor;
                readonly modelValue: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly editable: BooleanConstructor;
                readonly tabPosition: {
                    readonly type: PropType<"top" | "bottom" | "left" | "right">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "top";
                };
                readonly beforeLeave: {
                    readonly type: PropType<(newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => true;
                };
                readonly stretch: BooleanConstructor;
            }>> & {
                "onUpdate:modelValue"?: ((name: import('element-plus').TabPaneName) => any) | undefined;
                onTabClick?: ((pane: {
                    uid: number;
                    slots: import('vue').Slots;
                    props: {
                        readonly label: string;
                        readonly disabled: boolean;
                        readonly closable: boolean;
                        readonly lazy: boolean;
                        readonly name?: (string | number) | undefined;
                    };
                    paneName: string | number | undefined;
                    active: boolean;
                    index: string | undefined;
                    isClosable: boolean;
                }, ev: Event) => any) | undefined;
                onTabRemove?: ((name: import('element-plus').TabPaneName) => any) | undefined;
                onTabChange?: ((name: import('element-plus').TabPaneName) => any) | undefined;
                onEdit?: ((paneName: import('element-plus').TabPaneName | undefined, action: "add" | "remove") => any) | undefined;
                onTabAdd?: (() => any) | undefined;
            }, () => JSX.Element, {}, {}, {}, {
                readonly stretch: boolean;
                readonly type: "" | "card" | "border-card";
                readonly closable: boolean;
                readonly beforeLeave: (newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>;
                readonly editable: boolean;
                readonly tabPosition: "top" | "bottom" | "left" | "right";
                readonly addable: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly type: {
                readonly type: PropType<"" | "card" | "border-card">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly closable: BooleanConstructor;
            readonly addable: BooleanConstructor;
            readonly modelValue: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly editable: BooleanConstructor;
            readonly tabPosition: {
                readonly type: PropType<"top" | "bottom" | "left" | "right">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "top";
            };
            readonly beforeLeave: {
                readonly type: PropType<(newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => true;
            };
            readonly stretch: BooleanConstructor;
        }>> & {
            "onUpdate:modelValue"?: ((name: import('element-plus').TabPaneName) => any) | undefined;
            onTabClick?: ((pane: {
                uid: number;
                slots: import('vue').Slots;
                props: {
                    readonly label: string;
                    readonly disabled: boolean;
                    readonly closable: boolean;
                    readonly lazy: boolean;
                    readonly name?: (string | number) | undefined;
                };
                paneName: string | number | undefined;
                active: boolean;
                index: string | undefined;
                isClosable: boolean;
            }, ev: Event) => any) | undefined;
            onTabRemove?: ((name: import('element-plus').TabPaneName) => any) | undefined;
            onTabChange?: ((name: import('element-plus').TabPaneName) => any) | undefined;
            onEdit?: ((paneName: import('element-plus').TabPaneName | undefined, action: "add" | "remove") => any) | undefined;
            onTabAdd?: (() => any) | undefined;
        }, () => JSX.Element, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            "update:modelValue": (name: import('element-plus').TabPaneName) => name is string | number;
            tabClick: (pane: import('element-plus').TabsPaneContext, ev: Event) => boolean;
            tabChange: (name: import('element-plus').TabPaneName) => name is string | number;
            edit: (paneName: import('element-plus').TabPaneName | undefined, action: "remove" | "add") => boolean;
            tabRemove: (name: import('element-plus').TabPaneName) => name is string | number;
            tabAdd: () => boolean;
        }, string, {
            readonly stretch: boolean;
            readonly type: "" | "card" | "border-card";
            readonly closable: boolean;
            readonly beforeLeave: (newName: import('element-plus').TabPaneName, oldName: import('element-plus').TabPaneName) => boolean | void | Promise<boolean | void>;
            readonly editable: boolean;
            readonly tabPosition: "top" | "bottom" | "left" | "right";
            readonly addable: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin) & {
            TabPane: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly label: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly name: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly closable: BooleanConstructor;
                    readonly disabled: BooleanConstructor;
                    readonly lazy: BooleanConstructor;
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly label: string;
                    readonly disabled: boolean;
                    readonly closable: boolean;
                    readonly lazy: boolean;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly label: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly name: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly closable: BooleanConstructor;
                    readonly disabled: BooleanConstructor;
                    readonly lazy: BooleanConstructor;
                }>>, {}, {}, {}, {}, {
                    readonly label: string;
                    readonly disabled: boolean;
                    readonly closable: boolean;
                    readonly lazy: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly label: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly name: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly closable: BooleanConstructor;
                readonly disabled: BooleanConstructor;
                readonly lazy: BooleanConstructor;
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                readonly label: string;
                readonly disabled: boolean;
                readonly closable: boolean;
                readonly lazy: boolean;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    default?(_: {}): any;
                };
            });
        };
        ElTabPane: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly label: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly name: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly closable: BooleanConstructor;
                readonly disabled: BooleanConstructor;
                readonly lazy: BooleanConstructor;
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly label: string;
                readonly disabled: boolean;
                readonly closable: boolean;
                readonly lazy: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly label: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly name: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly closable: BooleanConstructor;
                readonly disabled: BooleanConstructor;
                readonly lazy: BooleanConstructor;
            }>>, {}, {}, {}, {}, {
                readonly label: string;
                readonly disabled: boolean;
                readonly closable: boolean;
                readonly lazy: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly label: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly name: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly closable: BooleanConstructor;
            readonly disabled: BooleanConstructor;
            readonly lazy: BooleanConstructor;
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
            readonly label: string;
            readonly disabled: boolean;
            readonly closable: boolean;
            readonly lazy: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, 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: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
        EleDropdown: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            transition: {
                type: StringConstructor;
                default: string;
            };
            items: PropType<import('../../ele-dropdown/types').DropdownItem[]>;
            modelValue: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
            menuStyle: PropType<import('../../ele-app/types').StyleValue>;
            iconProps: PropType<import('../../ele-app/el').ElIconProps>;
            componentType: PropType<"pro">;
            preventContextmenu: BooleanConstructor;
            splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            type: {
                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            effect: {
                readonly default: "light";
                readonly type: PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            placement: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "bottom";
            };
            popperClass: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            teleported: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            disabled: BooleanConstructor;
            persistent: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            triggerKeys: {
                readonly type: PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => string[];
            };
            popperOptions: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            id: StringConstructor;
            splitButton: BooleanConstructor;
            hideOnClick: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            loop: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            showTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            hideTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            tabindex: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            maxHeight: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            role: {
                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "menu";
            };
            buttonProps: {
                readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
            ariaLabel: StringConstructor;
            appendTo: {
                readonly type: PropType<string | HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            offset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            bg: StringConstructor;
            zIndex: NumberConstructor;
            visible: {
                readonly type: PropType<boolean | null>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: null;
            };
            trigger: {
                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "hover";
            };
            popperStyle: PropType<import('../../ele-app/types').StyleValue>;
            enterable: {
                readonly default: true;
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            showArrow: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowOffset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 5;
            };
            virtualRef: {
                readonly type: PropType<import('element-plus').Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            virtualTriggering: BooleanConstructor;
            className: StringConstructor;
            gpuAcceleration: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowBg: StringConstructor;
        }>, {
            omit: typeof import('../../utils/core').omit;
            dropdownRef: import('vue').Ref<import('../../ele-dropdown/props').DropdownInstance, import('../../ele-dropdown/props').DropdownInstance>;
            dropdownProps: import('vue').ComputedRef<import('../../ele-app/el').ElDropdownProps>;
            selected: import('vue').ComputedRef<import('../../ele-dropdown/types').DropdownItem | null | undefined>;
            handleMenuClick: (command: import('../../ele-dropdown/types').DropdownItem["command"]) => void;
            handleBtnClick: (e: MouseEvent) => void;
            handlePopVisibleChange: (visible: boolean) => void;
            handleOpen: () => void;
            handleClose: () => void;
            updatePopper: () => void;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            click: (_e: MouseEvent) => boolean;
            command: (_command: import('../../ele-dropdown/types').DropdownItem["command"]) => boolean;
            visibleChange: (_visible: boolean) => boolean;
            'update:modelValue': (_value: import('../../ele-dropdown/types').DropdownItem["command"]) => boolean;
            change: (_active: import('../../ele-dropdown/types').DropdownItem["command"]) => boolean;
            "update:visible": (value: boolean) => boolean;
            "before-enter": () => boolean;
            "before-leave": () => boolean;
            "after-enter": () => boolean;
            "after-leave": () => boolean;
        }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            transition: {
                type: StringConstructor;
                default: string;
            };
            items: PropType<import('../../ele-dropdown/types').DropdownItem[]>;
            modelValue: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
            menuStyle: PropType<import('../../ele-app/types').StyleValue>;
            iconProps: PropType<import('../../ele-app/el').ElIconProps>;
            componentType: PropType<"pro">;
            preventContextmenu: BooleanConstructor;
            splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            type: {
                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            effect: {
                readonly default: "light";
                readonly type: PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            placement: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "bottom";
            };
            popperClass: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            teleported: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            disabled: BooleanConstructor;
            persistent: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            triggerKeys: {
                readonly type: PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => string[];
            };
            popperOptions: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            id: StringConstructor;
            splitButton: BooleanConstructor;
            hideOnClick: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            loop: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            showTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            hideTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            tabindex: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            maxHeight: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            role: {
                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "menu";
            };
            buttonProps: {
                readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
            ariaLabel: StringConstructor;
            appendTo: {
                readonly type: PropType<string | HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            offset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            bg: StringConstructor;
            zIndex: NumberConstructor;
            visible: {
                readonly type: PropType<boolean | null>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: null;
            };
            trigger: {
                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "hover";
            };
            popperStyle: PropType<import('../../ele-app/types').StyleValue>;
            enterable: {
                readonly default: true;
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            showArrow: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowOffset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 5;
            };
            virtualRef: {
                readonly type: PropType<import('element-plus').Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            virtualTriggering: BooleanConstructor;
            className: StringConstructor;
            gpuAcceleration: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowBg: StringConstructor;
        }>> & Readonly<{
            onChange?: ((_active: (string | number | Record<string, any>) | undefined) => any) | undefined;
            onClick?: ((_e: MouseEvent) => any) | undefined;
            onCommand?: ((_command: (string | number | Record<string, any>) | undefined) => any) | undefined;
            "onUpdate:visible"?: ((value: boolean) => any) | undefined;
            onVisibleChange?: ((_visible: boolean) => any) | undefined;
            "onUpdate:modelValue"?: ((_value: (string | number | Record<string, any>) | undefined) => any) | undefined;
            "onBefore-enter"?: (() => any) | undefined;
            "onBefore-leave"?: (() => any) | undefined;
            "onAfter-enter"?: (() => any) | undefined;
            "onAfter-leave"?: (() => any) | undefined;
        }>, {
            effect: import('element-plus').PopperEffect;
            placement: any;
            popperClass: string;
            teleported: boolean;
            disabled: boolean;
            offset: number;
            persistent: boolean;
            visible: boolean | null;
            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
            triggerKeys: string[];
            popperOptions: any;
            splitButton: boolean;
            hideOnClick: boolean;
            loop: boolean;
            showTimeout: number;
            hideTimeout: number;
            tabindex: string | number;
            maxHeight: string | number;
            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
            transition: string;
            enterable: boolean;
            showArrow: boolean;
            arrowOffset: number;
            virtualTriggering: boolean;
            gpuAcceleration: boolean;
            preventContextmenu: boolean;
        }, {}, {
            ElDropdown: ({
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly trigger: {
                        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "hover";
                    };
                    readonly triggerKeys: {
                        readonly type: PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    readonly effect: {
                        readonly default: "light";
                        readonly type: PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        readonly __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly placement: {
                        readonly type: PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    readonly popperOptions: {
                        readonly type: PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    readonly id: StringConstructor;
                    readonly size: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly splitButton: BooleanConstructor;
                    readonly hideOnClick: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly loop: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly showTimeout: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    readonly hideTimeout: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    readonly tabindex: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    readonly maxHeight: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly popperClass: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly disabled: BooleanConstructor;
                    readonly role: {
                        readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "menu";
                    };
                    readonly buttonProps: {
                        readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly teleported: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly persistent: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                }>> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                    "onVisible-change"?: ((...args: any[]) => any) | undefined;
                    onCommand?: ((...args: any[]) => any) | undefined;
                }, {
                    t: import('element-plus').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>;
                    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>;
                    handleCurrentTabIdChange: (id: string) => void;
                    handlerMainButtonClick: (event: MouseEvent) => void;
                    handleEntryFocus: (e: Event) => void;
                    handleClose: () => void;
                    handleOpen: () => void;
                    handleBeforeShowTooltip: () => void;
                    handleShowTooltip: (event?: Event) => void;
                    handleBeforeHideTooltip: () => void;
                    onFocusAfterTrapped: (e: Event) => void;
                    popperRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
                    contentRef: import('vue').Ref<HTMLElement | undefined>;
                    triggeringElementRef: import('vue').Ref<any>;
                    referenceElementRef: import('vue').Ref<any>;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "visible-change" | "command")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly disabled: boolean;
                    readonly maxHeight: string | number;
                    readonly size: string;
                    readonly placement: any;
                    readonly effect: import('element-plus').PopperEffect;
                    readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                    readonly tabindex: string | number;
                    readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                    readonly loop: boolean;
                    readonly popperOptions: Partial<Options>;
                    readonly popperClass: string;
                    readonly triggerKeys: string[];
                    readonly teleported: boolean;
                    readonly persistent: boolean;
                    readonly hideOnClick: boolean;
                    readonly showTimeout: number;
                    readonly hideTimeout: number;
                    readonly splitButton: boolean;
                }, true, {}, {}, 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: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "hover";
                    };
                    readonly triggerKeys: {
                        readonly type: PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    readonly effect: {
                        readonly default: "light";
                        readonly type: PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        readonly __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly placement: {
                        readonly type: PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    readonly popperOptions: {
                        readonly type: PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    readonly id: StringConstructor;
                    readonly size: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly splitButton: BooleanConstructor;
                    readonly hideOnClick: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly loop: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly showTimeout: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    readonly hideTimeout: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    readonly tabindex: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    readonly maxHeight: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly popperClass: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly disabled: BooleanConstructor;
                    readonly role: {
                        readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "menu";
                    };
                    readonly buttonProps: {
                        readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly teleported: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly persistent: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                }>> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                    "onVisible-change"?: ((...args: any[]) => any) | undefined;
                    onCommand?: ((...args: any[]) => any) | undefined;
                }, {
                    t: import('element-plus').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>;
                    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>;
                    handleCurrentTabIdChange: (id: string) => void;
                    handlerMainButtonClick: (event: MouseEvent) => void;
                    handleEntryFocus: (e: Event) => void;
                    handleClose: () => void;
                    handleOpen: () => void;
                    handleBeforeShowTooltip: () => void;
                    handleShowTooltip: (event?: Event) => void;
                    handleBeforeHideTooltip: () => void;
                    onFocusAfterTrapped: (e: Event) => void;
                    popperRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
                    contentRef: import('vue').Ref<HTMLElement | undefined>;
                    triggeringElementRef: import('vue').Ref<any>;
                    referenceElementRef: import('vue').Ref<any>;
                }, {}, {}, {}, {
                    readonly disabled: boolean;
                    readonly maxHeight: string | number;
                    readonly size: string;
                    readonly placement: any;
                    readonly effect: import('element-plus').PopperEffect;
                    readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                    readonly tabindex: string | number;
                    readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                    readonly loop: boolean;
                    readonly popperOptions: Partial<Options>;
                    readonly popperClass: string;
                    readonly triggerKeys: string[];
                    readonly teleported: boolean;
                    readonly persistent: boolean;
                    readonly hideOnClick: boolean;
                    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: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                readonly triggerKeys: {
                    readonly type: PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                readonly effect: {
                    readonly default: "light";
                    readonly type: PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly placement: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                readonly popperOptions: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly id: StringConstructor;
                readonly size: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly splitButton: BooleanConstructor;
                readonly hideOnClick: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly loop: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly showTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                readonly hideTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                readonly tabindex: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly maxHeight: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly popperClass: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly disabled: BooleanConstructor;
                readonly role: {
                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "menu";
                };
                readonly buttonProps: {
                    readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly teleported: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly persistent: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
            }>> & {
                onClick?: ((...args: any[]) => any) | undefined;
                "onVisible-change"?: ((...args: any[]) => any) | undefined;
                onCommand?: ((...args: any[]) => any) | undefined;
            }, {
                t: import('element-plus').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>;
                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>;
                handleCurrentTabIdChange: (id: string) => void;
                handlerMainButtonClick: (event: MouseEvent) => void;
                handleEntryFocus: (e: Event) => void;
                handleClose: () => void;
                handleOpen: () => void;
                handleBeforeShowTooltip: () => void;
                handleShowTooltip: (event?: Event) => void;
                handleBeforeHideTooltip: () => void;
                onFocusAfterTrapped: (e: Event) => void;
                popperRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
                contentRef: import('vue').Ref<HTMLElement | undefined>;
                triggeringElementRef: import('vue').Ref<any>;
                referenceElementRef: import('vue').Ref<any>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "visible-change" | "command")[], "click" | "visible-change" | "command", {
                readonly disabled: boolean;
                readonly maxHeight: string | number;
                readonly size: string;
                readonly placement: any;
                readonly effect: import('element-plus').PopperEffect;
                readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                readonly tabindex: string | number;
                readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                readonly loop: boolean;
                readonly popperOptions: Partial<Options>;
                readonly popperClass: string;
                readonly triggerKeys: string[];
                readonly teleported: boolean;
                readonly persistent: boolean;
                readonly hideOnClick: boolean;
                readonly showTimeout: number;
                readonly hideTimeout: number;
                readonly splitButton: boolean;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin) & {
                DropdownItem: import('vue').DefineComponent<{
                    readonly command: {
                        readonly type: PropType<string | number | Record<string, any>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    readonly disabled: BooleanConstructor;
                    readonly divided: BooleanConstructor;
                    readonly textValue: StringConstructor;
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }, {
                    handleClick: (event: PointerEvent) => void;
                    handlePointerMove: (event: PointerEvent) => void;
                    handlePointerLeave: (event: PointerEvent) => void;
                    textContent: import('vue').ComputedRef<string>;
                    propsAndAttrs: import('vue').ComputedRef<{
                        disabled: boolean;
                        icon: (string | import('vue').Component) | undefined;
                        onClick: ((...args: any[]) => any) | undefined;
                        onPointermove: ((...args: any[]) => any) | undefined;
                        onPointerleave: ((...args: any[]) => any) | undefined;
                        command: string | number | Record<string, any>;
                        divided: boolean;
                        textValue: string | undefined;
                    }>;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
                    readonly command: {
                        readonly type: PropType<string | number | Record<string, any>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    readonly disabled: BooleanConstructor;
                    readonly divided: BooleanConstructor;
                    readonly textValue: StringConstructor;
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                    onPointermove?: ((...args: any[]) => any) | undefined;
                    onPointerleave?: ((...args: any[]) => any) | undefined;
                }, {
                    readonly disabled: boolean;
                    readonly command: string | number | Record<string, any>;
                    readonly divided: boolean;
                }>;
                DropdownMenu: import('vue').DefineComponent<{
                    onKeydown: {
                        readonly type: PropType<(e: KeyboardEvent) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }, {
                    size: import('vue').ComputedRef<string> | undefined;
                    rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
                    tabIndex: import('vue').Ref<number>;
                    dropdownKls: import('vue').ComputedRef<string[]>;
                    role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    triggerId: import('vue').ComputedRef<string>;
                    dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
                    handleKeydown: (e: KeyboardEvent) => void;
                    onBlur: (e: Event) => void;
                    onFocus: (e: FocusEvent) => void;
                    onMousedown: (e: Event) => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
                    onKeydown: {
                        readonly type: PropType<(e: KeyboardEvent) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}>;
            };
            ElDropdownMenu: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    onKeydown: {
                        readonly type: PropType<(e: KeyboardEvent) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {
                    size: import('vue').ComputedRef<string> | undefined;
                    rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
                    tabIndex: import('vue').Ref<number>;
                    dropdownKls: import('vue').ComputedRef<string[]>;
                    role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    triggerId: import('vue').ComputedRef<string>;
                    dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
                    handleKeydown: (e: KeyboardEvent) => void;
                    onBlur: (e: Event) => void;
                    onFocus: (e: FocusEvent) => void;
                    onMousedown: (e: Event) => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, 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: PropType<(e: KeyboardEvent) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {
                    size: import('vue').ComputedRef<string> | undefined;
                    rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
                    tabIndex: import('vue').Ref<number>;
                    dropdownKls: import('vue').ComputedRef<string[]>;
                    role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    triggerId: import('vue').ComputedRef<string>;
                    dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
                    handleKeydown: (e: KeyboardEvent) => void;
                    onBlur: (e: Event) => void;
                    onFocus: (e: FocusEvent) => void;
                    onMousedown: (e: Event) => void;
                }, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                onKeydown: {
                    readonly type: PropType<(e: KeyboardEvent) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {
                size: import('vue').ComputedRef<string> | undefined;
                rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
                tabIndex: import('vue').Ref<number>;
                dropdownKls: import('vue').ComputedRef<string[]>;
                role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                triggerId: import('vue').ComputedRef<string>;
                dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
                handleKeydown: (e: KeyboardEvent) => void;
                onBlur: (e: Event) => void;
                onFocus: (e: FocusEvent) => void;
                onMousedown: (e: Event) => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
            ElDropdownItem: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly command: {
                        readonly type: PropType<string | number | Record<string, any>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    readonly disabled: BooleanConstructor;
                    readonly divided: BooleanConstructor;
                    readonly textValue: StringConstructor;
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                    onPointermove?: ((...args: any[]) => any) | undefined;
                    onPointerleave?: ((...args: any[]) => any) | undefined;
                }, {
                    handleClick: (event: PointerEvent) => void;
                    handlePointerMove: (event: PointerEvent) => void;
                    handlePointerLeave: (event: PointerEvent) => void;
                    textContent: import('vue').ComputedRef<string>;
                    propsAndAttrs: import('vue').ComputedRef<{
                        disabled: boolean;
                        icon: (string | import('vue').Component) | undefined;
                        onClick: ((...args: any[]) => any) | undefined;
                        onPointermove: ((...args: any[]) => any) | undefined;
                        onPointerleave: ((...args: any[]) => any) | undefined;
                        command: string | number | Record<string, any>;
                        divided: boolean;
                        textValue: string | undefined;
                    }>;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly disabled: boolean;
                    readonly command: string | number | Record<string, any>;
                    readonly divided: boolean;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly command: {
                        readonly type: PropType<string | number | Record<string, any>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    readonly disabled: BooleanConstructor;
                    readonly divided: BooleanConstructor;
                    readonly textValue: StringConstructor;
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                    onPointermove?: ((...args: any[]) => any) | undefined;
                    onPointerleave?: ((...args: any[]) => any) | undefined;
                }, {
                    handleClick: (event: PointerEvent) => void;
                    handlePointerMove: (event: PointerEvent) => void;
                    handlePointerLeave: (event: PointerEvent) => void;
                    textContent: import('vue').ComputedRef<string>;
                    propsAndAttrs: import('vue').ComputedRef<{
                        disabled: boolean;
                        icon: (string | import('vue').Component) | undefined;
                        onClick: ((...args: any[]) => any) | undefined;
                        onPointermove: ((...args: any[]) => any) | undefined;
                        onPointerleave: ((...args: any[]) => any) | undefined;
                        command: string | number | Record<string, any>;
                        divided: boolean;
                        textValue: string | undefined;
                    }>;
                }, {}, {}, {}, {
                    readonly disabled: boolean;
                    readonly command: string | number | Record<string, any>;
                    readonly divided: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly command: {
                    readonly type: PropType<string | number | Record<string, any>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly disabled: BooleanConstructor;
                readonly divided: BooleanConstructor;
                readonly textValue: StringConstructor;
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onClick?: ((...args: any[]) => any) | undefined;
                onPointermove?: ((...args: any[]) => any) | undefined;
                onPointerleave?: ((...args: any[]) => any) | undefined;
            }, {
                handleClick: (event: PointerEvent) => void;
                handlePointerMove: (event: PointerEvent) => void;
                handlePointerLeave: (event: PointerEvent) => void;
                textContent: import('vue').ComputedRef<string>;
                propsAndAttrs: import('vue').ComputedRef<{
                    disabled: boolean;
                    icon: (string | import('vue').Component) | undefined;
                    onClick: ((...args: any[]) => any) | undefined;
                    onPointermove: ((...args: any[]) => any) | undefined;
                    onPointerleave: ((...args: any[]) => any) | undefined;
                    command: string | number | Record<string, any>;
                    divided: boolean;
                    textValue: string | undefined;
                }>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", {
                readonly disabled: boolean;
                readonly command: string | number | Record<string, any>;
                readonly divided: boolean;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
            ElButtonGroup: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                }, 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: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                }>>, {}, {}, {}, {}, {
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin;
            ElButton: ({
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: {
                        readonly type: PropType<"button" | "reset" | "submit">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => any;
                    };
                    readonly plain: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly text: BooleanConstructor;
                    readonly link: BooleanConstructor;
                    readonly bg: BooleanConstructor;
                    readonly autofocus: BooleanConstructor;
                    readonly round: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly circle: BooleanConstructor;
                    readonly color: StringConstructor;
                    readonly dark: BooleanConstructor;
                    readonly autoInsertSpace: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly tag: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                }>> & {
                    onClick?: ((evt: MouseEvent) => any) | undefined;
                }, {
                    ref: import('vue').Ref<HTMLButtonElement | undefined>;
                    size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                    type: import('vue').ComputedRef<string>;
                    disabled: import('vue').ComputedRef<boolean>;
                    shouldAddSpace: import('vue').ComputedRef<boolean>;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    click: (evt: MouseEvent) => void;
                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly link: boolean;
                    readonly circle: boolean;
                    readonly text: boolean;
                    readonly disabled: boolean;
                    readonly round: boolean;
                    readonly dark: boolean;
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    readonly bg: boolean;
                    readonly loading: boolean;
                    readonly autofocus: boolean;
                    readonly tag: string | import('vue').Component;
                    readonly plain: boolean;
                    readonly nativeType: "button" | "reset" | "submit";
                    readonly loadingIcon: string | import('vue').Component;
                    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: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: {
                        readonly type: PropType<"button" | "reset" | "submit">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => any;
                    };
                    readonly plain: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly text: BooleanConstructor;
                    readonly link: BooleanConstructor;
                    readonly bg: BooleanConstructor;
                    readonly autofocus: BooleanConstructor;
                    readonly round: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly circle: BooleanConstructor;
                    readonly color: StringConstructor;
                    readonly dark: BooleanConstructor;
                    readonly autoInsertSpace: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly tag: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                }>> & {
                    onClick?: ((evt: MouseEvent) => any) | undefined;
                }, {
                    ref: import('vue').Ref<HTMLButtonElement | undefined>;
                    size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                    type: import('vue').ComputedRef<string>;
                    disabled: import('vue').ComputedRef<boolean>;
                    shouldAddSpace: import('vue').ComputedRef<boolean>;
                }, {}, {}, {}, {
                    readonly link: boolean;
                    readonly circle: boolean;
                    readonly text: boolean;
                    readonly disabled: boolean;
                    readonly round: boolean;
                    readonly dark: boolean;
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    readonly bg: boolean;
                    readonly loading: boolean;
                    readonly autofocus: boolean;
                    readonly tag: string | import('vue').Component;
                    readonly plain: boolean;
                    readonly nativeType: "button" | "reset" | "submit";
                    readonly loadingIcon: string | import('vue').Component;
                    readonly autoInsertSpace: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly nativeType: {
                    readonly type: PropType<"button" | "reset" | "submit">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
                readonly loading: BooleanConstructor;
                readonly loadingIcon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => any;
                };
                readonly plain: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly text: BooleanConstructor;
                readonly link: BooleanConstructor;
                readonly bg: BooleanConstructor;
                readonly autofocus: BooleanConstructor;
                readonly round: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly circle: BooleanConstructor;
                readonly color: StringConstructor;
                readonly dark: BooleanConstructor;
                readonly autoInsertSpace: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly tag: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
            }>> & {
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }, {
                ref: import('vue').Ref<HTMLButtonElement | undefined>;
                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                type: import('vue').ComputedRef<string>;
                disabled: import('vue').ComputedRef<boolean>;
                shouldAddSpace: import('vue').ComputedRef<boolean>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                click: (evt: MouseEvent) => void;
            }, string, {
                readonly link: boolean;
                readonly circle: boolean;
                readonly text: boolean;
                readonly disabled: boolean;
                readonly round: boolean;
                readonly dark: boolean;
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                readonly bg: boolean;
                readonly loading: boolean;
                readonly autofocus: boolean;
                readonly tag: string | import('vue').Component;
                readonly plain: boolean;
                readonly nativeType: "button" | "reset" | "submit";
                readonly loadingIcon: string | import('vue').Component;
                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?(_: {}): any;
                    icon?(_: {}): any;
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin) & {
                ButtonGroup: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    }, 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: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                    }>>, {}, {}, {}, {}, {
                        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                    $slots: {
                        default?(_: {}): any;
                    };
                });
            };
            ElIcon: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, 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: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin;
            ProDropdown: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                selected: PropType<import('../../ele-dropdown/types').DropdownItem | null>;
                transition: {
                    type: StringConstructor;
                    default: string;
                };
                items: PropType<import('../../ele-dropdown/types').DropdownItem[]>;
                modelValue: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
                menuStyle: PropType<import('../../ele-app/types').StyleValue>;
                iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                componentType: PropType<"pro">;
                preventContextmenu: BooleanConstructor;
                splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
                caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
                type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                effect: {
                    readonly default: "light";
                    readonly type: PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                placement: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                popperClass: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                teleported: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                disabled: BooleanConstructor;
                persistent: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                triggerKeys: {
                    readonly type: PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                popperOptions: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                id: StringConstructor;
                splitButton: BooleanConstructor;
                hideOnClick: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                loop: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                showTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                hideTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                tabindex: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                maxHeight: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                role: {
                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "menu";
                };
                buttonProps: {
                    readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
                ariaLabel: StringConstructor;
                appendTo: {
                    readonly type: PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                offset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                bg: StringConstructor;
                zIndex: NumberConstructor;
                visible: {
                    readonly type: PropType<boolean | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                trigger: {
                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                popperStyle: PropType<import('../../ele-app/types').StyleValue>;
                enterable: {
                    readonly default: true;
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                showArrow: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                arrowOffset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 5;
                };
                virtualRef: {
                    readonly type: PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                className: StringConstructor;
                gpuAcceleration: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                arrowBg: StringConstructor;
            }>, {
                ArrowDown: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
                tooltipRef: import('vue').Ref<import('../../ele-app/plus').EleTooltipInstance, import('../../ele-app/plus').EleTooltipInstance>;
                tooltipProps: import('vue').ComputedRef<Partial<import('../../ele-tooltip/props').TooltipProps>>;
                hasSubMenu: import('vue').ComputedRef<boolean>;
                hidePopper: () => void;
                updatePopper: () => void;
                handleUpdateVisible: (visible: boolean) => void;
                handlePopBeforeEnter: () => void;
                handlePopBeforeLeave: () => void;
                handlePopAfterEnter: () => void;
                handlePopAfterLeave: () => void;
                handleItemClick: (item: import('../../ele-dropdown/types').DropdownItem) => void;
                handleBtnClick: (e: MouseEvent) => void;
                handleOpen: () => void;
                handleClose: () => void;
                handleWrapperContext: (e: MouseEvent) => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                click: (_e: MouseEvent) => boolean;
                command: (_command: import('../../ele-dropdown/types').DropdownItem["command"]) => boolean;
                visibleChange: (_visible: boolean) => boolean;
                'update:modelValue': (_value: import('../../ele-dropdown/types').DropdownItem["command"]) => boolean;
                change: (_active: import('../../ele-dropdown/types').DropdownItem["command"]) => boolean;
                "update:visible": (value: boolean) => boolean;
                "before-enter": () => boolean;
                "before-leave": () => boolean;
                "after-enter": () => boolean;
                "after-leave": () => boolean;
            }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                selected: PropType<import('../../ele-dropdown/types').DropdownItem | null>;
                transition: {
                    type: StringConstructor;
                    default: string;
                };
                items: PropType<import('../../ele-dropdown/types').DropdownItem[]>;
                modelValue: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
                menuStyle: PropType<import('../../ele-app/types').StyleValue>;
                iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                componentType: PropType<"pro">;
                preventContextmenu: BooleanConstructor;
                splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
                caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
                type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                effect: {
                    readonly default: "light";
                    readonly type: PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                placement: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                popperClass: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                teleported: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                disabled: BooleanConstructor;
                persistent: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                triggerKeys: {
                    readonly type: PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                popperOptions: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                id: StringConstructor;
                splitButton: BooleanConstructor;
                hideOnClick: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                loop: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                showTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                hideTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                tabindex: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                maxHeight: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                role: {
                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "menu";
                };
                buttonProps: {
                    readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
                ariaLabel: StringConstructor;
                appendTo: {
                    readonly type: PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                offset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                bg: StringConstructor;
                zIndex: NumberConstructor;
                visible: {
                    readonly type: PropType<boolean | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                trigger: {
                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                popperStyle: PropType<import('../../ele-app/types').StyleValue>;
                enterable: {
                    readonly default: true;
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                showArrow: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                arrowOffset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 5;
                };
                virtualRef: {
                    readonly type: PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                className: StringConstructor;
                gpuAcceleration: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                arrowBg: StringConstructor;
            }>> & Readonly<{
                onChange?: ((_active: (string | number | Record<string, any>) | undefined) => any) | undefined;
                onClick?: ((_e: MouseEvent) => any) | undefined;
                onCommand?: ((_command: (string | number | Record<string, any>) | undefined) => any) | undefined;
                "onUpdate:visible"?: ((value: boolean) => any) | undefined;
                onVisibleChange?: ((_visible: boolean) => any) | undefined;
                "onUpdate:modelValue"?: ((_value: (string | number | Record<string, any>) | undefined) => any) | undefined;
                "onBefore-enter"?: (() => any) | undefined;
                "onBefore-leave"?: (() => any) | undefined;
                "onAfter-enter"?: (() => any) | undefined;
                "onAfter-leave"?: (() => any) | undefined;
            }>, {
                effect: import('element-plus').PopperEffect;
                placement: any;
                popperClass: string;
                teleported: boolean;
                disabled: boolean;
                offset: number;
                persistent: boolean;
                visible: boolean | null;
                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                triggerKeys: string[];
                popperOptions: any;
                splitButton: boolean;
                hideOnClick: boolean;
                loop: boolean;
                showTimeout: number;
                hideTimeout: number;
                tabindex: string | number;
                maxHeight: string | number;
                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                transition: string;
                enterable: boolean;
                showArrow: boolean;
                arrowOffset: number;
                virtualTriggering: boolean;
                gpuAcceleration: boolean;
                preventContextmenu: boolean;
            }, {}, {
                ElButton: ({
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly disabled: BooleanConstructor;
                        readonly type: {
                            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly icon: {
                            readonly type: PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly nativeType: {
                            readonly type: PropType<"button" | "reset" | "submit">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "button";
                        };
                        readonly loading: BooleanConstructor;
                        readonly loadingIcon: {
                            readonly type: PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => any;
                        };
                        readonly plain: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly text: BooleanConstructor;
                        readonly link: BooleanConstructor;
                        readonly bg: BooleanConstructor;
                        readonly autofocus: BooleanConstructor;
                        readonly round: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly circle: BooleanConstructor;
                        readonly color: StringConstructor;
                        readonly dark: BooleanConstructor;
                        readonly autoInsertSpace: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly tag: {
                            readonly type: PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "button";
                        };
                    }>> & {
                        onClick?: ((evt: MouseEvent) => any) | undefined;
                    }, {
                        ref: import('vue').Ref<HTMLButtonElement | undefined>;
                        size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                        type: import('vue').ComputedRef<string>;
                        disabled: import('vue').ComputedRef<boolean>;
                        shouldAddSpace: import('vue').ComputedRef<boolean>;
                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        click: (evt: MouseEvent) => void;
                    }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        readonly link: boolean;
                        readonly circle: boolean;
                        readonly text: boolean;
                        readonly disabled: boolean;
                        readonly round: boolean;
                        readonly dark: boolean;
                        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                        readonly bg: boolean;
                        readonly loading: boolean;
                        readonly autofocus: boolean;
                        readonly tag: string | import('vue').Component;
                        readonly plain: boolean;
                        readonly nativeType: "button" | "reset" | "submit";
                        readonly loadingIcon: string | import('vue').Component;
                        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: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly disabled: BooleanConstructor;
                        readonly type: {
                            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly icon: {
                            readonly type: PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly nativeType: {
                            readonly type: PropType<"button" | "reset" | "submit">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "button";
                        };
                        readonly loading: BooleanConstructor;
                        readonly loadingIcon: {
                            readonly type: PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => any;
                        };
                        readonly plain: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly text: BooleanConstructor;
                        readonly link: BooleanConstructor;
                        readonly bg: BooleanConstructor;
                        readonly autofocus: BooleanConstructor;
                        readonly round: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly circle: BooleanConstructor;
                        readonly color: StringConstructor;
                        readonly dark: BooleanConstructor;
                        readonly autoInsertSpace: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly tag: {
                            readonly type: PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "button";
                        };
                    }>> & {
                        onClick?: ((evt: MouseEvent) => any) | undefined;
                    }, {
                        ref: import('vue').Ref<HTMLButtonElement | undefined>;
                        size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                        type: import('vue').ComputedRef<string>;
                        disabled: import('vue').ComputedRef<boolean>;
                        shouldAddSpace: import('vue').ComputedRef<boolean>;
                    }, {}, {}, {}, {
                        readonly link: boolean;
                        readonly circle: boolean;
                        readonly text: boolean;
                        readonly disabled: boolean;
                        readonly round: boolean;
                        readonly dark: boolean;
                        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                        readonly bg: boolean;
                        readonly loading: boolean;
                        readonly autofocus: boolean;
                        readonly tag: string | import('vue').Component;
                        readonly plain: boolean;
                        readonly nativeType: "button" | "reset" | "submit";
                        readonly loadingIcon: string | import('vue').Component;
                        readonly autoInsertSpace: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: {
                        readonly type: PropType<"button" | "reset" | "submit">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => any;
                    };
                    readonly plain: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly text: BooleanConstructor;
                    readonly link: BooleanConstructor;
                    readonly bg: BooleanConstructor;
                    readonly autofocus: BooleanConstructor;
                    readonly round: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly circle: BooleanConstructor;
                    readonly color: StringConstructor;
                    readonly dark: BooleanConstructor;
                    readonly autoInsertSpace: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly tag: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                }>> & {
                    onClick?: ((evt: MouseEvent) => any) | undefined;
                }, {
                    ref: import('vue').Ref<HTMLButtonElement | undefined>;
                    size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                    type: import('vue').ComputedRef<string>;
                    disabled: import('vue').ComputedRef<boolean>;
                    shouldAddSpace: import('vue').ComputedRef<boolean>;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    click: (evt: MouseEvent) => void;
                }, string, {
                    readonly link: boolean;
                    readonly circle: boolean;
                    readonly text: boolean;
                    readonly disabled: boolean;
                    readonly round: boolean;
                    readonly dark: boolean;
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    readonly bg: boolean;
                    readonly loading: boolean;
                    readonly autofocus: boolean;
                    readonly tag: string | import('vue').Component;
                    readonly plain: boolean;
                    readonly nativeType: "button" | "reset" | "submit";
                    readonly loadingIcon: string | import('vue').Component;
                    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?(_: {}): any;
                        icon?(_: {}): any;
                        default?(_: {}): any;
                    };
                }) & import('vue').Plugin) & {
                    ButtonGroup: {
                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            readonly size: {
                                readonly type: PropType<"" | "small" | "default" | "large">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly type: {
                                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                            readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                        }, 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: PropType<"" | "small" | "default" | "large">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly type: {
                                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                        }>>, {}, {}, {}, {}, {
                            readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                        }>;
                        __isFragment?: never;
                        __isTeleport?: never;
                        __isSuspense?: never;
                    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                        $slots: {
                            default?(_: {}): any;
                        };
                    });
                };
                ElScrollbar: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly ariaLabel: StringConstructor;
                        readonly ariaOrientation: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly height: {
                            readonly type: PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly maxHeight: {
                            readonly type: PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly native: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        readonly wrapStyle: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly wrapClass: {
                            readonly type: PropType<string | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly viewClass: {
                            readonly type: PropType<string | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly viewStyle: {
                            readonly type: PropType<string | Record<string, any> | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly noresize: BooleanConstructor;
                        readonly tag: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "div";
                        };
                        readonly always: BooleanConstructor;
                        readonly minSize: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 20;
                        };
                        readonly tabindex: {
                            readonly type: PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly id: StringConstructor;
                        readonly role: StringConstructor;
                    }>> & {
                        onScroll?: ((args_0: {
                            scrollTop: number;
                            scrollLeft: number;
                        }) => any) | undefined;
                        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                    }, {
                        wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                        update: () => void;
                        scrollTo: {
                            (xCord: number, yCord?: number): void;
                            (options: ScrollToOptions): void;
                        };
                        setScrollTop: (value: number) => void;
                        setScrollLeft: (value: number) => void;
                        handleScroll: () => void;
                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        scroll: (args_0: {
                            scrollTop: number;
                            scrollLeft: number;
                        }) => void;
                        "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
                    }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        readonly height: string | number;
                        readonly maxHeight: string | number;
                        readonly always: boolean;
                        readonly tabindex: string | number;
                        readonly minSize: number;
                        readonly native: boolean;
                        readonly wrapStyle: import('vue').StyleValue;
                        readonly wrapClass: string | unknown[];
                        readonly viewClass: string | unknown[];
                        readonly viewStyle: string | Record<string, any> | unknown[];
                        readonly tag: string;
                        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: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly height: {
                            readonly type: PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly maxHeight: {
                            readonly type: PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly native: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        readonly wrapStyle: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly wrapClass: {
                            readonly type: PropType<string | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly viewClass: {
                            readonly type: PropType<string | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly viewStyle: {
                            readonly type: PropType<string | Record<string, any> | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly noresize: BooleanConstructor;
                        readonly tag: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "div";
                        };
                        readonly always: BooleanConstructor;
                        readonly minSize: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 20;
                        };
                        readonly tabindex: {
                            readonly type: PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly id: StringConstructor;
                        readonly role: StringConstructor;
                    }>> & {
                        onScroll?: ((args_0: {
                            scrollTop: number;
                            scrollLeft: number;
                        }) => any) | undefined;
                        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                    }, {
                        wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                        update: () => void;
                        scrollTo: {
                            (xCord: number, yCord?: number): void;
                            (options: ScrollToOptions): void;
                        };
                        setScrollTop: (value: number) => void;
                        setScrollLeft: (value: number) => void;
                        handleScroll: () => void;
                    }, {}, {}, {}, {
                        readonly height: string | number;
                        readonly maxHeight: string | number;
                        readonly always: boolean;
                        readonly tabindex: string | number;
                        readonly minSize: number;
                        readonly native: boolean;
                        readonly wrapStyle: import('vue').StyleValue;
                        readonly wrapClass: string | unknown[];
                        readonly viewClass: string | unknown[];
                        readonly viewStyle: string | Record<string, any> | unknown[];
                        readonly tag: string;
                        readonly noresize: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly ariaOrientation: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly height: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly maxHeight: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly native: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    readonly wrapStyle: {
                        readonly type: PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly wrapClass: {
                        readonly type: PropType<string | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly viewClass: {
                        readonly type: PropType<string | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly viewStyle: {
                        readonly type: PropType<string | Record<string, any> | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly noresize: BooleanConstructor;
                    readonly tag: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "div";
                    };
                    readonly always: BooleanConstructor;
                    readonly minSize: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 20;
                    };
                    readonly tabindex: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: ((args_0: {
                        scrollTop: number;
                        scrollLeft: number;
                    }) => any) | undefined;
                    "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                }, {
                    wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                    update: () => void;
                    scrollTo: {
                        (xCord: number, yCord?: number): void;
                        (options: ScrollToOptions): void;
                    };
                    setScrollTop: (value: number) => void;
                    setScrollLeft: (value: number) => void;
                    handleScroll: () => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    scroll: (args_0: {
                        scrollTop: number;
                        scrollLeft: number;
                    }) => void;
                    "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
                }, string, {
                    readonly height: string | number;
                    readonly maxHeight: string | number;
                    readonly always: boolean;
                    readonly tabindex: string | number;
                    readonly minSize: number;
                    readonly native: boolean;
                    readonly wrapStyle: import('vue').StyleValue;
                    readonly wrapClass: string | unknown[];
                    readonly viewClass: string | unknown[];
                    readonly viewStyle: string | Record<string, any> | unknown[];
                    readonly tag: string;
                    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?(_: {}): any;
                    };
                }) & import('vue').Plugin;
                EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                    bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
                    bg: StringConstructor;
                    arrowBg: StringConstructor;
                    width: (StringConstructor | NumberConstructor)[];
                    isPopover: BooleanConstructor;
                    showAfter: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    hideAfter: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 200;
                    };
                    autoClose: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    effect: {
                        readonly type: PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "dark";
                    };
                    ariaLabel: StringConstructor;
                    placement: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    teleported: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    appendTo: {
                        readonly type: PropType<string | HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    disabled: BooleanConstructor;
                    offset: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 12;
                    };
                    persistent: BooleanConstructor;
                    zIndex: NumberConstructor;
                    visible: {
                        readonly type: PropType<boolean | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    trigger: {
                        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "hover";
                    };
                    triggerKeys: {
                        readonly type: PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    popperOptions: {
                        readonly type: PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    transition: StringConstructor;
                    content: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    enterable: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    showArrow: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: boolean;
                    };
                    arrowOffset: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 5;
                    };
                    virtualRef: {
                        readonly type: PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    rawContent: BooleanConstructor;
                    gpuAcceleration: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    className: StringConstructor;
                    popperClass: StringConstructor;
                    popperStyle: PropType<import('../../ele-app/types').StyleValue>;
                }>, {
                    tooltipRef: import('vue').Ref<import('../../ele-app/el').ElTooltipInstance | undefined, import('../../ele-app/el').ElTooltipInstance | undefined>;
                    rootProps: import('vue').ComputedRef<Partial<import('element-plus').ElTooltipProps>>;
                    popperRef: import('vue').ComputedRef<import('../../ele-app/el').ElPopperInstance>;
                    contentRef: import('vue').ComputedRef<import('element-plus').TooltipContentInstance | undefined>;
                    isFocusInsideContent: () => void;
                    updatePopper: () => void;
                    handleOpen: (opt?: Event) => void;
                    handleClose: (opt?: Event) => void;
                    hide: (opt?: Event) => void;
                    handleUpdateVisible: (visible: boolean) => void;
                    handlePopBeforeShow: (e: Event) => void;
                    handlePopBeforeHide: (e: Event) => void;
                    handlePopShow: (e: Event) => void;
                    handlePopHide: (e: Event) => void;
                    handlePopOpen: (e: any) => void;
                    handlePopClose: (e: any) => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, import('../../ele-tooltip/props').TooltipEmits, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                    bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
                    bg: StringConstructor;
                    arrowBg: StringConstructor;
                    width: (StringConstructor | NumberConstructor)[];
                    isPopover: BooleanConstructor;
                    showAfter: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    hideAfter: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 200;
                    };
                    autoClose: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    effect: {
                        readonly type: PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "dark";
                    };
                    ariaLabel: StringConstructor;
                    placement: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    teleported: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    appendTo: {
                        readonly type: PropType<string | HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    disabled: BooleanConstructor;
                    offset: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 12;
                    };
                    persistent: BooleanConstructor;
                    zIndex: NumberConstructor;
                    visible: {
                        readonly type: PropType<boolean | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    trigger: {
                        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "hover";
                    };
                    triggerKeys: {
                        readonly type: PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    popperOptions: {
                        readonly type: PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    transition: StringConstructor;
                    content: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    enterable: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    showArrow: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: boolean;
                    };
                    arrowOffset: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 5;
                    };
                    virtualRef: {
                        readonly type: PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    rawContent: BooleanConstructor;
                    gpuAcceleration: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    className: StringConstructor;
                    popperClass: StringConstructor;
                    popperStyle: PropType<import('../../ele-app/types').StyleValue>;
                }>> & Readonly<{
                    onClose?: ((e: any) => any) | undefined;
                    onHide?: ((e: Event) => any) | undefined;
                    onOpen?: ((e: any) => any) | undefined;
                    "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
                    "onBefore-show"?: ((e: Event) => any) | undefined;
                    "onBefore-hide"?: ((e: Event) => any) | undefined;
                    onShow?: ((e: Event) => any) | undefined;
                }>, {
                    showAfter: number;
                    hideAfter: number;
                    autoClose: number;
                    effect: import('element-plus').PopperEffect;
                    placement: string;
                    teleported: boolean;
                    disabled: boolean;
                    offset: number;
                    persistent: boolean;
                    visible: boolean | null;
                    trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                    triggerKeys: string[];
                    popperOptions: any;
                    content: string;
                    enterable: boolean;
                    showArrow: boolean;
                    arrowOffset: number;
                    virtualTriggering: boolean;
                    rawContent: boolean;
                    gpuAcceleration: boolean;
                    isPopover: boolean;
                }, {}, {
                    ElTooltip: {
                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            showArrow: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: boolean;
                            };
                            arrowOffset: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 5;
                            };
                            disabled: BooleanConstructor;
                            trigger: {
                                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "hover";
                            };
                            triggerKeys: {
                                readonly type: PropType<string[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => string[];
                            };
                            virtualRef: {
                                readonly type: PropType<import('element-plus').Measurable>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            virtualTriggering: BooleanConstructor;
                            onMouseenter: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onMouseleave: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onClick: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onKeydown: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onFocus: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onBlur: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onContextmenu: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            id: StringConstructor;
                            open: BooleanConstructor;
                            ariaLabel: StringConstructor;
                            appendTo: {
                                readonly type: PropType<string | HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            content: {
                                readonly type: PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            rawContent: BooleanConstructor;
                            persistent: BooleanConstructor;
                            visible: {
                                readonly type: PropType<boolean | null>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: null;
                            };
                            transition: StringConstructor;
                            teleported: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            style: {
                                readonly type: PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            className: {
                                readonly type: PropType<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 | any[] | {
                                    [x: string]: boolean;
                                })[])[])[])[])[])[])[])[])[])[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            effect: {
                                readonly type: PropType<import('element-plus').PopperEffect>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "dark";
                            };
                            enterable: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            pure: BooleanConstructor;
                            focusOnShow: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            trapping: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            popperClass: {
                                readonly type: PropType<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 | any[] | {
                                    [x: string]: boolean;
                                })[])[])[])[])[])[])[])[])[])[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            popperStyle: {
                                readonly type: PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            referenceEl: {
                                readonly type: PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            triggerTargetEl: {
                                readonly type: PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            stopPopperMouseEvent: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            zIndex: NumberConstructor;
                            boundariesPadding: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            fallbackPlacements: {
                                readonly type: PropType<Placement[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: undefined;
                            };
                            gpuAcceleration: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            offset: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 12;
                            };
                            placement: {
                                readonly type: PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "bottom";
                            };
                            popperOptions: {
                                readonly type: PropType<any>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => {};
                            };
                            strategy: {
                                readonly type: PropType<"fixed" | "absolute">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "absolute";
                            };
                            showAfter: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            hideAfter: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 200;
                            };
                            autoClose: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            "onUpdate:visible": {
                                readonly type: PropType<(val: boolean) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            role: {
                                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "tooltip";
                            };
                        }>>, {
                            popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                            contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
                            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                            updatePopper: () => void;
                            onOpen: (event?: Event) => void;
                            onClose: (event?: Event) => void;
                            hide: (event?: Event) => void;
                        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                            [x: string]: (...args: any[]) => void;
                        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                            disabled: boolean;
                            content: string;
                            offset: number;
                            visible: boolean | null;
                            open: boolean;
                            placement: string;
                            strategy: "fixed" | "absolute";
                            effect: import('element-plus').PopperEffect;
                            showAfter: number;
                            hideAfter: number;
                            autoClose: number;
                            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                            virtualTriggering: boolean;
                            arrowOffset: number;
                            boundariesPadding: number;
                            fallbackPlacements: Placement[];
                            gpuAcceleration: boolean;
                            popperOptions: Partial<Options>;
                            enterable: boolean;
                            focusOnShow: boolean;
                            trapping: boolean;
                            stopPopperMouseEvent: boolean;
                            pure: boolean;
                            triggerKeys: string[];
                            teleported: boolean;
                            rawContent: boolean;
                            persistent: boolean;
                            showArrow: boolean;
                        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            showArrow: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: boolean;
                            };
                            arrowOffset: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 5;
                            };
                            disabled: BooleanConstructor;
                            trigger: {
                                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "hover";
                            };
                            triggerKeys: {
                                readonly type: PropType<string[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => string[];
                            };
                            virtualRef: {
                                readonly type: PropType<import('element-plus').Measurable>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            virtualTriggering: BooleanConstructor;
                            onMouseenter: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onMouseleave: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onClick: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onKeydown: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onFocus: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onBlur: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onContextmenu: {
                                readonly type: PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            id: StringConstructor;
                            open: BooleanConstructor;
                            ariaLabel: StringConstructor;
                            appendTo: {
                                readonly type: PropType<string | HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            content: {
                                readonly type: PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            rawContent: BooleanConstructor;
                            persistent: BooleanConstructor;
                            visible: {
                                readonly type: PropType<boolean | null>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: null;
                            };
                            transition: StringConstructor;
                            teleported: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            style: {
                                readonly type: PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            className: {
                                readonly type: PropType<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 | any[] | {
                                    [x: string]: boolean;
                                })[])[])[])[])[])[])[])[])[])[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            effect: {
                                readonly type: PropType<import('element-plus').PopperEffect>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "dark";
                            };
                            enterable: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            pure: BooleanConstructor;
                            focusOnShow: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            trapping: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            popperClass: {
                                readonly type: PropType<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 | any[] | {
                                    [x: string]: boolean;
                                })[])[])[])[])[])[])[])[])[])[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            popperStyle: {
                                readonly type: PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            referenceEl: {
                                readonly type: PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            triggerTargetEl: {
                                readonly type: PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            stopPopperMouseEvent: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            zIndex: NumberConstructor;
                            boundariesPadding: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            fallbackPlacements: {
                                readonly type: PropType<Placement[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: undefined;
                            };
                            gpuAcceleration: {
                                readonly type: PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            offset: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 12;
                            };
                            placement: {
                                readonly type: PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "bottom";
                            };
                            popperOptions: {
                                readonly type: PropType<any>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => {};
                            };
                            strategy: {
                                readonly type: PropType<"fixed" | "absolute">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "absolute";
                            };
                            showAfter: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            hideAfter: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 200;
                            };
                            autoClose: {
                                readonly type: PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            "onUpdate:visible": {
                                readonly type: PropType<(val: boolean) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            role: {
                                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "tooltip";
                            };
                        }>>, {
                            popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                            contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
                            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                            updatePopper: () => void;
                            onOpen: (event?: Event) => void;
                            onClose: (event?: Event) => void;
                            hide: (event?: Event) => void;
                        }, {}, {}, {}, {
                            disabled: boolean;
                            content: string;
                            offset: number;
                            visible: boolean | null;
                            open: boolean;
                            placement: string;
                            strategy: "fixed" | "absolute";
                            effect: import('element-plus').PopperEffect;
                            showAfter: number;
                            hideAfter: number;
                            autoClose: number;
                            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                            virtualTriggering: boolean;
                            arrowOffset: number;
                            boundariesPadding: number;
                            fallbackPlacements: Placement[];
                            gpuAcceleration: boolean;
                            popperOptions: Partial<Options>;
                            enterable: boolean;
                            focusOnShow: boolean;
                            trapping: boolean;
                            stopPopperMouseEvent: boolean;
                            pure: boolean;
                            triggerKeys: string[];
                            teleported: boolean;
                            rawContent: boolean;
                            persistent: boolean;
                            showArrow: boolean;
                        }>;
                        __isFragment?: never;
                        __isTeleport?: never;
                        __isSuspense?: never;
                    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        showArrow: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: boolean;
                        };
                        arrowOffset: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 5;
                        };
                        disabled: BooleanConstructor;
                        trigger: {
                            readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "hover";
                        };
                        triggerKeys: {
                            readonly type: PropType<string[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => string[];
                        };
                        virtualRef: {
                            readonly type: PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        onMouseenter: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onMouseleave: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onClick: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onKeydown: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onFocus: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onBlur: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onContextmenu: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        id: StringConstructor;
                        open: BooleanConstructor;
                        ariaLabel: StringConstructor;
                        appendTo: {
                            readonly type: PropType<string | HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        content: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        rawContent: BooleanConstructor;
                        persistent: BooleanConstructor;
                        visible: {
                            readonly type: PropType<boolean | null>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: null;
                        };
                        transition: StringConstructor;
                        teleported: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        style: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        className: {
                            readonly type: PropType<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 | any[] | {
                                [x: string]: boolean;
                            })[])[])[])[])[])[])[])[])[])[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        effect: {
                            readonly type: PropType<import('element-plus').PopperEffect>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "dark";
                        };
                        enterable: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        pure: BooleanConstructor;
                        focusOnShow: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        trapping: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        popperClass: {
                            readonly type: PropType<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 | any[] | {
                                [x: string]: boolean;
                            })[])[])[])[])[])[])[])[])[])[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        popperStyle: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        referenceEl: {
                            readonly type: PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        triggerTargetEl: {
                            readonly type: PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        stopPopperMouseEvent: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        zIndex: NumberConstructor;
                        boundariesPadding: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        fallbackPlacements: {
                            readonly type: PropType<Placement[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        gpuAcceleration: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        offset: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 12;
                        };
                        placement: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "bottom";
                        };
                        popperOptions: {
                            readonly type: PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => {};
                        };
                        strategy: {
                            readonly type: PropType<"fixed" | "absolute">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "absolute";
                        };
                        showAfter: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        hideAfter: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 200;
                        };
                        autoClose: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        "onUpdate:visible": {
                            readonly type: PropType<(val: boolean) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        role: {
                            readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "tooltip";
                        };
                    }>>, {
                        popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                        contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
                        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                        updatePopper: () => void;
                        onOpen: (event?: Event) => void;
                        onClose: (event?: Event) => void;
                        hide: (event?: Event) => void;
                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        [x: string]: (...args: any[]) => void;
                    }, string, {
                        disabled: boolean;
                        content: string;
                        offset: number;
                        visible: boolean | null;
                        open: boolean;
                        placement: string;
                        strategy: "fixed" | "absolute";
                        effect: import('element-plus').PopperEffect;
                        showAfter: number;
                        hideAfter: number;
                        autoClose: number;
                        trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                        role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                        virtualTriggering: boolean;
                        arrowOffset: number;
                        boundariesPadding: number;
                        fallbackPlacements: Placement[];
                        gpuAcceleration: boolean;
                        popperOptions: Partial<Options>;
                        enterable: boolean;
                        focusOnShow: boolean;
                        trapping: boolean;
                        stopPopperMouseEvent: boolean;
                        pure: boolean;
                        triggerKeys: string[];
                        teleported: boolean;
                        rawContent: boolean;
                        persistent: boolean;
                        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?(_: {}): any;
                            content?(_: {}): any;
                        };
                    }) & import('vue').Plugin;
                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
                DropdownMenus: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                    items: {
                        type: PropType<import('../../ele-dropdown/types').DropdownItem[]>;
                        required: true;
                    };
                    selected: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
                    menuStyle: PropType<import('../../ele-app/types').StyleValue>;
                    iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                    size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
                }>, {
                    handleItemClick: (item: import('../../ele-dropdown/types').DropdownItem) => void;
                    handleWrapperContext: (e: MouseEvent) => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    itemClick: (_item: import('../../ele-dropdown/types').DropdownItem) => true;
                    wrapperContext: (_e: MouseEvent) => true;
                }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                    items: {
                        type: PropType<import('../../ele-dropdown/types').DropdownItem[]>;
                        required: true;
                    };
                    selected: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
                    menuStyle: PropType<import('../../ele-app/types').StyleValue>;
                    iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                    size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
                }>> & Readonly<{
                    onItemClick?: ((_item: import('../../ele-dropdown/types').DropdownItem) => any) | undefined;
                    onWrapperContext?: ((_e: MouseEvent) => any) | undefined;
                }>, {}, {}, {
                    DropdownMenuItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                        item: {
                            type: PropType<import('../../ele-dropdown/types').DropdownItem>;
                            required: true;
                        };
                        selected: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
                        iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                    }>, {
                        itemRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                        subMenuRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                        placement: import('vue').Ref<"rightEnd" | "leftStart" | "leftEnd" | undefined, "rightEnd" | "leftStart" | "leftEnd" | undefined>;
                        handleItemClick: () => void;
                        handleItemMouseenter: () => void;
                        handleWrapperContext: (e: MouseEvent) => void;
                    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        itemClick: (_item: import('../../ele-dropdown/types').DropdownItem) => true;
                        wrapperContext: (_e: MouseEvent) => true;
                    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                        item: {
                            type: PropType<import('../../ele-dropdown/types').DropdownItem>;
                            required: true;
                        };
                        selected: PropType<import('../../ele-dropdown/types').DropdownItem["command"]>;
                        iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                    }>> & Readonly<{
                        onItemClick?: ((_item: import('../../ele-dropdown/types').DropdownItem) => any) | undefined;
                        onWrapperContext?: ((_e: MouseEvent) => any) | undefined;
                    }>, {}, {}, {
                        ElIcon: {
                            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                                readonly size: {
                                    readonly type: PropType<string | number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                readonly color: {
                                    readonly type: PropType<string>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, 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: PropType<string | number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                readonly color: {
                                    readonly type: PropType<string>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                            }>>, {}, {}, {}, {}, {}>;
                            __isFragment?: never;
                            __isTeleport?: never;
                            __isSuspense?: never;
                        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                            readonly size: {
                                readonly type: PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly color: {
                                readonly type: PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                            $slots: {
                                default?(_: {}): any;
                            };
                        }) & import('vue').Plugin;
                        ArrowRight: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
                    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        CornerLeftFilled: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        CornerRightFilled: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;