import { EleMenusInstance } from '../ele-app/plus';
import { MenuItem } from '../ele-menus/types';
import { TabPaneItem, TabEventOption } from '../ele-tabs/types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    headerMenus: import('vue').PropType<MenuItem[]>;
    headerActive: StringConstructor;
    sidebarMenus: import('vue').PropType<MenuItem[]>;
    sidebarActive: StringConstructor;
    sideboxMenus: import('vue').PropType<MenuItem[]>;
    sideboxActive: StringConstructor;
    tabs: import('vue').PropType<TabPaneItem[]>;
    tabActive: StringConstructor;
    levels: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbItem[]>;
    collapse: BooleanConstructor;
    compact: BooleanConstructor;
    maximized: import('vue').PropType<import('./types').Maximized>;
    tabBar: import('vue').PropType<import('./types').TabBar>;
    breadcrumb: import('vue').PropType<boolean | import('../ele-app/plus').EleBreadcrumbProps>;
    backTop: import('vue').PropType<boolean | import('../ele-app/plus').EleBacktopProps>;
    headerMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
    sidebarMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
    sideboxMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
    layout: import('vue').PropType<import('./types').Layout>;
    sidebarLayout: import('vue').PropType<import('./types').SidebarLayout>;
    headerStyle: import('vue').PropType<import('./types').HeaderStyle>;
    sidebarStyle: import('vue').PropType<import('./types').SidebarStyle>;
    tabStyle: {
        type: import('vue').PropType<import('./types').TabStyle>;
        default: string;
    };
    fixedHeader: BooleanConstructor;
    fixedSidebar: BooleanConstructor;
    fixedBody: BooleanConstructor;
    logoInHeader: BooleanConstructor;
    fixedHome: BooleanConstructor;
    homePath: StringConstructor;
    isHome: BooleanConstructor;
    tabContextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
    tabContextMenus: import('vue').PropType<import('../ele-tabs/types').ContextMenus>;
    tabSortable: BooleanConstructor;
    headerTitleSlot: {
        type: StringConstructor;
        default: string;
    };
    headerIconSlot: {
        type: StringConstructor;
        default: string;
    };
    sidebarTitleSlot: {
        type: StringConstructor;
        default: string;
    };
    sidebarIconSlot: {
        type: StringConstructor;
        default: string;
    };
    sideboxTitleSlot: {
        type: StringConstructor;
        default: string;
    };
    sideboxIconSlot: {
        type: StringConstructor;
        default: string;
    };
    headerCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sidebarCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sideboxCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    tabsCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    contentCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    logoStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    logoTitleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    headerMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sidebarMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sideboxMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    logoSrc: StringConstructor;
    logoTitle: StringConstructor;
    menuScrollToActive: {
        type: BooleanConstructor;
        default: boolean;
    };
    mobile: BooleanConstructor;
}>, {
    ownSlots: string[];
    tabSlots: string[];
    sidebarMenuRef: import('vue').ShallowRef<EleMenusInstance, EleMenusInstance>;
    sideboxMenuRef: import('vue').ShallowRef<EleMenusInstance, EleMenusInstance>;
    contentRef: import('vue').ShallowRef<HTMLElement | null, HTMLElement | null>;
    modalsRef: import('vue').ShallowRef<HTMLElement | null, HTMLElement | null>;
    isDisableTransition: import('vue').ShallowRef<boolean, boolean>;
    layoutHeight: import('vue').ComputedRef<string | undefined>;
    isFixedHeader: import('vue').ComputedRef<boolean>;
    isFixedSidebar: import('vue').ComputedRef<boolean>;
    isTopLayout: import('vue').ComputedRef<boolean>;
    isSideLayout: import('vue').ComputedRef<boolean>;
    isBoxSidebar: import('vue').ComputedRef<boolean>;
    isMixSidebar: import('vue').ComputedRef<boolean>;
    isMobile: import('vue').ComputedRef<boolean>;
    isHeaderLogo: import('vue').ComputedRef<boolean>;
    showHeaderMenus: import('vue').ComputedRef<boolean>;
    showHeaderTabs: import('vue').ComputedRef<boolean>;
    isDarkHeader: import('vue').ComputedRef<boolean>;
    isPrimaryHeader: import('vue').ComputedRef<boolean>;
    isButtonTab: import('vue').ComputedRef<boolean>;
    isDarkSidebar: import('vue').ComputedRef<boolean>;
    isDarkMixSidebar: import('vue').ComputedRef<boolean>;
    isGhostHeader: import('vue').ComputedRef<boolean>;
    isGhostSidebar: import('vue').ComputedRef<boolean>;
    isCollapseSidebar: import('vue').ComputedRef<boolean>;
    isCollapseMobile: import('vue').ComputedRef<boolean>;
    getContentEl: () => HTMLElement | null;
    getModalsEl: () => HTMLElement | null;
    updateCollapse: (value?: boolean) => void;
    handleLogoClick: (e: MouseEvent) => void;
    handleHeadMenuOpen: (index: string, indexPath: string[]) => void;
    handleHeadMenuClose: (index: string, indexPath: string[]) => void;
    handleHeadMenuItemClick: (item: MenuItem, e: MouseEvent) => void;
    handleHeadMenuItemMouseenter: (item: MenuItem, e: MouseEvent) => void;
    handleHeadMenuItemMouseleave: (item: MenuItem, e: MouseEvent) => void;
    handleHeadMouseenter: (e: MouseEvent) => void;
    handleHeadMouseleave: (e: MouseEvent) => void;
    handleBoxMenuItemClick: (item: MenuItem, e: MouseEvent) => void;
    handleBoxMenuItemMouseenter: (item: MenuItem, e: MouseEvent) => void;
    handleBoxMenuItemMouseleave: (item: MenuItem, e: MouseEvent) => void;
    handleBoxMouseEnter: (e: MouseEvent) => void;
    handleBoxMouseLeave: (e: MouseEvent) => void;
    handleSideMenuOpen: (index: string, indexPath: string[]) => void;
    handleSideMenuClose: (index: string, indexPath: string[]) => void;
    handleSideMenuItemClick: (item: MenuItem, e: MouseEvent) => void;
    handleSideMouseEnter: (e: MouseEvent) => void;
    handleSideMouseLeave: (e: MouseEvent) => void;
    handleTabClick: (option: TabEventOption) => void;
    handleTabRemove: (name: string) => void;
    handleTabContextMenu: (option: TabEventOption) => void;
    handleTabSortChange: (data: TabPaneItem[]) => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    'update:collapse': (_collapse: boolean) => boolean;
    logoClick: (_e: MouseEvent) => boolean;
    headMenuOpen: (_index: string, _indexPath: string[]) => boolean;
    headMenuClose: (_index: string, _indexPath: string[]) => boolean;
    headMenuItemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
    headMenuItemMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
    headMenuItemMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
    headMouseenter: (_e: MouseEvent) => boolean;
    headMouseleave: (_e: MouseEvent) => boolean;
    boxMenuItemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
    boxMenuItemMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
    boxMenuItemMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
    boxMouseenter: (_e: MouseEvent) => boolean;
    boxMouseleave: (_e: MouseEvent) => boolean;
    sideMenuOpen: (_index: string, _indexPath: string[]) => boolean;
    sideMenuClose: (_index: string, _indexPath: string[]) => boolean;
    sideMenuItemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
    sideMouseenter: (_e: MouseEvent) => boolean;
    sideMouseleave: (_e: MouseEvent) => boolean;
    tabClick: (_option: TabEventOption) => boolean;
    tabRemove: (_name: string) => boolean;
    tabContextMenu: (_option: TabEventOption) => boolean;
    tabSortChange: (_data: TabPaneItem[]) => boolean;
    contentMounted: (_contentEl: HTMLElement, _modalsEl: HTMLElement) => boolean;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    height: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    headerMenus: import('vue').PropType<MenuItem[]>;
    headerActive: StringConstructor;
    sidebarMenus: import('vue').PropType<MenuItem[]>;
    sidebarActive: StringConstructor;
    sideboxMenus: import('vue').PropType<MenuItem[]>;
    sideboxActive: StringConstructor;
    tabs: import('vue').PropType<TabPaneItem[]>;
    tabActive: StringConstructor;
    levels: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbItem[]>;
    collapse: BooleanConstructor;
    compact: BooleanConstructor;
    maximized: import('vue').PropType<import('./types').Maximized>;
    tabBar: import('vue').PropType<import('./types').TabBar>;
    breadcrumb: import('vue').PropType<boolean | import('../ele-app/plus').EleBreadcrumbProps>;
    backTop: import('vue').PropType<boolean | import('../ele-app/plus').EleBacktopProps>;
    headerMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
    sidebarMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
    sideboxMenuProps: import('vue').PropType<import('../ele-app/plus').EleMenusProps>;
    layout: import('vue').PropType<import('./types').Layout>;
    sidebarLayout: import('vue').PropType<import('./types').SidebarLayout>;
    headerStyle: import('vue').PropType<import('./types').HeaderStyle>;
    sidebarStyle: import('vue').PropType<import('./types').SidebarStyle>;
    tabStyle: {
        type: import('vue').PropType<import('./types').TabStyle>;
        default: string;
    };
    fixedHeader: BooleanConstructor;
    fixedSidebar: BooleanConstructor;
    fixedBody: BooleanConstructor;
    logoInHeader: BooleanConstructor;
    fixedHome: BooleanConstructor;
    homePath: StringConstructor;
    isHome: BooleanConstructor;
    tabContextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
    tabContextMenus: import('vue').PropType<import('../ele-tabs/types').ContextMenus>;
    tabSortable: BooleanConstructor;
    headerTitleSlot: {
        type: StringConstructor;
        default: string;
    };
    headerIconSlot: {
        type: StringConstructor;
        default: string;
    };
    sidebarTitleSlot: {
        type: StringConstructor;
        default: string;
    };
    sidebarIconSlot: {
        type: StringConstructor;
        default: string;
    };
    sideboxTitleSlot: {
        type: StringConstructor;
        default: string;
    };
    sideboxIconSlot: {
        type: StringConstructor;
        default: string;
    };
    headerCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sidebarCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sideboxCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    tabsCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    contentCustomStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    logoStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    logoTitleStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    headerMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sidebarMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    sideboxMenusStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
    logoSrc: StringConstructor;
    logoTitle: StringConstructor;
    menuScrollToActive: {
        type: BooleanConstructor;
        default: boolean;
    };
    mobile: BooleanConstructor;
}>> & Readonly<{
    onTabContextMenu?: ((_option: TabEventOption) => any) | undefined;
    onTabSortChange?: ((_data: TabPaneItem[]) => any) | undefined;
    onTabClick?: ((_option: TabEventOption) => any) | undefined;
    onTabRemove?: ((_name: string) => any) | undefined;
    "onUpdate:collapse"?: ((_collapse: boolean) => any) | undefined;
    onLogoClick?: ((_e: MouseEvent) => any) | undefined;
    onHeadMenuOpen?: ((_index: string, _indexPath: string[]) => any) | undefined;
    onHeadMenuClose?: ((_index: string, _indexPath: string[]) => any) | undefined;
    onHeadMenuItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    onHeadMenuItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    onHeadMenuItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    onHeadMouseenter?: ((_e: MouseEvent) => any) | undefined;
    onHeadMouseleave?: ((_e: MouseEvent) => any) | undefined;
    onBoxMenuItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    onBoxMenuItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    onBoxMenuItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    onBoxMouseenter?: ((_e: MouseEvent) => any) | undefined;
    onBoxMouseleave?: ((_e: MouseEvent) => any) | undefined;
    onSideMenuOpen?: ((_index: string, _indexPath: string[]) => any) | undefined;
    onSideMenuClose?: ((_index: string, _indexPath: string[]) => any) | undefined;
    onSideMenuItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    onSideMouseenter?: ((_e: MouseEvent) => any) | undefined;
    onSideMouseleave?: ((_e: MouseEvent) => any) | undefined;
    onContentMounted?: ((_contentEl: HTMLElement, _modalsEl: HTMLElement) => any) | undefined;
}>, {
    height: string | number;
    collapse: boolean;
    compact: boolean;
    tabStyle: import('./types').TabStyle;
    fixedHeader: boolean;
    fixedSidebar: boolean;
    fixedBody: boolean;
    logoInHeader: boolean;
    fixedHome: boolean;
    isHome: boolean;
    tabSortable: boolean;
    headerTitleSlot: string;
    headerIconSlot: string;
    sidebarTitleSlot: string;
    sidebarIconSlot: string;
    sideboxTitleSlot: string;
    sideboxIconSlot: string;
    menuScrollToActive: boolean;
    mobile: boolean;
}, {}, {
    ElScrollbar: {
        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            readonly ariaLabel: StringConstructor;
            readonly ariaOrientation: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly height: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly maxHeight: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly native: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: false;
            };
            readonly wrapStyle: {
                readonly type: import('vue').PropType<import('vue').StyleValue>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly wrapClass: {
                readonly type: import('vue').PropType<string | unknown[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly viewClass: {
                readonly type: import('vue').PropType<string | unknown[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly viewStyle: {
                readonly type: import('vue').PropType<string | Record<string, any> | unknown[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly noresize: BooleanConstructor;
            readonly tag: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "div";
            };
            readonly always: BooleanConstructor;
            readonly minSize: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 20;
            };
            readonly tabindex: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            readonly id: StringConstructor;
            readonly role: StringConstructor;
        }>> & {
            onScroll?: ((args_0: {
                scrollTop: number;
                scrollLeft: number;
            }) => any) | undefined;
            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
        }, {
            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
            update: () => void;
            scrollTo: {
                (xCord: number, yCord?: number): void;
                (options: ScrollToOptions): void;
            };
            setScrollTop: (value: number) => void;
            setScrollLeft: (value: number) => void;
            handleScroll: () => void;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            scroll: (args_0: {
                scrollTop: number;
                scrollLeft: number;
            }) => void;
            "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
        }, 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: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly height: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly maxHeight: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly native: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: false;
            };
            readonly wrapStyle: {
                readonly type: import('vue').PropType<import('vue').StyleValue>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly wrapClass: {
                readonly type: import('vue').PropType<string | unknown[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly viewClass: {
                readonly type: import('vue').PropType<string | unknown[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly viewStyle: {
                readonly type: import('vue').PropType<string | Record<string, any> | unknown[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly noresize: BooleanConstructor;
            readonly tag: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "div";
            };
            readonly always: BooleanConstructor;
            readonly minSize: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 20;
            };
            readonly tabindex: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            readonly id: StringConstructor;
            readonly role: StringConstructor;
        }>> & {
            onScroll?: ((args_0: {
                scrollTop: number;
                scrollLeft: number;
            }) => any) | undefined;
            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
        }, {
            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
            update: () => void;
            scrollTo: {
                (xCord: number, yCord?: number): void;
                (options: ScrollToOptions): void;
            };
            setScrollTop: (value: number) => void;
            setScrollLeft: (value: number) => void;
            handleScroll: () => void;
        }, {}, {}, {}, {
            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: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly height: {
            readonly type: import('vue').PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        readonly maxHeight: {
            readonly type: import('vue').PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        readonly native: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: false;
        };
        readonly wrapStyle: {
            readonly type: import('vue').PropType<import('vue').StyleValue>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        readonly wrapClass: {
            readonly type: import('vue').PropType<string | unknown[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        readonly viewClass: {
            readonly type: import('vue').PropType<string | unknown[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        readonly viewStyle: {
            readonly type: import('vue').PropType<string | Record<string, any> | unknown[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        readonly noresize: BooleanConstructor;
        readonly tag: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "div";
        };
        readonly always: BooleanConstructor;
        readonly minSize: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 20;
        };
        readonly tabindex: {
            readonly type: import('vue').PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: undefined;
        };
        readonly id: StringConstructor;
        readonly role: StringConstructor;
    }>> & {
        onScroll?: ((args_0: {
            scrollTop: number;
            scrollLeft: number;
        }) => any) | undefined;
        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
    }, {
        wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
        update: () => void;
        scrollTo: {
            (xCord: number, yCord?: number): void;
            (options: ScrollToOptions): void;
        };
        setScrollTop: (value: number) => void;
        setScrollLeft: (value: number) => void;
        handleScroll: () => void;
    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        scroll: (args_0: {
            scrollTop: number;
            scrollLeft: number;
        }) => void;
        "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
    }, string, {
        readonly height: string | number;
        readonly maxHeight: string | number;
        readonly always: boolean;
        readonly tabindex: string | number;
        readonly minSize: number;
        readonly 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;
    EleMenus: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        mode: import('vue').PropType<import('../ele-menus/types').MenuMode>;
        items: {
            type: import('vue').PropType<MenuItem[]>;
            required: boolean;
        };
        theme: import('vue').PropType<import('../ele-menus/types').MenuTheme>;
        popupTheme: {
            type: import('vue').PropType<import('../ele-menus/types').PopupMenuTheme>;
            default: string;
        };
        colorful: BooleanConstructor;
        popupColorful: {
            type: import('vue').PropType<import('../ele-menus/types').PopupColorful>;
            default: string;
        };
        firstPopperClass: StringConstructor;
        tooltipDisabled: BooleanConstructor;
        ellipsisProps: import('vue').PropType<import('../ele-menus/types').EllipsisProps>;
        textEllipsisTooltip: import('vue').PropType<import('../ele-menus/types').TextEllipsisTooltip>;
        defaultActive: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        defaultOpeneds: {
            readonly type: import('vue').PropType<string[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => [];
        };
        uniqueOpened: BooleanConstructor;
        router: BooleanConstructor;
        menuTrigger: {
            readonly type: import('vue').PropType<"click" | "hover">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "hover";
        };
        collapse: BooleanConstructor;
        backgroundColor: StringConstructor;
        textColor: StringConstructor;
        activeTextColor: StringConstructor;
        closeOnClickOutside: BooleanConstructor;
        collapseTransition: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        ellipsis: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        popperOffset: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 6;
        };
        ellipsisIcon: {
            readonly type: import('vue').PropType<string | import('vue').Component>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => any;
        };
        popperEffect: {
            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "dark";
        };
        popperClass: StringConstructor;
        showTimeout: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 300;
        };
        hideTimeout: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 300;
        };
        persistent: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
    }>, {
        EllipsisOutlined: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        getPopperClass: typeof import('../ele-menus/util').getPopperClass;
        isWebkit: boolean;
        menuRef: import('vue').Ref<import('../ele-app/el').ElMenuInstance, import('../ele-app/el').ElMenuInstance>;
        ellipsisRef: import('vue').Ref<import('../ele-app/el').ElSubMenuInstance, import('../ele-app/el').ElSubMenuInstance>;
        menuItems: import('vue').ShallowRef<MenuItem[] | undefined, MenuItem[] | undefined>;
        moreMenuItems: import('vue').ShallowRef<MenuItem[] | undefined, MenuItem[] | undefined>;
        tooltipVirtualRef: import('vue').Ref<any, any>;
        tooltipContent: import('vue').Ref<string, string>;
        tooltipVisible: import('vue').Ref<boolean, boolean>;
        isCompact: import('vue').ComputedRef<boolean>;
        collapseTooltipDisabled: import('vue').ComputedRef<boolean>;
        menuProps: import('vue').ComputedRef<import('../ele-app/el').ElMenuProps>;
        open: (index: string) => void;
        close: (index: string) => void;
        handleOpen: (index: string, indexPath: string[]) => void;
        handleClose: (index: string, indexPath: string[]) => void;
        handleSelect: (index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure> | undefined) => void;
        handleItemClick: import('../ele-menus/types').MenuItemEvent;
        handleItemMouseenter: import('../ele-menus/types').MenuItemEvent;
        handleItemMouseleave: import('../ele-menus/types').MenuItemEvent;
        handleParentMouseenter: import('../ele-menus/types').MenuItemEvent;
        handleParentMouseleave: import('../ele-menus/types').MenuItemEvent;
        scrollToActive: () => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        itemClick: (_item: MenuItem, _e: MouseEvent) => boolean;
        itemMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
        itemMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
        parentMouseenter: (_item: MenuItem, _e: MouseEvent) => boolean;
        parentMouseleave: (_item: MenuItem, _e: MouseEvent) => boolean;
        close: (index: string, indexPath: string[]) => boolean;
        open: (index: string, indexPath: string[]) => boolean;
        select: (index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure>) => boolean;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        mode: import('vue').PropType<import('../ele-menus/types').MenuMode>;
        items: {
            type: import('vue').PropType<MenuItem[]>;
            required: boolean;
        };
        theme: import('vue').PropType<import('../ele-menus/types').MenuTheme>;
        popupTheme: {
            type: import('vue').PropType<import('../ele-menus/types').PopupMenuTheme>;
            default: string;
        };
        colorful: BooleanConstructor;
        popupColorful: {
            type: import('vue').PropType<import('../ele-menus/types').PopupColorful>;
            default: string;
        };
        firstPopperClass: StringConstructor;
        tooltipDisabled: BooleanConstructor;
        ellipsisProps: import('vue').PropType<import('../ele-menus/types').EllipsisProps>;
        textEllipsisTooltip: import('vue').PropType<import('../ele-menus/types').TextEllipsisTooltip>;
        defaultActive: {
            readonly type: import('vue').PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        defaultOpeneds: {
            readonly type: import('vue').PropType<string[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => [];
        };
        uniqueOpened: BooleanConstructor;
        router: BooleanConstructor;
        menuTrigger: {
            readonly type: import('vue').PropType<"click" | "hover">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "hover";
        };
        collapse: BooleanConstructor;
        backgroundColor: StringConstructor;
        textColor: StringConstructor;
        activeTextColor: StringConstructor;
        closeOnClickOutside: BooleanConstructor;
        collapseTransition: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        ellipsis: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        popperOffset: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 6;
        };
        ellipsisIcon: {
            readonly type: import('vue').PropType<string | import('vue').Component>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => any;
        };
        popperEffect: {
            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "dark";
        };
        popperClass: StringConstructor;
        showTimeout: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 300;
        };
        hideTimeout: {
            readonly type: import('vue').PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 300;
        };
        persistent: {
            readonly type: import('vue').PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
    }>> & Readonly<{
        onClose?: ((index: string, indexPath: string[]) => any) | undefined;
        onSelect?: ((index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure> | undefined) => any) | undefined;
        onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
        onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
        onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
        onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
        onParentMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
        onParentMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
    }>, {
        persistent: boolean;
        showTimeout: number;
        hideTimeout: number;
        defaultActive: string;
        defaultOpeneds: string[];
        uniqueOpened: boolean;
        router: boolean;
        menuTrigger: "click" | "hover";
        collapse: boolean;
        closeOnClickOutside: boolean;
        collapseTransition: boolean;
        ellipsis: boolean;
        popperOffset: number;
        ellipsisIcon: string | import('vue').Component;
        popperEffect: import('element-plus').PopperEffect;
        popupTheme: import('../ele-menus/types').PopupMenuTheme;
        colorful: boolean;
        popupColorful: import('../ele-menus/types').PopupColorful;
        tooltipDisabled: boolean;
    }, {}, {
        ElMenu: ({
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly mode: {
                    readonly type: import('vue').PropType<"horizontal" | "vertical">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "vertical";
                };
                readonly defaultActive: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly defaultOpeneds: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => [];
                };
                readonly uniqueOpened: BooleanConstructor;
                readonly router: BooleanConstructor;
                readonly menuTrigger: {
                    readonly type: import('vue').PropType<"click" | "hover">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                readonly collapse: BooleanConstructor;
                readonly backgroundColor: StringConstructor;
                readonly textColor: StringConstructor;
                readonly activeTextColor: StringConstructor;
                readonly closeOnClickOutside: BooleanConstructor;
                readonly collapseTransition: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly ellipsis: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly popperOffset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 6;
                };
                readonly ellipsisIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => any;
                };
                readonly popperEffect: {
                    readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "dark";
                };
                readonly popperClass: StringConstructor;
                readonly showTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 300;
                };
                readonly hideTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 300;
                };
                readonly persistent: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
            }>> & {
                onSelect?: ((index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure> | undefined) => any) | undefined;
                onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
                onClose?: ((index: string, indexPath: string[]) => any) | undefined;
            }, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                close: (index: string, indexPath: string[]) => boolean;
                open: (index: string, indexPath: string[]) => boolean;
                select: (index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure>) => boolean;
            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly ellipsis: boolean;
                readonly collapse: boolean;
                readonly mode: "horizontal" | "vertical";
                readonly persistent: boolean;
                readonly showTimeout: number;
                readonly hideTimeout: number;
                readonly defaultActive: string;
                readonly defaultOpeneds: string[];
                readonly menuTrigger: "click" | "hover";
                readonly collapseTransition: boolean;
                readonly popperOffset: number;
                readonly ellipsisIcon: string | import('vue').Component;
                readonly popperEffect: import('element-plus').PopperEffect;
                readonly uniqueOpened: boolean;
                readonly router: boolean;
                readonly closeOnClickOutside: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly mode: {
                    readonly type: import('vue').PropType<"horizontal" | "vertical">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "vertical";
                };
                readonly defaultActive: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly defaultOpeneds: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => [];
                };
                readonly uniqueOpened: BooleanConstructor;
                readonly router: BooleanConstructor;
                readonly menuTrigger: {
                    readonly type: import('vue').PropType<"click" | "hover">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                readonly collapse: BooleanConstructor;
                readonly backgroundColor: StringConstructor;
                readonly textColor: StringConstructor;
                readonly activeTextColor: StringConstructor;
                readonly closeOnClickOutside: BooleanConstructor;
                readonly collapseTransition: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly ellipsis: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly popperOffset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 6;
                };
                readonly ellipsisIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => any;
                };
                readonly popperEffect: {
                    readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "dark";
                };
                readonly popperClass: StringConstructor;
                readonly showTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 300;
                };
                readonly hideTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 300;
                };
                readonly persistent: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
            }>> & {
                onSelect?: ((index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure> | undefined) => any) | undefined;
                onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
                onClose?: ((index: string, indexPath: string[]) => any) | undefined;
            }, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, {
                readonly ellipsis: boolean;
                readonly collapse: boolean;
                readonly mode: "horizontal" | "vertical";
                readonly persistent: boolean;
                readonly showTimeout: number;
                readonly hideTimeout: number;
                readonly defaultActive: string;
                readonly defaultOpeneds: string[];
                readonly menuTrigger: "click" | "hover";
                readonly collapseTransition: boolean;
                readonly popperOffset: number;
                readonly ellipsisIcon: string | import('vue').Component;
                readonly popperEffect: import('element-plus').PopperEffect;
                readonly uniqueOpened: boolean;
                readonly router: boolean;
                readonly closeOnClickOutside: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly mode: {
                readonly type: import('vue').PropType<"horizontal" | "vertical">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "vertical";
            };
            readonly defaultActive: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly defaultOpeneds: {
                readonly type: import('vue').PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => [];
            };
            readonly uniqueOpened: BooleanConstructor;
            readonly router: BooleanConstructor;
            readonly menuTrigger: {
                readonly type: import('vue').PropType<"click" | "hover">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "hover";
            };
            readonly collapse: BooleanConstructor;
            readonly backgroundColor: StringConstructor;
            readonly textColor: StringConstructor;
            readonly activeTextColor: StringConstructor;
            readonly closeOnClickOutside: BooleanConstructor;
            readonly collapseTransition: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly ellipsis: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly popperOffset: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 6;
            };
            readonly ellipsisIcon: {
                readonly type: import('vue').PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => any;
            };
            readonly popperEffect: {
                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "dark";
            };
            readonly popperClass: StringConstructor;
            readonly showTimeout: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 300;
            };
            readonly hideTimeout: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 300;
            };
            readonly persistent: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
        }>> & {
            onSelect?: ((index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure> | undefined) => any) | undefined;
            onOpen?: ((index: string, indexPath: string[]) => any) | undefined;
            onClose?: ((index: string, indexPath: string[]) => any) | undefined;
        }, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
            [key: string]: any;
        }>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            close: (index: string, indexPath: string[]) => boolean;
            open: (index: string, indexPath: string[]) => boolean;
            select: (index: string, indexPath: string[], item: import('element-plus').MenuItemClicked, routerResult?: Promise<void | import('vue-router').NavigationFailure>) => boolean;
        }, string, {
            readonly ellipsis: boolean;
            readonly collapse: boolean;
            readonly mode: "horizontal" | "vertical";
            readonly persistent: boolean;
            readonly showTimeout: number;
            readonly hideTimeout: number;
            readonly defaultActive: string;
            readonly defaultOpeneds: string[];
            readonly menuTrigger: "click" | "hover";
            readonly collapseTransition: boolean;
            readonly popperOffset: number;
            readonly ellipsisIcon: string | import('vue').Component;
            readonly popperEffect: import('element-plus').PopperEffect;
            readonly uniqueOpened: boolean;
            readonly router: boolean;
            readonly closeOnClickOutside: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin) & {
            MenuItem: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly index: {
                        readonly type: import('vue').PropType<string | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    readonly route: {
                        readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }>> & {
                    onClick?: ((item: import('element-plus').MenuItemRegistered) => any) | undefined;
                }, {
                    parentMenu: import('vue').ComputedRef<import('vue').ComponentInternalInstance>;
                    rootMenu: import('element-plus').MenuProvider;
                    active: import('vue').ComputedRef<boolean>;
                    nsMenu: {
                        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;
                    };
                    nsMenuItem: {
                        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;
                    };
                    handleClick: () => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    click: (item: import('element-plus').MenuItemRegistered) => void;
                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly disabled: boolean;
                    readonly index: string | null;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly index: {
                        readonly type: import('vue').PropType<string | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    readonly route: {
                        readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }>> & {
                    onClick?: ((item: import('element-plus').MenuItemRegistered) => any) | undefined;
                }, {
                    parentMenu: import('vue').ComputedRef<import('vue').ComponentInternalInstance>;
                    rootMenu: import('element-plus').MenuProvider;
                    active: import('vue').ComputedRef<boolean>;
                    nsMenu: {
                        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;
                    };
                    nsMenuItem: {
                        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;
                    };
                    handleClick: () => void;
                }, {}, {}, {}, {
                    readonly disabled: boolean;
                    readonly index: string | null;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly index: {
                    readonly type: import('vue').PropType<string | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                readonly route: {
                    readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
            }>> & {
                onClick?: ((item: import('element-plus').MenuItemRegistered) => any) | undefined;
            }, {
                parentMenu: import('vue').ComputedRef<import('vue').ComponentInternalInstance>;
                rootMenu: import('element-plus').MenuProvider;
                active: import('vue').ComputedRef<boolean>;
                nsMenu: {
                    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;
                };
                nsMenuItem: {
                    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;
                };
                handleClick: () => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                click: (item: import('element-plus').MenuItemRegistered) => void;
            }, string, {
                readonly disabled: boolean;
                readonly index: string | null;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    title?(_: {}): any;
                    title?(_: {}): any;
                    default?(_: {}): any;
                    default?(_: {}): any;
                };
            });
            MenuItemGroup: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly title: StringConstructor;
                }>>, {}, 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 title: StringConstructor;
                }>>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly title: StringConstructor;
            }>>, {}, 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: {
                    title?(_: {}): any;
                    default?(_: {}): any;
                };
            });
            SubMenu: import('vue').DefineComponent<{
                readonly index: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly showTimeout: NumberConstructor;
                readonly hideTimeout: NumberConstructor;
                readonly popperClass: StringConstructor;
                readonly disabled: BooleanConstructor;
                readonly teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly popperOffset: NumberConstructor;
                readonly expandCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly expandOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
                readonly index: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly showTimeout: NumberConstructor;
                readonly hideTimeout: NumberConstructor;
                readonly popperClass: StringConstructor;
                readonly disabled: BooleanConstructor;
                readonly teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly popperOffset: NumberConstructor;
                readonly expandCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly expandOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {
                readonly disabled: boolean;
                readonly teleported: boolean;
            }>;
        };
        ElSubMenu: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly index: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly showTimeout: NumberConstructor;
                readonly hideTimeout: NumberConstructor;
                readonly popperClass: StringConstructor;
                readonly disabled: BooleanConstructor;
                readonly teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly popperOffset: NumberConstructor;
                readonly expandCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly expandOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly disabled: boolean;
                readonly teleported: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly index: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly showTimeout: NumberConstructor;
                readonly hideTimeout: NumberConstructor;
                readonly popperClass: StringConstructor;
                readonly disabled: BooleanConstructor;
                readonly teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly popperOffset: NumberConstructor;
                readonly expandCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly expandOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, {
                readonly disabled: boolean;
                readonly teleported: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly index: {
                readonly type: import('vue').PropType<string>;
                readonly required: true;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly showTimeout: NumberConstructor;
            readonly hideTimeout: NumberConstructor;
            readonly popperClass: StringConstructor;
            readonly disabled: BooleanConstructor;
            readonly teleported: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            readonly popperOffset: NumberConstructor;
            readonly expandCloseIcon: {
                readonly type: import('vue').PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly expandOpenIcon: {
                readonly type: import('vue').PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly collapseCloseIcon: {
                readonly type: import('vue').PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly collapseOpenIcon: {
                readonly type: import('vue').PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
            [key: string]: any;
        }>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
            readonly disabled: boolean;
            readonly teleported: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, 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: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, 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;
        EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            bodyStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
            bg: StringConstructor;
            arrowBg: StringConstructor;
            width: (StringConstructor | NumberConstructor)[];
            isPopover: BooleanConstructor;
            showAfter: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            hideAfter: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 200;
            };
            autoClose: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            effect: {
                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "dark";
            };
            ariaLabel: StringConstructor;
            placement: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "bottom";
            };
            teleported: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            appendTo: {
                readonly type: import('vue').PropType<string | HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            disabled: BooleanConstructor;
            offset: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 12;
            };
            persistent: BooleanConstructor;
            zIndex: NumberConstructor;
            visible: {
                readonly type: import('vue').PropType<boolean | null>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: null;
            };
            trigger: {
                readonly type: import('vue').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: import('vue').PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => string[];
            };
            popperOptions: {
                readonly type: import('vue').PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            transition: StringConstructor;
            content: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            enterable: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            showArrow: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: boolean;
            };
            arrowOffset: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 5;
            };
            virtualRef: {
                readonly type: import('vue').PropType<import('element-plus').Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            virtualTriggering: BooleanConstructor;
            rawContent: BooleanConstructor;
            gpuAcceleration: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            className: StringConstructor;
            popperClass: StringConstructor;
            popperStyle: import('vue').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: import('vue').PropType<import('../ele-app/types').StyleValue>;
            bg: StringConstructor;
            arrowBg: StringConstructor;
            width: (StringConstructor | NumberConstructor)[];
            isPopover: BooleanConstructor;
            showAfter: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            hideAfter: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 200;
            };
            autoClose: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            effect: {
                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "dark";
            };
            ariaLabel: StringConstructor;
            placement: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "bottom";
            };
            teleported: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            appendTo: {
                readonly type: import('vue').PropType<string | HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            disabled: BooleanConstructor;
            offset: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 12;
            };
            persistent: BooleanConstructor;
            zIndex: NumberConstructor;
            visible: {
                readonly type: import('vue').PropType<boolean | null>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: null;
            };
            trigger: {
                readonly type: import('vue').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: import('vue').PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => string[];
            };
            popperOptions: {
                readonly type: import('vue').PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            transition: StringConstructor;
            content: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            enterable: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            showArrow: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: boolean;
            };
            arrowOffset: {
                readonly type: import('vue').PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 5;
            };
            virtualRef: {
                readonly type: import('vue').PropType<import('element-plus').Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            virtualTriggering: BooleanConstructor;
            rawContent: BooleanConstructor;
            gpuAcceleration: {
                readonly type: import('vue').PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            className: StringConstructor;
            popperClass: StringConstructor;
            popperStyle: import('vue').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: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: boolean;
                    };
                    arrowOffset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 5;
                    };
                    disabled: BooleanConstructor;
                    trigger: {
                        readonly type: import('vue').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: import('vue').PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    virtualRef: {
                        readonly type: import('vue').PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    onMouseenter: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onMouseleave: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onClick: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onKeydown: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onFocus: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onBlur: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onContextmenu: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    id: StringConstructor;
                    open: BooleanConstructor;
                    ariaLabel: StringConstructor;
                    appendTo: {
                        readonly type: import('vue').PropType<string | HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    content: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    rawContent: BooleanConstructor;
                    persistent: BooleanConstructor;
                    visible: {
                        readonly type: import('vue').PropType<boolean | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    transition: StringConstructor;
                    teleported: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    style: {
                        readonly type: import('vue').PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    className: {
                        readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "dark";
                    };
                    enterable: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    pure: BooleanConstructor;
                    focusOnShow: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    trapping: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    popperClass: {
                        readonly type: import('vue').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: import('vue').PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    referenceEl: {
                        readonly type: import('vue').PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    triggerTargetEl: {
                        readonly type: import('vue').PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    stopPopperMouseEvent: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    zIndex: NumberConstructor;
                    boundariesPadding: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    fallbackPlacements: {
                        readonly type: import('vue').PropType<Placement[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    gpuAcceleration: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    offset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 12;
                    };
                    placement: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    popperOptions: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    strategy: {
                        readonly type: import('vue').PropType<"fixed" | "absolute">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "absolute";
                    };
                    showAfter: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    hideAfter: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 200;
                    };
                    autoClose: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    "onUpdate:visible": {
                        readonly type: import('vue').PropType<(val: boolean) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    role: {
                        readonly type: import('vue').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: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: boolean;
                    };
                    arrowOffset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 5;
                    };
                    disabled: BooleanConstructor;
                    trigger: {
                        readonly type: import('vue').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: import('vue').PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    virtualRef: {
                        readonly type: import('vue').PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    onMouseenter: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onMouseleave: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onClick: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onKeydown: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onFocus: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onBlur: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onContextmenu: {
                        readonly type: import('vue').PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    id: StringConstructor;
                    open: BooleanConstructor;
                    ariaLabel: StringConstructor;
                    appendTo: {
                        readonly type: import('vue').PropType<string | HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    content: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    rawContent: BooleanConstructor;
                    persistent: BooleanConstructor;
                    visible: {
                        readonly type: import('vue').PropType<boolean | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    transition: StringConstructor;
                    teleported: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    style: {
                        readonly type: import('vue').PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    className: {
                        readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "dark";
                    };
                    enterable: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    pure: BooleanConstructor;
                    focusOnShow: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    trapping: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    popperClass: {
                        readonly type: import('vue').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: import('vue').PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    referenceEl: {
                        readonly type: import('vue').PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    triggerTargetEl: {
                        readonly type: import('vue').PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    stopPopperMouseEvent: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    zIndex: NumberConstructor;
                    boundariesPadding: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    fallbackPlacements: {
                        readonly type: import('vue').PropType<Placement[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    gpuAcceleration: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    offset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 12;
                    };
                    placement: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    popperOptions: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    strategy: {
                        readonly type: import('vue').PropType<"fixed" | "absolute">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "absolute";
                    };
                    showAfter: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    hideAfter: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 200;
                    };
                    autoClose: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    "onUpdate:visible": {
                        readonly type: import('vue').PropType<(val: boolean) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    role: {
                        readonly type: import('vue').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: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: boolean;
                };
                arrowOffset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 5;
                };
                disabled: BooleanConstructor;
                trigger: {
                    readonly type: import('vue').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: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                virtualRef: {
                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                onMouseenter: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onMouseleave: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onClick: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onKeydown: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onFocus: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onBlur: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                onContextmenu: {
                    readonly type: import('vue').PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                id: StringConstructor;
                open: BooleanConstructor;
                ariaLabel: StringConstructor;
                appendTo: {
                    readonly type: import('vue').PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                content: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                rawContent: BooleanConstructor;
                persistent: BooleanConstructor;
                visible: {
                    readonly type: import('vue').PropType<boolean | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                transition: StringConstructor;
                teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                style: {
                    readonly type: import('vue').PropType<import('vue').StyleValue>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                className: {
                    readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "dark";
                };
                enterable: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                pure: BooleanConstructor;
                focusOnShow: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: false;
                };
                trapping: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: false;
                };
                popperClass: {
                    readonly type: import('vue').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: import('vue').PropType<import('vue').StyleValue>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                referenceEl: {
                    readonly type: import('vue').PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                triggerTargetEl: {
                    readonly type: import('vue').PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                stopPopperMouseEvent: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                zIndex: NumberConstructor;
                boundariesPadding: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                fallbackPlacements: {
                    readonly type: import('vue').PropType<Placement[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                gpuAcceleration: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                offset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 12;
                };
                placement: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                popperOptions: {
                    readonly type: import('vue').PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                strategy: {
                    readonly type: import('vue').PropType<"fixed" | "absolute">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "absolute";
                };
                showAfter: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                hideAfter: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 200;
                };
                autoClose: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                "onUpdate:visible": {
                    readonly type: import('vue').PropType<(val: boolean) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                role: {
                    readonly type: import('vue').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>;
        MenuItems: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            items: import('vue').PropType<MenuItem[]>;
            first: BooleanConstructor;
            tipDisabled: BooleanConstructor;
            parentIsGroup: BooleanConstructor;
            theme: import('vue').PropType<import('../ele-menus/types').MenuTheme>;
            popTheme: import('vue').PropType<import('../ele-menus/types').PopupMenuTheme>;
            colorful: BooleanConstructor;
            popupColorful: import('vue').PropType<import('../ele-menus/types').PopupColorful>;
            firstPopClass: StringConstructor;
            webkit: BooleanConstructor;
        }>, {
            pick: typeof import('../utils/core').pick;
            ArrowDown: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            ArrowRight: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            getPopperClass: typeof import('../ele-menus/util').getPopperClass;
            handleMenuItemClick: () => void;
            handleItemClick: import('../ele-menus/types').MenuItemEvent;
            handleItemMouseenter: import('../ele-menus/types').MenuItemEvent;
            handleItemMouseleave: import('../ele-menus/types').MenuItemEvent;
            handleParentMouseenter: import('../ele-menus/types').MenuItemEvent;
            handleParentMouseleave: import('../ele-menus/types').MenuItemEvent;
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            itemClick: (_item: MenuItem, _e: MouseEvent) => true;
            itemMouseenter: (_item: MenuItem, _e: MouseEvent) => true;
            itemMouseleave: (_item: MenuItem, _e: MouseEvent) => true;
            parentMouseenter: (_item: MenuItem, _e: MouseEvent) => true;
            parentMouseleave: (_item: MenuItem, _e: MouseEvent) => true;
        }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            items: import('vue').PropType<MenuItem[]>;
            first: BooleanConstructor;
            tipDisabled: BooleanConstructor;
            parentIsGroup: BooleanConstructor;
            theme: import('vue').PropType<import('../ele-menus/types').MenuTheme>;
            popTheme: import('vue').PropType<import('../ele-menus/types').PopupMenuTheme>;
            colorful: BooleanConstructor;
            popupColorful: import('vue').PropType<import('../ele-menus/types').PopupColorful>;
            firstPopClass: StringConstructor;
            webkit: BooleanConstructor;
        }>> & Readonly<{
            onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
            onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
            onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
            onParentMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
            onParentMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
        }>, {
            first: boolean;
            colorful: boolean;
            tipDisabled: boolean;
            parentIsGroup: boolean;
            webkit: boolean;
        }, {}, {
            ElMenuItem: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly index: {
                        readonly type: import('vue').PropType<string | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    readonly route: {
                        readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }>> & {
                    onClick?: ((item: import('element-plus').MenuItemRegistered) => any) | undefined;
                }, {
                    parentMenu: import('vue').ComputedRef<import('vue').ComponentInternalInstance>;
                    rootMenu: import('element-plus').MenuProvider;
                    active: import('vue').ComputedRef<boolean>;
                    nsMenu: {
                        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;
                    };
                    nsMenuItem: {
                        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;
                    };
                    handleClick: () => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    click: (item: import('element-plus').MenuItemRegistered) => void;
                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly disabled: boolean;
                    readonly index: string | null;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly index: {
                        readonly type: import('vue').PropType<string | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    readonly route: {
                        readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }>> & {
                    onClick?: ((item: import('element-plus').MenuItemRegistered) => any) | undefined;
                }, {
                    parentMenu: import('vue').ComputedRef<import('vue').ComponentInternalInstance>;
                    rootMenu: import('element-plus').MenuProvider;
                    active: import('vue').ComputedRef<boolean>;
                    nsMenu: {
                        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;
                    };
                    nsMenuItem: {
                        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;
                    };
                    handleClick: () => void;
                }, {}, {}, {}, {
                    readonly disabled: boolean;
                    readonly index: string | null;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly index: {
                    readonly type: import('vue').PropType<string | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                readonly route: {
                    readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
            }>> & {
                onClick?: ((item: import('element-plus').MenuItemRegistered) => any) | undefined;
            }, {
                parentMenu: import('vue').ComputedRef<import('vue').ComponentInternalInstance>;
                rootMenu: import('element-plus').MenuProvider;
                active: import('vue').ComputedRef<boolean>;
                nsMenu: {
                    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;
                };
                nsMenuItem: {
                    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;
                };
                handleClick: () => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                click: (item: import('element-plus').MenuItemRegistered) => void;
            }, string, {
                readonly disabled: boolean;
                readonly index: string | null;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    title?(_: {}): any;
                    title?(_: {}): any;
                    default?(_: {}): any;
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin;
            ElSubMenu: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly index: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: true;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly showTimeout: NumberConstructor;
                    readonly hideTimeout: NumberConstructor;
                    readonly popperClass: StringConstructor;
                    readonly disabled: BooleanConstructor;
                    readonly teleported: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly popperOffset: NumberConstructor;
                    readonly expandCloseIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly expandOpenIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly collapseCloseIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly collapseOpenIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                    [key: string]: any;
                }>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly disabled: boolean;
                    readonly teleported: boolean;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly index: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: true;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly showTimeout: NumberConstructor;
                    readonly hideTimeout: NumberConstructor;
                    readonly popperClass: StringConstructor;
                    readonly disabled: BooleanConstructor;
                    readonly teleported: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly popperOffset: NumberConstructor;
                    readonly expandCloseIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly expandOpenIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly collapseCloseIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly collapseOpenIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                    [key: string]: any;
                }>, {}, {}, {}, {
                    readonly disabled: boolean;
                    readonly teleported: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly index: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: true;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly showTimeout: NumberConstructor;
                readonly hideTimeout: NumberConstructor;
                readonly popperClass: StringConstructor;
                readonly disabled: BooleanConstructor;
                readonly teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly popperOffset: NumberConstructor;
                readonly expandCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly expandOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseCloseIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly collapseOpenIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
                [key: string]: any;
            }>, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                readonly disabled: boolean;
                readonly teleported: boolean;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
            ElMenuItemGroup: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly title: StringConstructor;
                }>>, {}, 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 title: StringConstructor;
                }>>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly title: StringConstructor;
            }>>, {}, 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: {
                    title?(_: {}): any;
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin;
            ItemTitle: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                item: {
                    type: import('vue').PropType<MenuItem>;
                    required: true;
                };
                showTitle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                showLink: BooleanConstructor;
            }>, {
                isExternalLink: typeof import('../utils/core').isExternalLink;
                handleItemClick: import('../ele-menus/types').MenuItemEvent;
                handleItemMouseenter: import('../ele-menus/types').MenuItemEvent;
                handleItemMouseleave: import('../ele-menus/types').MenuItemEvent;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                itemClick: (_item: MenuItem, _e: MouseEvent) => true;
                itemMouseenter: (_item: MenuItem, _e: MouseEvent) => true;
                itemMouseleave: (_item: MenuItem, _e: MouseEvent) => true;
            }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                item: {
                    type: import('vue').PropType<MenuItem>;
                    required: true;
                };
                showTitle: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                showLink: BooleanConstructor;
            }>> & Readonly<{
                onItemClick?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
                onItemMouseenter?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
                onItemMouseleave?: ((_item: MenuItem, _e: MouseEvent) => any) | undefined;
            }>, {
                showLink: boolean;
                showTitle: boolean;
            }, {}, {
                ElIcon: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly color: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                    }>>, {}, 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: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly color: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                    }>>, {}, {}, {}, {}, {}>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, 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;
                ElBadge: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly value: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly max: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 99;
                        };
                        readonly isDot: BooleanConstructor;
                        readonly hidden: BooleanConstructor;
                        readonly type: {
                            readonly type: import('vue').PropType<"success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "danger";
                        };
                        readonly showZero: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly color: StringConstructor;
                        readonly badgeStyle: {
                            readonly type: import('vue').PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly offset: {
                            readonly type: import('vue').PropType<[number, number]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: readonly [0, 0];
                        };
                        readonly badgeClass: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                    }>>, {
                        content: import('vue').ComputedRef<string>;
                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        readonly hidden: boolean;
                        readonly offset: [number, number];
                        readonly value: string | number;
                        readonly type: "success" | "primary" | "warning" | "info" | "danger";
                        readonly max: number;
                        readonly showZero: boolean;
                        readonly isDot: boolean;
                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        readonly value: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly max: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 99;
                        };
                        readonly isDot: BooleanConstructor;
                        readonly hidden: BooleanConstructor;
                        readonly type: {
                            readonly type: import('vue').PropType<"success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "danger";
                        };
                        readonly showZero: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly color: StringConstructor;
                        readonly badgeStyle: {
                            readonly type: import('vue').PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly offset: {
                            readonly type: import('vue').PropType<[number, number]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: readonly [0, 0];
                        };
                        readonly badgeClass: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                    }>>, {
                        content: import('vue').ComputedRef<string>;
                    }, {}, {}, {}, {
                        readonly hidden: boolean;
                        readonly offset: [number, number];
                        readonly value: string | number;
                        readonly type: "success" | "primary" | "warning" | "info" | "danger";
                        readonly max: number;
                        readonly showZero: boolean;
                        readonly isDot: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly value: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly max: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 99;
                    };
                    readonly isDot: BooleanConstructor;
                    readonly hidden: BooleanConstructor;
                    readonly type: {
                        readonly type: import('vue').PropType<"success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "danger";
                    };
                    readonly showZero: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly color: StringConstructor;
                    readonly badgeStyle: {
                        readonly type: import('vue').PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly offset: {
                        readonly type: import('vue').PropType<[number, number]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: readonly [0, 0];
                    };
                    readonly badgeClass: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {
                    content: import('vue').ComputedRef<string>;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                    readonly hidden: boolean;
                    readonly offset: [number, number];
                    readonly value: string | number;
                    readonly type: "success" | "primary" | "warning" | "info" | "danger";
                    readonly max: number;
                    readonly showZero: boolean;
                    readonly isDot: 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?(_: {
                            value: string;
                        }): any;
                    };
                }) & import('vue').Plugin;
            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleBreadcrumb: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        separator: {
            type: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbSeparator>;
            default: string;
        };
        items: {
            type: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbItem[]>;
            required: boolean;
        };
        separatorIcon: {
            readonly type: import('vue').PropType<string | import('vue').Component>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>, {
        breadcrumbRef: import('vue').Ref<import('../ele-app/el').ElBreadcrumbInstance, import('../ele-app/el').ElBreadcrumbInstance>;
        breadcrumbSeparator: import('vue').ComputedRef<string | undefined>;
        breadcrumbSeparatorIcon: import('vue').ComputedRef<(string | import('vue').Component) | undefined>;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        separator: {
            type: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbSeparator>;
            default: string;
        };
        items: {
            type: import('vue').PropType<import('../ele-breadcrumb/types').BreadcrumbItem[]>;
            required: boolean;
        };
        separatorIcon: {
            readonly type: import('vue').PropType<string | import('vue').Component>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>> & Readonly<{}>, {
        separator: import('../ele-breadcrumb/types').BreadcrumbSeparator;
    }, {}, {
        ElBreadcrumb: ({
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly separator: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "/";
                };
                readonly separatorIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    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, {
                readonly separator: string;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly separator: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "/";
                };
                readonly separatorIcon: {
                    readonly type: import('vue').PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {
                readonly separator: string;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly separator: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "/";
            };
            readonly separatorIcon: {
                readonly type: import('vue').PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
            readonly separator: 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) & {
            BreadcrumbItem: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly to: {
                        readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly replace: BooleanConstructor;
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
                    readonly replace: boolean;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly to: {
                        readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly replace: BooleanConstructor;
                }>>, {}, {}, {}, {}, {
                    readonly to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
                    readonly replace: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly to: {
                    readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly replace: BooleanConstructor;
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                readonly to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
                readonly replace: 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;
                };
            });
        };
        ElBreadcrumbItem: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly to: {
                    readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly replace: BooleanConstructor;
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
                readonly replace: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly to: {
                    readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly replace: BooleanConstructor;
            }>>, {}, {}, {}, {}, {
                readonly to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
                readonly replace: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly to: {
                readonly type: import('vue').PropType<string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly replace: BooleanConstructor;
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
            readonly to: string | import('vue-router').RouteLocationAsRelativeGeneric | import('vue-router').RouteLocationAsPathGeneric;
            readonly replace: 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: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, 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: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, 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;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleBacktop: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        target: import('vue').PropType<string | HTMLElement | null>;
        visibilityHeight: {
            type: NumberConstructor;
            default: number;
        };
        bottom: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        right: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        transitionName: {
            type: StringConstructor;
            default: string;
        };
    }>, {
        visible: import('vue').Ref<boolean, boolean>;
        handleClick: (e: MouseEvent) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
        click: (_e: MouseEvent) => boolean;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        target: import('vue').PropType<string | HTMLElement | null>;
        visibilityHeight: {
            type: NumberConstructor;
            default: number;
        };
        bottom: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        right: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        transitionName: {
            type: StringConstructor;
            default: string;
        };
    }>> & Readonly<{
        onClick?: ((_e: MouseEvent) => any) | undefined;
    }>, {
        visibilityHeight: number;
        bottom: string | number;
        right: string | number;
        transitionName: string;
    }, {}, {
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, 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: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, 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;
        ArrowUp: 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>;
    LayoutSkeleton: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        isHeaderLogo: BooleanConstructor;
    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        isHeaderLogo: BooleanConstructor;
    }>> & Readonly<{}>, {
        isHeaderLogo: boolean;
    }, {}, {
        ReceiverView: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            wrapPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>, {
            authenticated: import('vue').Ref<boolean, boolean>;
            watermark: string[];
        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            wrapPosition: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{}>, {
            wrapPosition: boolean;
        }, {}, {
            EleWatermark: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                width: NumberConstructor;
                height: NumberConstructor;
                rotate: NumberConstructor;
                zIndex: NumberConstructor;
                image: StringConstructor;
                content: import('vue').PropType<string | string[]>;
                font: import('vue').PropType<import('../ele-watermark/types').WatermarkFont>;
                gap: import('vue').PropType<import('../ele-watermark/types').WatermarkGap>;
                offset: import('vue').PropType<import('../ele-watermark/types').WatermarkOffset>;
                lineGap: {
                    type: NumberConstructor;
                    default: number;
                };
                customStyle: import('vue').PropType<Exclude<import('../ele-app/types').StyleValue, string>>;
                fixed: BooleanConstructor;
                wrapPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: BooleanConstructor;
            }>, {
                rootKey: import('vue').Ref<number, number>;
                rootRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                imgRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                imgStyle: import('vue').Ref<Partial<import('vue').CSSProperties>, Partial<import('vue').CSSProperties>>;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                width: NumberConstructor;
                height: NumberConstructor;
                rotate: NumberConstructor;
                zIndex: NumberConstructor;
                image: StringConstructor;
                content: import('vue').PropType<string | string[]>;
                font: import('vue').PropType<import('../ele-watermark/types').WatermarkFont>;
                gap: import('vue').PropType<import('../ele-watermark/types').WatermarkGap>;
                offset: import('vue').PropType<import('../ele-watermark/types').WatermarkOffset>;
                lineGap: {
                    type: NumberConstructor;
                    default: number;
                };
                customStyle: import('vue').PropType<Exclude<import('../ele-app/types').StyleValue, string>>;
                fixed: BooleanConstructor;
                wrapPosition: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                disabled: BooleanConstructor;
            }>> & Readonly<{}>, {
                fixed: boolean;
                disabled: boolean;
                lineGap: number;
                wrapPosition: boolean;
            }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    LayoutTabs: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        tabs: import('vue').PropType<TabPaneItem[]>;
        active: StringConstructor;
        fixedHome: BooleanConstructor;
        homePath: StringConstructor;
        isHome: BooleanConstructor;
        tabStyle: import('vue').PropType<import('./types').TabStyle>;
        tabContextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
        tabContextMenus: import('vue').PropType<import('../ele-tabs/types').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: import('vue').PropType<TabPaneItem[]>;
        active: StringConstructor;
        fixedHome: BooleanConstructor;
        homePath: StringConstructor;
        isHome: BooleanConstructor;
        tabStyle: import('vue').PropType<import('./types').TabStyle>;
        tabContextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
        tabContextMenus: import('vue').PropType<import('../ele-tabs/types').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: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, 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: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: import('vue').PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, 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: import('vue').PropType<import('../ele-tabs/types').TabSize>;
            type: import('vue').PropType<import('../ele-tabs/types').TabType>;
        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            size: import('vue').PropType<import('../ele-tabs/types').TabSize>;
            type: import('vue').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: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, 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: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, 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: import('vue').PropType<TabPaneItem[]>;
                required: boolean;
            };
            size: import('vue').PropType<import('../ele-tabs/types').TabSize>;
            type: import('vue').PropType<import('../ele-tabs/types').TabType>;
            center: BooleanConstructor;
            contextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
            contextMenus: import('vue').PropType<import('../ele-tabs/types').ContextMenus>;
            sortable: BooleanConstructor;
            mousewheel: BooleanConstructor;
            handleClick: BooleanConstructor;
            flexTable: BooleanConstructor;
            closable: BooleanConstructor;
            addable: BooleanConstructor;
            modelValue: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            editable: BooleanConstructor;
            tabPosition: {
                readonly type: import('vue').PropType<"bottom" | "right" | "top" | "left">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "top";
            };
            beforeLeave: {
                readonly type: import('vue').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: import('vue').PropType<TabPaneItem[]>;
                required: boolean;
            };
            size: import('vue').PropType<import('../ele-tabs/types').TabSize>;
            type: import('vue').PropType<import('../ele-tabs/types').TabType>;
            center: BooleanConstructor;
            contextMenu: import('vue').PropType<boolean | import('../ele-app/plus').EleDropdownProps>;
            contextMenus: import('vue').PropType<import('../ele-tabs/types').ContextMenus>;
            sortable: BooleanConstructor;
            mousewheel: BooleanConstructor;
            handleClick: BooleanConstructor;
            flexTable: BooleanConstructor;
            closable: BooleanConstructor;
            addable: BooleanConstructor;
            modelValue: {
                readonly type: import('vue').PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            editable: BooleanConstructor;
            tabPosition: {
                readonly type: import('vue').PropType<"bottom" | "right" | "top" | "left">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "top";
            };
            beforeLeave: {
                readonly type: import('vue').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<{
            "onUpdate:modelValue"?: ((name: import('element-plus').TabPaneName) => any) | undefined;
            onTabContextMenu?: ((_opt: TabEventOption) => 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: "bottom" | "right" | "top" | "left";
            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: import('vue').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: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly editable: BooleanConstructor;
                    readonly tabPosition: {
                        readonly type: import('vue').PropType<"bottom" | "right" | "top" | "left">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "top";
                    };
                    readonly beforeLeave: {
                        readonly type: import('vue').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: "bottom" | "right" | "top" | "left";
                    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: import('vue').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: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly editable: BooleanConstructor;
                    readonly tabPosition: {
                        readonly type: import('vue').PropType<"bottom" | "right" | "top" | "left">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "top";
                    };
                    readonly beforeLeave: {
                        readonly type: import('vue').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: "bottom" | "right" | "top" | "left";
                    readonly addable: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly type: {
                    readonly type: import('vue').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: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly editable: BooleanConstructor;
                readonly tabPosition: {
                    readonly type: import('vue').PropType<"bottom" | "right" | "top" | "left">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "top";
                };
                readonly beforeLeave: {
                    readonly type: import('vue').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: "bottom" | "right" | "top" | "left";
                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: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly name: {
                            readonly type: import('vue').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: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly name: {
                            readonly type: import('vue').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: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly name: {
                        readonly type: import('vue').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: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly name: {
                        readonly type: import('vue').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: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly name: {
                        readonly type: import('vue').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: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly name: {
                    readonly type: import('vue').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: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, 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: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, {}, {}, {}, {}>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, 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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem[]>;
                modelValue: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                menuStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
                componentType: import('vue').PropType<"pro">;
                preventContextmenu: BooleanConstructor;
                splitButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                caretButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                id: StringConstructor;
                type: {
                    readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                placement: {
                    readonly type: import('vue').PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                popperClass: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                disabled: BooleanConstructor;
                persistent: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                triggerKeys: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                popperOptions: {
                    readonly type: import('vue').PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                splitButton: BooleanConstructor;
                hideOnClick: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                loop: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                showTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                hideTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                tabindex: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                maxHeight: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                role: {
                    readonly type: import('vue').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: import('vue').PropType<Partial<import('element-plus').ButtonProps>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                size: import('vue').PropType<import('../ele-app/el').ElButtonProps["size"]>;
                ariaLabel: StringConstructor;
                appendTo: {
                    readonly type: import('vue').PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                offset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                bg: StringConstructor;
                zIndex: NumberConstructor;
                visible: {
                    readonly type: import('vue').PropType<boolean | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                trigger: {
                    readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                enterable: {
                    readonly default: true;
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                showArrow: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                arrowOffset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 5;
                };
                virtualRef: {
                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                className: StringConstructor;
                gpuAcceleration: {
                    readonly type: import('vue').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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem[]>;
                modelValue: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                menuStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
                componentType: import('vue').PropType<"pro">;
                preventContextmenu: BooleanConstructor;
                splitButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                caretButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                id: StringConstructor;
                type: {
                    readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                placement: {
                    readonly type: import('vue').PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                popperClass: {
                    readonly type: import('vue').PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                teleported: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                disabled: BooleanConstructor;
                persistent: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                triggerKeys: {
                    readonly type: import('vue').PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                popperOptions: {
                    readonly type: import('vue').PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                splitButton: BooleanConstructor;
                hideOnClick: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                loop: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                showTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                hideTimeout: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                tabindex: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                maxHeight: {
                    readonly type: import('vue').PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                role: {
                    readonly type: import('vue').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: import('vue').PropType<Partial<import('element-plus').ButtonProps>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                size: import('vue').PropType<import('../ele-app/el').ElButtonProps["size"]>;
                ariaLabel: StringConstructor;
                appendTo: {
                    readonly type: import('vue').PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                offset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                bg: StringConstructor;
                zIndex: NumberConstructor;
                visible: {
                    readonly type: import('vue').PropType<boolean | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                trigger: {
                    readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                enterable: {
                    readonly default: true;
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                showArrow: {
                    readonly type: import('vue').PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                arrowOffset: {
                    readonly type: import('vue').PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 5;
                };
                virtualRef: {
                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                className: StringConstructor;
                gpuAcceleration: {
                    readonly type: import('vue').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;
                "onUpdate:modelValue"?: ((_value: (string | number | Record<string, any>) | undefined) => any) | undefined;
                onVisibleChange?: ((_visible: boolean) => 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: import('vue').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: import('vue').PropType<string[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => string[];
                        };
                        readonly effect: {
                            readonly default: "light";
                            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            readonly __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: import('vue').PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly placement: {
                            readonly type: import('vue').PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "bottom";
                        };
                        readonly popperOptions: {
                            readonly type: import('vue').PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => {};
                        };
                        readonly id: StringConstructor;
                        readonly size: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly splitButton: BooleanConstructor;
                        readonly hideOnClick: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly loop: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly showTimeout: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 150;
                        };
                        readonly hideTimeout: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 150;
                        };
                        readonly tabindex: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        readonly maxHeight: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly popperClass: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly disabled: BooleanConstructor;
                        readonly role: {
                            readonly type: import('vue').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: import('vue').PropType<Partial<import('element-plus').ButtonProps>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly teleported: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly persistent: {
                            readonly type: import('vue').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: import('vue').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: import('vue').PropType<string[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => string[];
                        };
                        readonly effect: {
                            readonly default: "light";
                            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            readonly __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: import('vue').PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly placement: {
                            readonly type: import('vue').PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "bottom";
                        };
                        readonly popperOptions: {
                            readonly type: import('vue').PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => {};
                        };
                        readonly id: StringConstructor;
                        readonly size: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly splitButton: BooleanConstructor;
                        readonly hideOnClick: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly loop: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly showTimeout: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 150;
                        };
                        readonly hideTimeout: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 150;
                        };
                        readonly tabindex: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        readonly maxHeight: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly popperClass: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly disabled: BooleanConstructor;
                        readonly role: {
                            readonly type: import('vue').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: import('vue').PropType<Partial<import('element-plus').ButtonProps>>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly teleported: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        readonly persistent: {
                            readonly type: import('vue').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: import('vue').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: import('vue').PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    readonly effect: {
                        readonly default: "light";
                        readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        readonly __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: import('vue').PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly placement: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    readonly popperOptions: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    readonly id: StringConstructor;
                    readonly size: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly splitButton: BooleanConstructor;
                    readonly hideOnClick: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly loop: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly showTimeout: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    readonly hideTimeout: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    readonly tabindex: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    readonly maxHeight: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly popperClass: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly disabled: BooleanConstructor;
                    readonly role: {
                        readonly type: import('vue').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: import('vue').PropType<Partial<import('element-plus').ButtonProps>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly teleported: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    readonly persistent: {
                        readonly type: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly disabled: BooleanConstructor;
                        readonly type: {
                            readonly type: import('vue').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: import('vue').PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly nativeType: {
                            readonly type: import('vue').PropType<"reset" | "submit" | "button">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "button";
                        };
                        readonly loading: BooleanConstructor;
                        readonly loadingIcon: {
                            readonly type: import('vue').PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => any;
                        };
                        readonly plain: {
                            readonly type: import('vue').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: import('vue').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: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly tag: {
                            readonly type: import('vue').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: "reset" | "submit" | "button";
                        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: import('vue').PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly disabled: BooleanConstructor;
                        readonly type: {
                            readonly type: import('vue').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: import('vue').PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly nativeType: {
                            readonly type: import('vue').PropType<"reset" | "submit" | "button">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "button";
                        };
                        readonly loading: BooleanConstructor;
                        readonly loadingIcon: {
                            readonly type: import('vue').PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => any;
                        };
                        readonly plain: {
                            readonly type: import('vue').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: import('vue').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: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly tag: {
                            readonly type: import('vue').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: "reset" | "submit" | "button";
                        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: import('vue').PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: {
                        readonly type: import('vue').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: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: {
                        readonly type: import('vue').PropType<"reset" | "submit" | "button">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: {
                        readonly type: import('vue').PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => any;
                    };
                    readonly plain: {
                        readonly type: import('vue').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: import('vue').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: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly tag: {
                        readonly type: import('vue').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: "reset" | "submit" | "button";
                    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: import('vue').PropType<"" | "small" | "default" | "large">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly type: {
                                readonly type: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly type: {
                                readonly type: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: import('vue').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: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly color: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                    }>>, {}, 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: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly color: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                    }>>, {}, {}, {}, {}, {}>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly color: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                }>>, {}, 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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem | null>;
                    transition: {
                        type: StringConstructor;
                        default: string;
                    };
                    items: import('vue').PropType<import('../ele-dropdown/types').DropdownItem[]>;
                    modelValue: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                    menuStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                    iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
                    componentType: import('vue').PropType<"pro">;
                    preventContextmenu: BooleanConstructor;
                    splitButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                    caretButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                    id: StringConstructor;
                    type: {
                        readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        readonly __epPropKey: true;
                    };
                    placement: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    popperClass: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    teleported: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    disabled: BooleanConstructor;
                    persistent: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    triggerKeys: {
                        readonly type: import('vue').PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    popperOptions: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    splitButton: BooleanConstructor;
                    hideOnClick: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    loop: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    showTimeout: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    hideTimeout: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    tabindex: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    maxHeight: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    role: {
                        readonly type: import('vue').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: import('vue').PropType<Partial<import('element-plus').ButtonProps>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    size: import('vue').PropType<import('../ele-app/el').ElButtonProps["size"]>;
                    ariaLabel: StringConstructor;
                    appendTo: {
                        readonly type: import('vue').PropType<string | HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    offset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    bg: StringConstructor;
                    zIndex: NumberConstructor;
                    visible: {
                        readonly type: import('vue').PropType<boolean | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    trigger: {
                        readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "hover";
                    };
                    popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                    enterable: {
                        readonly default: true;
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        readonly __epPropKey: true;
                    };
                    showArrow: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    arrowOffset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 5;
                    };
                    virtualRef: {
                        readonly type: import('vue').PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    className: StringConstructor;
                    gpuAcceleration: {
                        readonly type: import('vue').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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem | null>;
                    transition: {
                        type: StringConstructor;
                        default: string;
                    };
                    items: import('vue').PropType<import('../ele-dropdown/types').DropdownItem[]>;
                    modelValue: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                    menuStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                    iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
                    componentType: import('vue').PropType<"pro">;
                    preventContextmenu: BooleanConstructor;
                    splitButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                    caretButtonProps: import('vue').PropType<import('../ele-app/el').ElButtonProps>;
                    id: StringConstructor;
                    type: {
                        readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        readonly __epPropKey: true;
                    };
                    placement: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    popperClass: {
                        readonly type: import('vue').PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    teleported: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    disabled: BooleanConstructor;
                    persistent: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    triggerKeys: {
                        readonly type: import('vue').PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    popperOptions: {
                        readonly type: import('vue').PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    splitButton: BooleanConstructor;
                    hideOnClick: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    loop: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    showTimeout: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    hideTimeout: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 150;
                    };
                    tabindex: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    maxHeight: {
                        readonly type: import('vue').PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    role: {
                        readonly type: import('vue').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: import('vue').PropType<Partial<import('element-plus').ButtonProps>>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    size: import('vue').PropType<import('../ele-app/el').ElButtonProps["size"]>;
                    ariaLabel: StringConstructor;
                    appendTo: {
                        readonly type: import('vue').PropType<string | HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    offset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    bg: StringConstructor;
                    zIndex: NumberConstructor;
                    visible: {
                        readonly type: import('vue').PropType<boolean | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    trigger: {
                        readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "hover";
                    };
                    popperStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                    enterable: {
                        readonly default: true;
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        readonly __epPropKey: true;
                    };
                    showArrow: {
                        readonly type: import('vue').PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    arrowOffset: {
                        readonly type: import('vue').PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 5;
                    };
                    virtualRef: {
                        readonly type: import('vue').PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    className: StringConstructor;
                    gpuAcceleration: {
                        readonly type: import('vue').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;
                    "onUpdate:modelValue"?: ((_value: (string | number | Record<string, any>) | undefined) => any) | undefined;
                    onVisibleChange?: ((_visible: boolean) => 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: import('vue').PropType<"" | "small" | "default" | "large">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly disabled: BooleanConstructor;
                            readonly type: {
                                readonly type: import('vue').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: import('vue').PropType<string | import('vue').Component>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly nativeType: {
                                readonly type: import('vue').PropType<"reset" | "submit" | "button">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "button";
                            };
                            readonly loading: BooleanConstructor;
                            readonly loadingIcon: {
                                readonly type: import('vue').PropType<string | import('vue').Component>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => any;
                            };
                            readonly plain: {
                                readonly type: import('vue').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: import('vue').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: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: undefined;
                            };
                            readonly tag: {
                                readonly type: import('vue').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: "reset" | "submit" | "button";
                            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: import('vue').PropType<"" | "small" | "default" | "large">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly disabled: BooleanConstructor;
                            readonly type: {
                                readonly type: import('vue').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: import('vue').PropType<string | import('vue').Component>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly nativeType: {
                                readonly type: import('vue').PropType<"reset" | "submit" | "button">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "button";
                            };
                            readonly loading: BooleanConstructor;
                            readonly loadingIcon: {
                                readonly type: import('vue').PropType<string | import('vue').Component>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => any;
                            };
                            readonly plain: {
                                readonly type: import('vue').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: import('vue').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: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: undefined;
                            };
                            readonly tag: {
                                readonly type: import('vue').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: "reset" | "submit" | "button";
                            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: import('vue').PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly disabled: BooleanConstructor;
                        readonly type: {
                            readonly type: import('vue').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: import('vue').PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly nativeType: {
                            readonly type: import('vue').PropType<"reset" | "submit" | "button">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "button";
                        };
                        readonly loading: BooleanConstructor;
                        readonly loadingIcon: {
                            readonly type: import('vue').PropType<string | import('vue').Component>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => any;
                        };
                        readonly plain: {
                            readonly type: import('vue').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: import('vue').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: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly tag: {
                            readonly type: import('vue').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: "reset" | "submit" | "button";
                        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: import('vue').PropType<"" | "small" | "default" | "large">;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                readonly type: {
                                    readonly type: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                readonly type: {
                                    readonly type: import('vue').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: import('vue').PropType<"" | "small" | "default" | "large">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly type: {
                                readonly type: import('vue').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: import('vue').PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly height: {
                                readonly type: import('vue').PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly maxHeight: {
                                readonly type: import('vue').PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly native: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            readonly wrapStyle: {
                                readonly type: import('vue').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly wrapClass: {
                                readonly type: import('vue').PropType<string | unknown[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly viewClass: {
                                readonly type: import('vue').PropType<string | unknown[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly viewStyle: {
                                readonly type: import('vue').PropType<string | Record<string, any> | unknown[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly noresize: BooleanConstructor;
                            readonly tag: {
                                readonly type: import('vue').PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "div";
                            };
                            readonly always: BooleanConstructor;
                            readonly minSize: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 20;
                            };
                            readonly tabindex: {
                                readonly type: import('vue').PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: undefined;
                            };
                            readonly id: StringConstructor;
                            readonly role: StringConstructor;
                        }>> & {
                            onScroll?: ((args_0: {
                                scrollTop: number;
                                scrollLeft: number;
                            }) => any) | undefined;
                            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                        }, {
                            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                            update: () => void;
                            scrollTo: {
                                (xCord: number, yCord?: number): void;
                                (options: ScrollToOptions): void;
                            };
                            setScrollTop: (value: number) => void;
                            setScrollLeft: (value: number) => void;
                            handleScroll: () => void;
                        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                            scroll: (args_0: {
                                scrollTop: number;
                                scrollLeft: number;
                            }) => void;
                            "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
                        }, 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: import('vue').PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly height: {
                                readonly type: import('vue').PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly maxHeight: {
                                readonly type: import('vue').PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly native: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            readonly wrapStyle: {
                                readonly type: import('vue').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly wrapClass: {
                                readonly type: import('vue').PropType<string | unknown[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly viewClass: {
                                readonly type: import('vue').PropType<string | unknown[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly viewStyle: {
                                readonly type: import('vue').PropType<string | Record<string, any> | unknown[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            readonly noresize: BooleanConstructor;
                            readonly tag: {
                                readonly type: import('vue').PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "div";
                            };
                            readonly always: BooleanConstructor;
                            readonly minSize: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 20;
                            };
                            readonly tabindex: {
                                readonly type: import('vue').PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: undefined;
                            };
                            readonly id: StringConstructor;
                            readonly role: StringConstructor;
                        }>> & {
                            onScroll?: ((args_0: {
                                scrollTop: number;
                                scrollLeft: number;
                            }) => any) | undefined;
                            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                        }, {
                            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                            update: () => void;
                            scrollTo: {
                                (xCord: number, yCord?: number): void;
                                (options: ScrollToOptions): void;
                            };
                            setScrollTop: (value: number) => void;
                            setScrollLeft: (value: number) => void;
                            handleScroll: () => void;
                        }, {}, {}, {}, {
                            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: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly height: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly maxHeight: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly native: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        readonly wrapStyle: {
                            readonly type: import('vue').PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly wrapClass: {
                            readonly type: import('vue').PropType<string | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly viewClass: {
                            readonly type: import('vue').PropType<string | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly viewStyle: {
                            readonly type: import('vue').PropType<string | Record<string, any> | unknown[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        readonly noresize: BooleanConstructor;
                        readonly tag: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "div";
                        };
                        readonly always: BooleanConstructor;
                        readonly minSize: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 20;
                        };
                        readonly tabindex: {
                            readonly type: import('vue').PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        readonly id: StringConstructor;
                        readonly role: StringConstructor;
                    }>> & {
                        onScroll?: ((args_0: {
                            scrollTop: number;
                            scrollLeft: number;
                        }) => any) | undefined;
                        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                    }, {
                        wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                        update: () => void;
                        scrollTo: {
                            (xCord: number, yCord?: number): void;
                            (options: ScrollToOptions): void;
                        };
                        setScrollTop: (value: number) => void;
                        setScrollLeft: (value: number) => void;
                        handleScroll: () => void;
                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        scroll: (args_0: {
                            scrollTop: number;
                            scrollLeft: number;
                        }) => void;
                        "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
                    }, string, {
                        readonly height: string | number;
                        readonly maxHeight: string | number;
                        readonly always: boolean;
                        readonly tabindex: string | number;
                        readonly minSize: number;
                        readonly 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: import('vue').PropType<import('../ele-app/types').StyleValue>;
                        bg: StringConstructor;
                        arrowBg: StringConstructor;
                        width: (StringConstructor | NumberConstructor)[];
                        isPopover: BooleanConstructor;
                        showAfter: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        hideAfter: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 200;
                        };
                        autoClose: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        effect: {
                            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "dark";
                        };
                        ariaLabel: StringConstructor;
                        placement: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "bottom";
                        };
                        teleported: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        appendTo: {
                            readonly type: import('vue').PropType<string | HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        disabled: BooleanConstructor;
                        offset: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 12;
                        };
                        persistent: BooleanConstructor;
                        zIndex: NumberConstructor;
                        visible: {
                            readonly type: import('vue').PropType<boolean | null>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: null;
                        };
                        trigger: {
                            readonly type: import('vue').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: import('vue').PropType<string[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => string[];
                        };
                        popperOptions: {
                            readonly type: import('vue').PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => {};
                        };
                        transition: StringConstructor;
                        content: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        enterable: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        showArrow: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: boolean;
                        };
                        arrowOffset: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 5;
                        };
                        virtualRef: {
                            readonly type: import('vue').PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        rawContent: BooleanConstructor;
                        gpuAcceleration: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        className: StringConstructor;
                        popperClass: StringConstructor;
                        popperStyle: import('vue').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: import('vue').PropType<import('../ele-app/types').StyleValue>;
                        bg: StringConstructor;
                        arrowBg: StringConstructor;
                        width: (StringConstructor | NumberConstructor)[];
                        isPopover: BooleanConstructor;
                        showAfter: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        hideAfter: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 200;
                        };
                        autoClose: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        effect: {
                            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "dark";
                        };
                        ariaLabel: StringConstructor;
                        placement: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "bottom";
                        };
                        teleported: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        appendTo: {
                            readonly type: import('vue').PropType<string | HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        disabled: BooleanConstructor;
                        offset: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 12;
                        };
                        persistent: BooleanConstructor;
                        zIndex: NumberConstructor;
                        visible: {
                            readonly type: import('vue').PropType<boolean | null>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: null;
                        };
                        trigger: {
                            readonly type: import('vue').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: import('vue').PropType<string[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => string[];
                        };
                        popperOptions: {
                            readonly type: import('vue').PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => {};
                        };
                        transition: StringConstructor;
                        content: {
                            readonly type: import('vue').PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        enterable: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        showArrow: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: boolean;
                        };
                        arrowOffset: {
                            readonly type: import('vue').PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 5;
                        };
                        virtualRef: {
                            readonly type: import('vue').PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        rawContent: BooleanConstructor;
                        gpuAcceleration: {
                            readonly type: import('vue').PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        className: StringConstructor;
                        popperClass: StringConstructor;
                        popperStyle: import('vue').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: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: boolean;
                                };
                                arrowOffset: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 5;
                                };
                                disabled: BooleanConstructor;
                                trigger: {
                                    readonly type: import('vue').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: import('vue').PropType<string[]>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: () => string[];
                                };
                                virtualRef: {
                                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                virtualTriggering: BooleanConstructor;
                                onMouseenter: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onMouseleave: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onClick: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onKeydown: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onFocus: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onBlur: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onContextmenu: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                id: StringConstructor;
                                open: BooleanConstructor;
                                ariaLabel: StringConstructor;
                                appendTo: {
                                    readonly type: import('vue').PropType<string | HTMLElement>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                content: {
                                    readonly type: import('vue').PropType<string>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "";
                                };
                                rawContent: BooleanConstructor;
                                persistent: BooleanConstructor;
                                visible: {
                                    readonly type: import('vue').PropType<boolean | null>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: null;
                                };
                                transition: StringConstructor;
                                teleported: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                style: {
                                    readonly type: import('vue').PropType<import('vue').StyleValue>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                className: {
                                    readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "dark";
                                };
                                enterable: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                pure: BooleanConstructor;
                                focusOnShow: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: false;
                                };
                                trapping: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: false;
                                };
                                popperClass: {
                                    readonly type: import('vue').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: import('vue').PropType<import('vue').StyleValue>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                referenceEl: {
                                    readonly type: import('vue').PropType<HTMLElement>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                triggerTargetEl: {
                                    readonly type: import('vue').PropType<HTMLElement>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                stopPopperMouseEvent: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                zIndex: NumberConstructor;
                                boundariesPadding: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 0;
                                };
                                fallbackPlacements: {
                                    readonly type: import('vue').PropType<Placement[]>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: undefined;
                                };
                                gpuAcceleration: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                offset: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 12;
                                };
                                placement: {
                                    readonly type: import('vue').PropType<string>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "bottom";
                                };
                                popperOptions: {
                                    readonly type: import('vue').PropType<any>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: () => {};
                                };
                                strategy: {
                                    readonly type: import('vue').PropType<"fixed" | "absolute">;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "absolute";
                                };
                                showAfter: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 0;
                                };
                                hideAfter: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 200;
                                };
                                autoClose: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 0;
                                };
                                "onUpdate:visible": {
                                    readonly type: import('vue').PropType<(val: boolean) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                role: {
                                    readonly type: import('vue').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: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: boolean;
                                };
                                arrowOffset: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 5;
                                };
                                disabled: BooleanConstructor;
                                trigger: {
                                    readonly type: import('vue').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: import('vue').PropType<string[]>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: () => string[];
                                };
                                virtualRef: {
                                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                virtualTriggering: BooleanConstructor;
                                onMouseenter: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onMouseleave: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onClick: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onKeydown: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onFocus: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onBlur: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                onContextmenu: {
                                    readonly type: import('vue').PropType<(e: Event) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                id: StringConstructor;
                                open: BooleanConstructor;
                                ariaLabel: StringConstructor;
                                appendTo: {
                                    readonly type: import('vue').PropType<string | HTMLElement>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                content: {
                                    readonly type: import('vue').PropType<string>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "";
                                };
                                rawContent: BooleanConstructor;
                                persistent: BooleanConstructor;
                                visible: {
                                    readonly type: import('vue').PropType<boolean | null>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: null;
                                };
                                transition: StringConstructor;
                                teleported: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                style: {
                                    readonly type: import('vue').PropType<import('vue').StyleValue>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                className: {
                                    readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "dark";
                                };
                                enterable: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                pure: BooleanConstructor;
                                focusOnShow: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: false;
                                };
                                trapping: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: false;
                                };
                                popperClass: {
                                    readonly type: import('vue').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: import('vue').PropType<import('vue').StyleValue>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                referenceEl: {
                                    readonly type: import('vue').PropType<HTMLElement>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                triggerTargetEl: {
                                    readonly type: import('vue').PropType<HTMLElement>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                stopPopperMouseEvent: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                zIndex: NumberConstructor;
                                boundariesPadding: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 0;
                                };
                                fallbackPlacements: {
                                    readonly type: import('vue').PropType<Placement[]>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: undefined;
                                };
                                gpuAcceleration: {
                                    readonly type: import('vue').PropType<boolean>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: true;
                                };
                                offset: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 12;
                                };
                                placement: {
                                    readonly type: import('vue').PropType<string>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "bottom";
                                };
                                popperOptions: {
                                    readonly type: import('vue').PropType<any>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: () => {};
                                };
                                strategy: {
                                    readonly type: import('vue').PropType<"fixed" | "absolute">;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: "absolute";
                                };
                                showAfter: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 0;
                                };
                                hideAfter: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 200;
                                };
                                autoClose: {
                                    readonly type: import('vue').PropType<number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                } & {
                                    readonly default: 0;
                                };
                                "onUpdate:visible": {
                                    readonly type: import('vue').PropType<(val: boolean) => void>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                role: {
                                    readonly type: import('vue').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: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: boolean;
                            };
                            arrowOffset: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 5;
                            };
                            disabled: BooleanConstructor;
                            trigger: {
                                readonly type: import('vue').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: import('vue').PropType<string[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => string[];
                            };
                            virtualRef: {
                                readonly type: import('vue').PropType<import('element-plus').Measurable>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            virtualTriggering: BooleanConstructor;
                            onMouseenter: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onMouseleave: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onClick: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onKeydown: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onFocus: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onBlur: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            onContextmenu: {
                                readonly type: import('vue').PropType<(e: Event) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            id: StringConstructor;
                            open: BooleanConstructor;
                            ariaLabel: StringConstructor;
                            appendTo: {
                                readonly type: import('vue').PropType<string | HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            content: {
                                readonly type: import('vue').PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "";
                            };
                            rawContent: BooleanConstructor;
                            persistent: BooleanConstructor;
                            visible: {
                                readonly type: import('vue').PropType<boolean | null>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: null;
                            };
                            transition: StringConstructor;
                            teleported: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            style: {
                                readonly type: import('vue').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            className: {
                                readonly type: import('vue').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: import('vue').PropType<import('element-plus').PopperEffect>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "dark";
                            };
                            enterable: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            pure: BooleanConstructor;
                            focusOnShow: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            trapping: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: false;
                            };
                            popperClass: {
                                readonly type: import('vue').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: import('vue').PropType<import('vue').StyleValue>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            referenceEl: {
                                readonly type: import('vue').PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            triggerTargetEl: {
                                readonly type: import('vue').PropType<HTMLElement>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            stopPopperMouseEvent: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            zIndex: NumberConstructor;
                            boundariesPadding: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            fallbackPlacements: {
                                readonly type: import('vue').PropType<Placement[]>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: undefined;
                            };
                            gpuAcceleration: {
                                readonly type: import('vue').PropType<boolean>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: true;
                            };
                            offset: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 12;
                            };
                            placement: {
                                readonly type: import('vue').PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "bottom";
                            };
                            popperOptions: {
                                readonly type: import('vue').PropType<any>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: () => {};
                            };
                            strategy: {
                                readonly type: import('vue').PropType<"fixed" | "absolute">;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: "absolute";
                            };
                            showAfter: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            hideAfter: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 200;
                            };
                            autoClose: {
                                readonly type: import('vue').PropType<number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            } & {
                                readonly default: 0;
                            };
                            "onUpdate:visible": {
                                readonly type: import('vue').PropType<(val: boolean) => void>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            role: {
                                readonly type: import('vue').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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem[]>;
                            required: true;
                        };
                        selected: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                        menuStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                        iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
                        size: import('vue').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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem[]>;
                            required: true;
                        };
                        selected: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                        menuStyle: import('vue').PropType<import('../ele-app/types').StyleValue>;
                        iconProps: import('vue').PropType<import('../ele-app/el').ElIconProps>;
                        size: import('vue').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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem>;
                                required: true;
                            };
                            selected: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                            iconProps: import('vue').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: import('vue').PropType<import('../ele-dropdown/types').DropdownItem>;
                                required: true;
                            };
                            selected: import('vue').PropType<import('../ele-dropdown/types').DropdownItem["command"]>;
                            iconProps: import('vue').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: import('vue').PropType<string | number>;
                                        readonly required: false;
                                        readonly validator: ((val: unknown) => boolean) | undefined;
                                        __epPropKey: true;
                                    };
                                    readonly color: {
                                        readonly type: import('vue').PropType<string>;
                                        readonly required: false;
                                        readonly validator: ((val: unknown) => boolean) | undefined;
                                        __epPropKey: true;
                                    };
                                }>>, {}, 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: import('vue').PropType<string | number>;
                                        readonly required: false;
                                        readonly validator: ((val: unknown) => boolean) | undefined;
                                        __epPropKey: true;
                                    };
                                    readonly color: {
                                        readonly type: import('vue').PropType<string>;
                                        readonly required: false;
                                        readonly validator: ((val: unknown) => boolean) | undefined;
                                        __epPropKey: true;
                                    };
                                }>>, {}, {}, {}, {}, {}>;
                                __isFragment?: never;
                                __isTeleport?: never;
                                __isSuspense?: never;
                            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                                readonly size: {
                                    readonly type: import('vue').PropType<string | number>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                                readonly color: {
                                    readonly type: import('vue').PropType<string>;
                                    readonly required: false;
                                    readonly validator: ((val: unknown) => boolean) | undefined;
                                    __epPropKey: true;
                                };
                            }>>, {}, 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>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;