import { PropType } from 'vue';
import { EleDropdownProps, EleDropdownInstance } from '../../ele-app/plus';
import { DropdownItem } from '../../ele-dropdown/types';

declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
    /** 右键菜单 */
    items: PropType<DropdownItem[]>;
    /** 右键菜单属性 */
    dropdownProps: PropType<EleDropdownProps>;
    /** 是否点击后自动关闭菜单 */
    autoClose: {
        type: BooleanConstructor;
        default: boolean;
    };
}>, {
    dropdownRef: import('vue').Ref<EleDropdownInstance, EleDropdownInstance>;
    handleCommand: (command: string) => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
    menuClick: (_command: string) => true;
}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
    /** 右键菜单 */
    items: PropType<DropdownItem[]>;
    /** 右键菜单属性 */
    dropdownProps: PropType<EleDropdownProps>;
    /** 是否点击后自动关闭菜单 */
    autoClose: {
        type: BooleanConstructor;
        default: boolean;
    };
}>> & Readonly<{
    onMenuClick?: ((_command: string) => any) | undefined;
}>, {
    autoClose: boolean;
}, {}, {
    ElIcon: {
        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, {}, {}, {}, {}>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
        readonly size: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        readonly color: {
            readonly type: PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
        $slots: {
            default?(_: {}): any;
        };
    }) & import('vue').Plugin;
    ArrowDown: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleDropdown: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        transition: {
            type: StringConstructor;
            default: string;
        };
        items: PropType<DropdownItem[]>;
        modelValue: PropType<DropdownItem["command"]>;
        menuStyle: PropType<import('../../ele-app/types').StyleValue>;
        iconProps: PropType<import('../../ele-app/el').ElIconProps>;
        componentType: PropType<"pro">;
        preventContextmenu: BooleanConstructor;
        splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
        caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
        id: StringConstructor;
        type: {
            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        effect: {
            readonly default: "light";
            readonly type: PropType<import('element-plus').PopperEffect>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            readonly __epPropKey: true;
        };
        placement: {
            readonly type: PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "bottom";
        };
        popperClass: {
            readonly type: PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        teleported: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        disabled: BooleanConstructor;
        persistent: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        triggerKeys: {
            readonly type: PropType<string[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => string[];
        };
        popperOptions: {
            readonly type: PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => {};
        };
        splitButton: BooleanConstructor;
        hideOnClick: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        loop: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        showTimeout: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 150;
        };
        hideTimeout: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 150;
        };
        tabindex: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        maxHeight: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        role: {
            readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "menu";
        };
        buttonProps: {
            readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
        ariaLabel: StringConstructor;
        appendTo: {
            readonly type: PropType<string | HTMLElement>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        offset: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: undefined;
        };
        bg: StringConstructor;
        zIndex: NumberConstructor;
        visible: {
            readonly type: PropType<boolean | null>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: null;
        };
        trigger: {
            readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "hover";
        };
        popperStyle: PropType<import('../../ele-app/types').StyleValue>;
        enterable: {
            readonly default: true;
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            readonly __epPropKey: true;
        };
        showArrow: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        arrowOffset: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 5;
        };
        virtualRef: {
            readonly type: PropType<import('element-plus').Measurable>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        virtualTriggering: BooleanConstructor;
        className: StringConstructor;
        gpuAcceleration: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        arrowBg: StringConstructor;
    }>, {
        omit: typeof import('../../utils/core').omit;
        dropdownRef: import('vue').Ref<import('../../ele-dropdown/props').DropdownInstance, import('../../ele-dropdown/props').DropdownInstance>;
        dropdownProps: import('vue').ComputedRef<import('../../ele-app/el').ElDropdownProps>;
        selected: import('vue').ComputedRef<DropdownItem | null | undefined>;
        handleMenuClick: (command: 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: DropdownItem["command"]) => boolean;
        visibleChange: (_visible: boolean) => boolean;
        'update:modelValue': (_value: DropdownItem["command"]) => boolean;
        change: (_active: DropdownItem["command"]) => boolean;
        "update:visible": (value: boolean) => boolean;
        "before-enter": () => boolean;
        "before-leave": () => boolean;
        "after-enter": () => boolean;
        "after-leave": () => boolean;
    }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        transition: {
            type: StringConstructor;
            default: string;
        };
        items: PropType<DropdownItem[]>;
        modelValue: PropType<DropdownItem["command"]>;
        menuStyle: PropType<import('../../ele-app/types').StyleValue>;
        iconProps: PropType<import('../../ele-app/el').ElIconProps>;
        componentType: PropType<"pro">;
        preventContextmenu: BooleanConstructor;
        splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
        caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
        id: StringConstructor;
        type: {
            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        effect: {
            readonly default: "light";
            readonly type: PropType<import('element-plus').PopperEffect>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            readonly __epPropKey: true;
        };
        placement: {
            readonly type: PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "bottom";
        };
        popperClass: {
            readonly type: PropType<string>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        teleported: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        disabled: BooleanConstructor;
        persistent: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        triggerKeys: {
            readonly type: PropType<string[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => string[];
        };
        popperOptions: {
            readonly type: PropType<any>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: () => {};
        };
        splitButton: BooleanConstructor;
        hideOnClick: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        loop: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        showTimeout: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 150;
        };
        hideTimeout: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 150;
        };
        tabindex: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 0;
        };
        maxHeight: {
            readonly type: PropType<string | number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "";
        };
        role: {
            readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "menu";
        };
        buttonProps: {
            readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
        ariaLabel: StringConstructor;
        appendTo: {
            readonly type: PropType<string | HTMLElement>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        offset: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: undefined;
        };
        bg: StringConstructor;
        zIndex: NumberConstructor;
        visible: {
            readonly type: PropType<boolean | null>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: null;
        };
        trigger: {
            readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: "hover";
        };
        popperStyle: PropType<import('../../ele-app/types').StyleValue>;
        enterable: {
            readonly default: true;
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            readonly __epPropKey: true;
        };
        showArrow: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        arrowOffset: {
            readonly type: PropType<number>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: 5;
        };
        virtualRef: {
            readonly type: PropType<import('element-plus').Measurable>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        };
        virtualTriggering: BooleanConstructor;
        className: StringConstructor;
        gpuAcceleration: {
            readonly type: PropType<boolean>;
            readonly required: false;
            readonly validator: ((val: unknown) => boolean) | undefined;
            __epPropKey: true;
        } & {
            readonly default: true;
        };
        arrowBg: StringConstructor;
    }>> & Readonly<{
        onChange?: ((_active: (string | number | Record<string, any>) | undefined) => any) | undefined;
        onClick?: ((_e: MouseEvent) => any) | undefined;
        onCommand?: ((_command: (string | number | Record<string, any>) | undefined) => any) | undefined;
        "onUpdate:visible"?: ((value: boolean) => any) | undefined;
        onVisibleChange?: ((_visible: boolean) => any) | undefined;
        "onUpdate:modelValue"?: ((_value: (string | number | Record<string, any>) | undefined) => any) | undefined;
        "onBefore-enter"?: (() => any) | undefined;
        "onBefore-leave"?: (() => any) | undefined;
        "onAfter-enter"?: (() => any) | undefined;
        "onAfter-leave"?: (() => any) | undefined;
    }>, {
        effect: import('element-plus').PopperEffect;
        placement: any;
        popperClass: string;
        teleported: boolean;
        disabled: boolean;
        offset: number;
        persistent: boolean;
        visible: boolean | null;
        trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
        triggerKeys: string[];
        popperOptions: any;
        splitButton: boolean;
        hideOnClick: boolean;
        loop: boolean;
        showTimeout: number;
        hideTimeout: number;
        tabindex: string | number;
        maxHeight: string | number;
        role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
        transition: string;
        enterable: boolean;
        showArrow: boolean;
        arrowOffset: number;
        virtualTriggering: boolean;
        gpuAcceleration: boolean;
        preventContextmenu: boolean;
    }, {}, {
        ElDropdown: ({
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly trigger: {
                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                readonly triggerKeys: {
                    readonly type: PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                readonly effect: {
                    readonly default: "light";
                    readonly type: PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly placement: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                readonly popperOptions: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly id: StringConstructor;
                readonly size: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly splitButton: BooleanConstructor;
                readonly hideOnClick: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly loop: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly showTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                readonly hideTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                readonly tabindex: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly maxHeight: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly popperClass: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly disabled: BooleanConstructor;
                readonly role: {
                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "menu";
                };
                readonly buttonProps: {
                    readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly teleported: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly persistent: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
            }>> & {
                onClick?: ((...args: any[]) => any) | undefined;
                "onVisible-change"?: ((...args: any[]) => any) | undefined;
                onCommand?: ((...args: any[]) => any) | undefined;
            }, {
                t: import('element-plus').Translator;
                ns: {
                    namespace: import('vue').ComputedRef<string>;
                    b: (blockSuffix?: string) => string;
                    e: (element?: string) => string;
                    m: (modifier?: string) => string;
                    be: (blockSuffix?: string, element?: string) => string;
                    em: (element?: string, modifier?: string) => string;
                    bm: (blockSuffix?: string, modifier?: string) => string;
                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                    is: {
                        (name: string, state: boolean | undefined): string;
                        (name: string): string;
                    };
                    cssVar: (object: Record<string, string>) => Record<string, string>;
                    cssVarName: (name: string) => string;
                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                    cssVarBlockName: (name: string) => string;
                };
                scrollbar: import('vue').Ref<null>;
                wrapStyle: import('vue').ComputedRef<import('vue').CSSProperties>;
                dropdownTriggerKls: import('vue').ComputedRef<string[]>;
                dropdownSize: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                triggerId: import('vue').ComputedRef<string>;
                currentTabId: import('vue').Ref<string | null>;
                handleCurrentTabIdChange: (id: string) => void;
                handlerMainButtonClick: (event: MouseEvent) => void;
                handleEntryFocus: (e: Event) => void;
                handleClose: () => void;
                handleOpen: () => void;
                handleBeforeShowTooltip: () => void;
                handleShowTooltip: (event?: Event) => void;
                handleBeforeHideTooltip: () => void;
                onFocusAfterTrapped: (e: Event) => void;
                popperRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
                contentRef: import('vue').Ref<HTMLElement | undefined>;
                triggeringElementRef: import('vue').Ref<any>;
                referenceElementRef: import('vue').Ref<any>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "visible-change" | "command")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly disabled: boolean;
                readonly maxHeight: string | number;
                readonly size: string;
                readonly placement: any;
                readonly effect: import('element-plus').PopperEffect;
                readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                readonly tabindex: string | number;
                readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                readonly loop: boolean;
                readonly popperOptions: Partial<Options>;
                readonly popperClass: string;
                readonly triggerKeys: string[];
                readonly teleported: boolean;
                readonly persistent: boolean;
                readonly hideOnClick: boolean;
                readonly showTimeout: number;
                readonly hideTimeout: number;
                readonly splitButton: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly trigger: {
                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                readonly triggerKeys: {
                    readonly type: PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                readonly effect: {
                    readonly default: "light";
                    readonly type: PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    readonly __epPropKey: true;
                };
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly placement: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                readonly popperOptions: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly id: StringConstructor;
                readonly size: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly splitButton: BooleanConstructor;
                readonly hideOnClick: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly loop: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly showTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                readonly hideTimeout: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 150;
                };
                readonly tabindex: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                readonly maxHeight: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly popperClass: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly disabled: BooleanConstructor;
                readonly role: {
                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "menu";
                };
                readonly buttonProps: {
                    readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly teleported: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                readonly persistent: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
            }>> & {
                onClick?: ((...args: any[]) => any) | undefined;
                "onVisible-change"?: ((...args: any[]) => any) | undefined;
                onCommand?: ((...args: any[]) => any) | undefined;
            }, {
                t: import('element-plus').Translator;
                ns: {
                    namespace: import('vue').ComputedRef<string>;
                    b: (blockSuffix?: string) => string;
                    e: (element?: string) => string;
                    m: (modifier?: string) => string;
                    be: (blockSuffix?: string, element?: string) => string;
                    em: (element?: string, modifier?: string) => string;
                    bm: (blockSuffix?: string, modifier?: string) => string;
                    bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                    is: {
                        (name: string, state: boolean | undefined): string;
                        (name: string): string;
                    };
                    cssVar: (object: Record<string, string>) => Record<string, string>;
                    cssVarName: (name: string) => string;
                    cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                    cssVarBlockName: (name: string) => string;
                };
                scrollbar: import('vue').Ref<null>;
                wrapStyle: import('vue').ComputedRef<import('vue').CSSProperties>;
                dropdownTriggerKls: import('vue').ComputedRef<string[]>;
                dropdownSize: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                triggerId: import('vue').ComputedRef<string>;
                currentTabId: import('vue').Ref<string | null>;
                handleCurrentTabIdChange: (id: string) => void;
                handlerMainButtonClick: (event: MouseEvent) => void;
                handleEntryFocus: (e: Event) => void;
                handleClose: () => void;
                handleOpen: () => void;
                handleBeforeShowTooltip: () => void;
                handleShowTooltip: (event?: Event) => void;
                handleBeforeHideTooltip: () => void;
                onFocusAfterTrapped: (e: Event) => void;
                popperRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
                contentRef: import('vue').Ref<HTMLElement | undefined>;
                triggeringElementRef: import('vue').Ref<any>;
                referenceElementRef: import('vue').Ref<any>;
            }, {}, {}, {}, {
                readonly disabled: boolean;
                readonly maxHeight: string | number;
                readonly size: string;
                readonly placement: any;
                readonly effect: import('element-plus').PopperEffect;
                readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                readonly tabindex: string | number;
                readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                readonly loop: boolean;
                readonly popperOptions: Partial<Options>;
                readonly popperClass: string;
                readonly triggerKeys: string[];
                readonly teleported: boolean;
                readonly persistent: boolean;
                readonly hideOnClick: boolean;
                readonly showTimeout: number;
                readonly hideTimeout: number;
                readonly splitButton: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly trigger: {
                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "hover";
            };
            readonly triggerKeys: {
                readonly type: PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => string[];
            };
            readonly effect: {
                readonly default: "light";
                readonly type: PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            readonly type: {
                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly placement: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "bottom";
            };
            readonly popperOptions: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            readonly id: StringConstructor;
            readonly size: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly splitButton: BooleanConstructor;
            readonly hideOnClick: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly loop: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly showTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            readonly hideTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            readonly tabindex: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            readonly maxHeight: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly popperClass: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly disabled: BooleanConstructor;
            readonly role: {
                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "menu";
            };
            readonly buttonProps: {
                readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly teleported: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            readonly persistent: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
        }>> & {
            onClick?: ((...args: any[]) => any) | undefined;
            "onVisible-change"?: ((...args: any[]) => any) | undefined;
            onCommand?: ((...args: any[]) => any) | undefined;
        }, {
            t: import('element-plus').Translator;
            ns: {
                namespace: import('vue').ComputedRef<string>;
                b: (blockSuffix?: string) => string;
                e: (element?: string) => string;
                m: (modifier?: string) => string;
                be: (blockSuffix?: string, element?: string) => string;
                em: (element?: string, modifier?: string) => string;
                bm: (blockSuffix?: string, modifier?: string) => string;
                bem: (blockSuffix?: string, element?: string, modifier?: string) => string;
                is: {
                    (name: string, state: boolean | undefined): string;
                    (name: string): string;
                };
                cssVar: (object: Record<string, string>) => Record<string, string>;
                cssVarName: (name: string) => string;
                cssVarBlock: (object: Record<string, string>) => Record<string, string>;
                cssVarBlockName: (name: string) => string;
            };
            scrollbar: import('vue').Ref<null>;
            wrapStyle: import('vue').ComputedRef<import('vue').CSSProperties>;
            dropdownTriggerKls: import('vue').ComputedRef<string[]>;
            dropdownSize: import('vue').ComputedRef<"" | "small" | "default" | "large">;
            triggerId: import('vue').ComputedRef<string>;
            currentTabId: import('vue').Ref<string | null>;
            handleCurrentTabIdChange: (id: string) => void;
            handlerMainButtonClick: (event: MouseEvent) => void;
            handleEntryFocus: (e: Event) => void;
            handleClose: () => void;
            handleOpen: () => void;
            handleBeforeShowTooltip: () => void;
            handleShowTooltip: (event?: Event) => void;
            handleBeforeHideTooltip: () => void;
            onFocusAfterTrapped: (e: Event) => void;
            popperRef: import('vue').Ref<import('element-plus').TooltipInstance | undefined>;
            contentRef: import('vue').Ref<HTMLElement | undefined>;
            triggeringElementRef: import('vue').Ref<any>;
            referenceElementRef: import('vue').Ref<any>;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "visible-change" | "command")[], "click" | "visible-change" | "command", {
            readonly disabled: boolean;
            readonly maxHeight: string | number;
            readonly size: string;
            readonly placement: any;
            readonly effect: import('element-plus').PopperEffect;
            readonly trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
            readonly tabindex: string | number;
            readonly role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
            readonly loop: boolean;
            readonly popperOptions: Partial<Options>;
            readonly popperClass: string;
            readonly triggerKeys: string[];
            readonly teleported: boolean;
            readonly persistent: boolean;
            readonly hideOnClick: boolean;
            readonly showTimeout: number;
            readonly hideTimeout: number;
            readonly splitButton: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin) & {
            DropdownItem: import('vue').DefineComponent<{
                readonly command: {
                    readonly type: PropType<string | number | Record<string, any>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly disabled: BooleanConstructor;
                readonly divided: BooleanConstructor;
                readonly textValue: StringConstructor;
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }, {
                handleClick: (event: PointerEvent) => void;
                handlePointerMove: (event: PointerEvent) => void;
                handlePointerLeave: (event: PointerEvent) => void;
                textContent: import('vue').ComputedRef<string>;
                propsAndAttrs: import('vue').ComputedRef<{
                    disabled: boolean;
                    icon: (string | import('vue').Component) | undefined;
                    onClick: ((...args: any[]) => any) | undefined;
                    onPointermove: ((...args: any[]) => any) | undefined;
                    onPointerleave: ((...args: any[]) => any) | undefined;
                    command: string | number | Record<string, any>;
                    divided: boolean;
                    textValue: string | undefined;
                }>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
                readonly command: {
                    readonly type: PropType<string | number | Record<string, any>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly disabled: BooleanConstructor;
                readonly divided: BooleanConstructor;
                readonly textValue: StringConstructor;
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onClick?: ((...args: any[]) => any) | undefined;
                onPointermove?: ((...args: any[]) => any) | undefined;
                onPointerleave?: ((...args: any[]) => any) | undefined;
            }, {
                readonly disabled: boolean;
                readonly command: string | number | Record<string, any>;
                readonly divided: boolean;
            }>;
            DropdownMenu: import('vue').DefineComponent<{
                onKeydown: {
                    readonly type: PropType<(e: KeyboardEvent) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }, {
                size: import('vue').ComputedRef<string> | undefined;
                rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
                tabIndex: import('vue').Ref<number>;
                dropdownKls: import('vue').ComputedRef<string[]>;
                role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                triggerId: import('vue').ComputedRef<string>;
                dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
                handleKeydown: (e: KeyboardEvent) => void;
                onBlur: (e: Event) => void;
                onFocus: (e: FocusEvent) => void;
                onMousedown: (e: Event) => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, Readonly<import('vue').ExtractPropTypes<{
                onKeydown: {
                    readonly type: PropType<(e: KeyboardEvent) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}>;
        };
        ElDropdownMenu: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                onKeydown: {
                    readonly type: PropType<(e: KeyboardEvent) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {
                size: import('vue').ComputedRef<string> | undefined;
                rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
                tabIndex: import('vue').Ref<number>;
                dropdownKls: import('vue').ComputedRef<string[]>;
                role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                triggerId: import('vue').ComputedRef<string>;
                dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
                handleKeydown: (e: KeyboardEvent) => void;
                onBlur: (e: Event) => void;
                onFocus: (e: FocusEvent) => void;
                onMousedown: (e: Event) => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                onKeydown: {
                    readonly type: PropType<(e: KeyboardEvent) => void>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {
                size: import('vue').ComputedRef<string> | undefined;
                rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
                tabIndex: import('vue').Ref<number>;
                dropdownKls: import('vue').ComputedRef<string[]>;
                role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                triggerId: import('vue').ComputedRef<string>;
                dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
                handleKeydown: (e: KeyboardEvent) => void;
                onBlur: (e: Event) => void;
                onFocus: (e: FocusEvent) => void;
                onMousedown: (e: Event) => void;
            }, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            onKeydown: {
                readonly type: PropType<(e: KeyboardEvent) => void>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {
            size: import('vue').ComputedRef<string> | undefined;
            rovingFocusGroupRootStyle: import('vue').Ref<import('vue').StyleValue>;
            tabIndex: import('vue').Ref<number>;
            dropdownKls: import('vue').ComputedRef<string[]>;
            role: import('vue').ComputedRef<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
            triggerId: import('vue').ComputedRef<string>;
            dropdownListWrapperRef: (el: Element | import('vue').ComponentPublicInstance | null) => void;
            handleKeydown: (e: KeyboardEvent) => void;
            onBlur: (e: Event) => void;
            onFocus: (e: FocusEvent) => void;
            onMousedown: (e: Event) => void;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
        ElDropdownItem: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly command: {
                    readonly type: PropType<string | number | Record<string, any>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly disabled: BooleanConstructor;
                readonly divided: BooleanConstructor;
                readonly textValue: StringConstructor;
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onClick?: ((...args: any[]) => any) | undefined;
                onPointermove?: ((...args: any[]) => any) | undefined;
                onPointerleave?: ((...args: any[]) => any) | undefined;
            }, {
                handleClick: (event: PointerEvent) => void;
                handlePointerMove: (event: PointerEvent) => void;
                handlePointerLeave: (event: PointerEvent) => void;
                textContent: import('vue').ComputedRef<string>;
                propsAndAttrs: import('vue').ComputedRef<{
                    disabled: boolean;
                    icon: (string | import('vue').Component) | undefined;
                    onClick: ((...args: any[]) => any) | undefined;
                    onPointermove: ((...args: any[]) => any) | undefined;
                    onPointerleave: ((...args: any[]) => any) | undefined;
                    command: string | number | Record<string, any>;
                    divided: boolean;
                    textValue: string | undefined;
                }>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly disabled: boolean;
                readonly command: string | number | Record<string, any>;
                readonly divided: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly command: {
                    readonly type: PropType<string | number | Record<string, any>>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                readonly disabled: BooleanConstructor;
                readonly divided: BooleanConstructor;
                readonly textValue: StringConstructor;
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>> & {
                onClick?: ((...args: any[]) => any) | undefined;
                onPointermove?: ((...args: any[]) => any) | undefined;
                onPointerleave?: ((...args: any[]) => any) | undefined;
            }, {
                handleClick: (event: PointerEvent) => void;
                handlePointerMove: (event: PointerEvent) => void;
                handlePointerLeave: (event: PointerEvent) => void;
                textContent: import('vue').ComputedRef<string>;
                propsAndAttrs: import('vue').ComputedRef<{
                    disabled: boolean;
                    icon: (string | import('vue').Component) | undefined;
                    onClick: ((...args: any[]) => any) | undefined;
                    onPointermove: ((...args: any[]) => any) | undefined;
                    onPointerleave: ((...args: any[]) => any) | undefined;
                    command: string | number | Record<string, any>;
                    divided: boolean;
                    textValue: string | undefined;
                }>;
            }, {}, {}, {}, {
                readonly disabled: boolean;
                readonly command: string | number | Record<string, any>;
                readonly divided: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly command: {
                readonly type: PropType<string | number | Record<string, any>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            readonly disabled: BooleanConstructor;
            readonly divided: BooleanConstructor;
            readonly textValue: StringConstructor;
            readonly icon: {
                readonly type: PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>> & {
            onClick?: ((...args: any[]) => any) | undefined;
            onPointermove?: ((...args: any[]) => any) | undefined;
            onPointerleave?: ((...args: any[]) => any) | undefined;
        }, {
            handleClick: (event: PointerEvent) => void;
            handlePointerMove: (event: PointerEvent) => void;
            handlePointerLeave: (event: PointerEvent) => void;
            textContent: import('vue').ComputedRef<string>;
            propsAndAttrs: import('vue').ComputedRef<{
                disabled: boolean;
                icon: (string | import('vue').Component) | undefined;
                onClick: ((...args: any[]) => any) | undefined;
                onPointermove: ((...args: any[]) => any) | undefined;
                onPointerleave: ((...args: any[]) => any) | undefined;
                command: string | number | Record<string, any>;
                divided: boolean;
                textValue: string | undefined;
            }>;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("click" | "pointerleave" | "pointermove")[], "click" | "pointerleave" | "pointermove", {
            readonly disabled: boolean;
            readonly command: string | number | Record<string, any>;
            readonly divided: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & import('vue').Plugin;
        ElButtonGroup: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
            }>>, {}, {}, {}, {}, {
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<"" | "small" | "default" | "large">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly type: {
                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
            readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
        ElButton: ({
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly nativeType: {
                    readonly type: PropType<"button" | "reset" | "submit">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
                readonly loading: BooleanConstructor;
                readonly loadingIcon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => any;
                };
                readonly plain: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly text: BooleanConstructor;
                readonly link: BooleanConstructor;
                readonly bg: BooleanConstructor;
                readonly autofocus: BooleanConstructor;
                readonly round: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly circle: BooleanConstructor;
                readonly color: StringConstructor;
                readonly dark: BooleanConstructor;
                readonly autoInsertSpace: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly tag: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
            }>> & {
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }, {
                ref: import('vue').Ref<HTMLButtonElement | undefined>;
                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                type: import('vue').ComputedRef<string>;
                disabled: import('vue').ComputedRef<boolean>;
                shouldAddSpace: import('vue').ComputedRef<boolean>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                click: (evt: MouseEvent) => void;
            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                readonly link: boolean;
                readonly circle: boolean;
                readonly text: boolean;
                readonly disabled: boolean;
                readonly round: boolean;
                readonly dark: boolean;
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                readonly bg: boolean;
                readonly loading: boolean;
                readonly autofocus: boolean;
                readonly tag: string | import('vue').Component;
                readonly plain: boolean;
                readonly nativeType: "button" | "reset" | "submit";
                readonly loadingIcon: string | import('vue').Component;
                readonly autoInsertSpace: boolean;
            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly nativeType: {
                    readonly type: PropType<"button" | "reset" | "submit">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
                readonly loading: BooleanConstructor;
                readonly loadingIcon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => any;
                };
                readonly plain: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly text: BooleanConstructor;
                readonly link: BooleanConstructor;
                readonly bg: BooleanConstructor;
                readonly autofocus: BooleanConstructor;
                readonly round: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly circle: BooleanConstructor;
                readonly color: StringConstructor;
                readonly dark: BooleanConstructor;
                readonly autoInsertSpace: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly tag: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
            }>> & {
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }, {
                ref: import('vue').Ref<HTMLButtonElement | undefined>;
                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                type: import('vue').ComputedRef<string>;
                disabled: import('vue').ComputedRef<boolean>;
                shouldAddSpace: import('vue').ComputedRef<boolean>;
            }, {}, {}, {}, {
                readonly link: boolean;
                readonly circle: boolean;
                readonly text: boolean;
                readonly disabled: boolean;
                readonly round: boolean;
                readonly dark: boolean;
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                readonly bg: boolean;
                readonly loading: boolean;
                readonly autofocus: boolean;
                readonly tag: string | import('vue').Component;
                readonly plain: boolean;
                readonly nativeType: "button" | "reset" | "submit";
                readonly loadingIcon: string | import('vue').Component;
                readonly autoInsertSpace: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<"" | "small" | "default" | "large">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly disabled: BooleanConstructor;
            readonly type: {
                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            readonly icon: {
                readonly type: PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly nativeType: {
                readonly type: PropType<"button" | "reset" | "submit">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "button";
            };
            readonly loading: BooleanConstructor;
            readonly loadingIcon: {
                readonly type: PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => any;
            };
            readonly plain: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            readonly text: BooleanConstructor;
            readonly link: BooleanConstructor;
            readonly bg: BooleanConstructor;
            readonly autofocus: BooleanConstructor;
            readonly round: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            readonly circle: BooleanConstructor;
            readonly color: StringConstructor;
            readonly dark: BooleanConstructor;
            readonly autoInsertSpace: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            readonly tag: {
                readonly type: PropType<string | import('vue').Component>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "button";
            };
        }>> & {
            onClick?: ((evt: MouseEvent) => any) | undefined;
        }, {
            ref: import('vue').Ref<HTMLButtonElement | undefined>;
            size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
            type: import('vue').ComputedRef<string>;
            disabled: import('vue').ComputedRef<boolean>;
            shouldAddSpace: import('vue').ComputedRef<boolean>;
        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
            click: (evt: MouseEvent) => void;
        }, string, {
            readonly link: boolean;
            readonly circle: boolean;
            readonly text: boolean;
            readonly disabled: boolean;
            readonly round: boolean;
            readonly dark: boolean;
            readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
            readonly bg: boolean;
            readonly loading: boolean;
            readonly autofocus: boolean;
            readonly tag: string | import('vue').Component;
            readonly plain: boolean;
            readonly nativeType: "button" | "reset" | "submit";
            readonly loadingIcon: string | import('vue').Component;
            readonly autoInsertSpace: boolean;
        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                loading?(_: {}): any;
                icon?(_: {}): any;
                default?(_: {}): any;
            };
        }) & import('vue').Plugin) & {
            ButtonGroup: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                }>>, {}, {}, {}, {}, {
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    default?(_: {}): any;
                };
            });
        };
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
        ProDropdown: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
            selected: PropType<DropdownItem | null>;
            transition: {
                type: StringConstructor;
                default: string;
            };
            items: PropType<DropdownItem[]>;
            modelValue: PropType<DropdownItem["command"]>;
            menuStyle: PropType<import('../../ele-app/types').StyleValue>;
            iconProps: PropType<import('../../ele-app/el').ElIconProps>;
            componentType: PropType<"pro">;
            preventContextmenu: BooleanConstructor;
            splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            id: StringConstructor;
            type: {
                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            effect: {
                readonly default: "light";
                readonly type: PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            placement: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "bottom";
            };
            popperClass: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            teleported: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            disabled: BooleanConstructor;
            persistent: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            triggerKeys: {
                readonly type: PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => string[];
            };
            popperOptions: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            splitButton: BooleanConstructor;
            hideOnClick: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            loop: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            showTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            hideTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            tabindex: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            maxHeight: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            role: {
                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "menu";
            };
            buttonProps: {
                readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
            ariaLabel: StringConstructor;
            appendTo: {
                readonly type: PropType<string | HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            offset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            bg: StringConstructor;
            zIndex: NumberConstructor;
            visible: {
                readonly type: PropType<boolean | null>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: null;
            };
            trigger: {
                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "hover";
            };
            popperStyle: PropType<import('../../ele-app/types').StyleValue>;
            enterable: {
                readonly default: true;
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            showArrow: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowOffset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 5;
            };
            virtualRef: {
                readonly type: PropType<import('element-plus').Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            virtualTriggering: BooleanConstructor;
            className: StringConstructor;
            gpuAcceleration: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowBg: StringConstructor;
        }>, {
            ArrowDown: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            tooltipRef: import('vue').Ref<import('../../ele-app/plus').EleTooltipInstance, import('../../ele-app/plus').EleTooltipInstance>;
            tooltipProps: import('vue').ComputedRef<Partial<import('../../ele-tooltip/props').TooltipProps>>;
            hasSubMenu: import('vue').ComputedRef<boolean>;
            hidePopper: () => void;
            updatePopper: () => void;
            handleUpdateVisible: (visible: boolean) => void;
            handlePopBeforeEnter: () => void;
            handlePopBeforeLeave: () => void;
            handlePopAfterEnter: () => void;
            handlePopAfterLeave: () => void;
            handleItemClick: (item: 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: DropdownItem["command"]) => boolean;
            visibleChange: (_visible: boolean) => boolean;
            'update:modelValue': (_value: DropdownItem["command"]) => boolean;
            change: (_active: DropdownItem["command"]) => boolean;
            "update:visible": (value: boolean) => boolean;
            "before-enter": () => boolean;
            "before-leave": () => boolean;
            "after-enter": () => boolean;
            "after-leave": () => boolean;
        }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
            selected: PropType<DropdownItem | null>;
            transition: {
                type: StringConstructor;
                default: string;
            };
            items: PropType<DropdownItem[]>;
            modelValue: PropType<DropdownItem["command"]>;
            menuStyle: PropType<import('../../ele-app/types').StyleValue>;
            iconProps: PropType<import('../../ele-app/el').ElIconProps>;
            componentType: PropType<"pro">;
            preventContextmenu: BooleanConstructor;
            splitButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            caretButtonProps: PropType<import('../../ele-app/el').ElButtonProps>;
            id: StringConstructor;
            type: {
                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            effect: {
                readonly default: "light";
                readonly type: PropType<import('element-plus').PopperEffect>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            placement: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "bottom";
            };
            popperClass: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            teleported: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            disabled: BooleanConstructor;
            persistent: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            triggerKeys: {
                readonly type: PropType<string[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => string[];
            };
            popperOptions: {
                readonly type: PropType<any>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: () => {};
            };
            splitButton: BooleanConstructor;
            hideOnClick: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            loop: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            showTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            hideTimeout: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 150;
            };
            tabindex: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 0;
            };
            maxHeight: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "";
            };
            role: {
                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "menu";
            };
            buttonProps: {
                readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
            ariaLabel: StringConstructor;
            appendTo: {
                readonly type: PropType<string | HTMLElement>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            offset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: undefined;
            };
            bg: StringConstructor;
            zIndex: NumberConstructor;
            visible: {
                readonly type: PropType<boolean | null>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: null;
            };
            trigger: {
                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: "hover";
            };
            popperStyle: PropType<import('../../ele-app/types').StyleValue>;
            enterable: {
                readonly default: true;
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                readonly __epPropKey: true;
            };
            showArrow: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowOffset: {
                readonly type: PropType<number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: 5;
            };
            virtualRef: {
                readonly type: PropType<import('element-plus').Measurable>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            virtualTriggering: BooleanConstructor;
            className: StringConstructor;
            gpuAcceleration: {
                readonly type: PropType<boolean>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            } & {
                readonly default: true;
            };
            arrowBg: StringConstructor;
        }>> & Readonly<{
            onChange?: ((_active: (string | number | Record<string, any>) | undefined) => any) | undefined;
            onClick?: ((_e: MouseEvent) => any) | undefined;
            onCommand?: ((_command: (string | number | Record<string, any>) | undefined) => any) | undefined;
            "onUpdate:visible"?: ((value: boolean) => any) | undefined;
            onVisibleChange?: ((_visible: boolean) => any) | undefined;
            "onUpdate:modelValue"?: ((_value: (string | number | Record<string, any>) | undefined) => any) | undefined;
            "onBefore-enter"?: (() => any) | undefined;
            "onBefore-leave"?: (() => any) | undefined;
            "onAfter-enter"?: (() => any) | undefined;
            "onAfter-leave"?: (() => any) | undefined;
        }>, {
            effect: import('element-plus').PopperEffect;
            placement: any;
            popperClass: string;
            teleported: boolean;
            disabled: boolean;
            offset: number;
            persistent: boolean;
            visible: boolean | null;
            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
            triggerKeys: string[];
            popperOptions: any;
            splitButton: boolean;
            hideOnClick: boolean;
            loop: boolean;
            showTimeout: number;
            hideTimeout: number;
            tabindex: string | number;
            maxHeight: string | number;
            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
            transition: string;
            enterable: boolean;
            showArrow: boolean;
            arrowOffset: number;
            virtualTriggering: boolean;
            gpuAcceleration: boolean;
            preventContextmenu: boolean;
        }, {}, {
            ElButton: ({
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: {
                        readonly type: PropType<"button" | "reset" | "submit">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => any;
                    };
                    readonly plain: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly text: BooleanConstructor;
                    readonly link: BooleanConstructor;
                    readonly bg: BooleanConstructor;
                    readonly autofocus: BooleanConstructor;
                    readonly round: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly circle: BooleanConstructor;
                    readonly color: StringConstructor;
                    readonly dark: BooleanConstructor;
                    readonly autoInsertSpace: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly tag: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                }>> & {
                    onClick?: ((evt: MouseEvent) => any) | undefined;
                }, {
                    ref: import('vue').Ref<HTMLButtonElement | undefined>;
                    size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                    type: import('vue').ComputedRef<string>;
                    disabled: import('vue').ComputedRef<boolean>;
                    shouldAddSpace: import('vue').ComputedRef<boolean>;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    click: (evt: MouseEvent) => void;
                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly link: boolean;
                    readonly circle: boolean;
                    readonly text: boolean;
                    readonly disabled: boolean;
                    readonly round: boolean;
                    readonly dark: boolean;
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    readonly bg: boolean;
                    readonly loading: boolean;
                    readonly autofocus: boolean;
                    readonly tag: string | import('vue').Component;
                    readonly plain: boolean;
                    readonly nativeType: "button" | "reset" | "submit";
                    readonly loadingIcon: string | import('vue').Component;
                    readonly autoInsertSpace: boolean;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly icon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly nativeType: {
                        readonly type: PropType<"button" | "reset" | "submit">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                    readonly loading: BooleanConstructor;
                    readonly loadingIcon: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => any;
                    };
                    readonly plain: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly text: BooleanConstructor;
                    readonly link: BooleanConstructor;
                    readonly bg: BooleanConstructor;
                    readonly autofocus: BooleanConstructor;
                    readonly round: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly circle: BooleanConstructor;
                    readonly color: StringConstructor;
                    readonly dark: BooleanConstructor;
                    readonly autoInsertSpace: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly tag: {
                        readonly type: PropType<string | import('vue').Component>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "button";
                    };
                }>> & {
                    onClick?: ((evt: MouseEvent) => any) | undefined;
                }, {
                    ref: import('vue').Ref<HTMLButtonElement | undefined>;
                    size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                    type: import('vue').ComputedRef<string>;
                    disabled: import('vue').ComputedRef<boolean>;
                    shouldAddSpace: import('vue').ComputedRef<boolean>;
                }, {}, {}, {}, {
                    readonly link: boolean;
                    readonly circle: boolean;
                    readonly text: boolean;
                    readonly disabled: boolean;
                    readonly round: boolean;
                    readonly dark: boolean;
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    readonly bg: boolean;
                    readonly loading: boolean;
                    readonly autofocus: boolean;
                    readonly tag: string | import('vue').Component;
                    readonly plain: boolean;
                    readonly nativeType: "button" | "reset" | "submit";
                    readonly loadingIcon: string | import('vue').Component;
                    readonly autoInsertSpace: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<"" | "small" | "default" | "large">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
                readonly type: {
                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly icon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly nativeType: {
                    readonly type: PropType<"button" | "reset" | "submit">;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
                readonly loading: BooleanConstructor;
                readonly loadingIcon: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => any;
                };
                readonly plain: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly text: BooleanConstructor;
                readonly link: BooleanConstructor;
                readonly bg: BooleanConstructor;
                readonly autofocus: BooleanConstructor;
                readonly round: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly circle: BooleanConstructor;
                readonly color: StringConstructor;
                readonly dark: BooleanConstructor;
                readonly autoInsertSpace: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly tag: {
                    readonly type: PropType<string | import('vue').Component>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "button";
                };
            }>> & {
                onClick?: ((evt: MouseEvent) => any) | undefined;
            }, {
                ref: import('vue').Ref<HTMLButtonElement | undefined>;
                size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
                type: import('vue').ComputedRef<string>;
                disabled: import('vue').ComputedRef<boolean>;
                shouldAddSpace: import('vue').ComputedRef<boolean>;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                click: (evt: MouseEvent) => void;
            }, string, {
                readonly link: boolean;
                readonly circle: boolean;
                readonly text: boolean;
                readonly disabled: boolean;
                readonly round: boolean;
                readonly dark: boolean;
                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                readonly bg: boolean;
                readonly loading: boolean;
                readonly autofocus: boolean;
                readonly tag: string | import('vue').Component;
                readonly plain: boolean;
                readonly nativeType: "button" | "reset" | "submit";
                readonly loadingIcon: string | import('vue').Component;
                readonly autoInsertSpace: boolean;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    loading?(_: {}): any;
                    icon?(_: {}): any;
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin) & {
                ButtonGroup: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: PropType<"" | "small" | "default" | "large">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly type: {
                            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                    }>>, {}, {}, {}, {}, {
                        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    readonly size: {
                        readonly type: PropType<"" | "small" | "default" | "large">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly type: {
                        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
                    readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                    $slots: {
                        default?(_: {}): any;
                    };
                });
            };
            ElScrollbar: {
                new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly ariaOrientation: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly height: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly maxHeight: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly native: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    readonly wrapStyle: {
                        readonly type: PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly wrapClass: {
                        readonly type: PropType<string | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly viewClass: {
                        readonly type: PropType<string | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly viewStyle: {
                        readonly type: PropType<string | Record<string, any> | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly noresize: BooleanConstructor;
                    readonly tag: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "div";
                    };
                    readonly always: BooleanConstructor;
                    readonly minSize: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 20;
                    };
                    readonly tabindex: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: ((args_0: {
                        scrollTop: number;
                        scrollLeft: number;
                    }) => any) | undefined;
                    "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                }, {
                    wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                    update: () => void;
                    scrollTo: {
                        (xCord: number, yCord?: number): void;
                        (options: ScrollToOptions): void;
                    };
                    setScrollTop: (value: number) => void;
                    setScrollLeft: (value: number) => void;
                    handleScroll: () => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    scroll: (args_0: {
                        scrollTop: number;
                        scrollLeft: number;
                    }) => void;
                    "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
                }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                    readonly height: string | number;
                    readonly maxHeight: string | number;
                    readonly always: boolean;
                    readonly tabindex: string | number;
                    readonly minSize: number;
                    readonly native: boolean;
                    readonly wrapStyle: import('vue').StyleValue;
                    readonly wrapClass: string | unknown[];
                    readonly viewClass: string | unknown[];
                    readonly viewStyle: string | Record<string, any> | unknown[];
                    readonly tag: string;
                    readonly noresize: boolean;
                }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<import('vue').ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly ariaOrientation: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    readonly height: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly maxHeight: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly native: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    readonly wrapStyle: {
                        readonly type: PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly wrapClass: {
                        readonly type: PropType<string | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly viewClass: {
                        readonly type: PropType<string | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly viewStyle: {
                        readonly type: PropType<string | Record<string, any> | unknown[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    readonly noresize: BooleanConstructor;
                    readonly tag: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "div";
                    };
                    readonly always: BooleanConstructor;
                    readonly minSize: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 20;
                    };
                    readonly tabindex: {
                        readonly type: PropType<string | number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: ((args_0: {
                        scrollTop: number;
                        scrollLeft: number;
                    }) => any) | undefined;
                    "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
                }, {
                    wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                    update: () => void;
                    scrollTo: {
                        (xCord: number, yCord?: number): void;
                        (options: ScrollToOptions): void;
                    };
                    setScrollTop: (value: number) => void;
                    setScrollLeft: (value: number) => void;
                    handleScroll: () => void;
                }, {}, {}, {}, {
                    readonly height: string | number;
                    readonly maxHeight: string | number;
                    readonly always: boolean;
                    readonly tabindex: string | number;
                    readonly minSize: number;
                    readonly native: boolean;
                    readonly wrapStyle: import('vue').StyleValue;
                    readonly wrapClass: string | unknown[];
                    readonly viewClass: string | unknown[];
                    readonly viewStyle: string | Record<string, any> | unknown[];
                    readonly tag: string;
                    readonly noresize: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                readonly ariaLabel: StringConstructor;
                readonly ariaOrientation: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly height: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly maxHeight: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly native: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: false;
                };
                readonly wrapStyle: {
                    readonly type: PropType<import('vue').StyleValue>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly wrapClass: {
                    readonly type: PropType<string | unknown[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly viewClass: {
                    readonly type: PropType<string | unknown[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly viewStyle: {
                    readonly type: PropType<string | Record<string, any> | unknown[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                readonly noresize: BooleanConstructor;
                readonly tag: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "div";
                };
                readonly always: BooleanConstructor;
                readonly minSize: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 20;
                };
                readonly tabindex: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: undefined;
                };
                readonly id: StringConstructor;
                readonly role: StringConstructor;
            }>> & {
                onScroll?: ((args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => any) | undefined;
                "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
            }, {
                wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
                update: () => void;
                scrollTo: {
                    (xCord: number, yCord?: number): void;
                    (options: ScrollToOptions): void;
                };
                setScrollTop: (value: number) => void;
                setScrollLeft: (value: number) => void;
                handleScroll: () => void;
            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                scroll: (args_0: {
                    scrollTop: number;
                    scrollLeft: number;
                }) => void;
                "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
            }, string, {
                readonly height: string | number;
                readonly maxHeight: string | number;
                readonly always: boolean;
                readonly tabindex: string | number;
                readonly minSize: number;
                readonly native: boolean;
                readonly wrapStyle: import('vue').StyleValue;
                readonly wrapClass: string | unknown[];
                readonly viewClass: string | unknown[];
                readonly viewStyle: string | Record<string, any> | unknown[];
                readonly tag: string;
                readonly noresize: boolean;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                $slots: {
                    default?(_: {}): any;
                };
            }) & import('vue').Plugin;
            EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
                bg: StringConstructor;
                arrowBg: StringConstructor;
                width: (StringConstructor | NumberConstructor)[];
                isPopover: BooleanConstructor;
                showAfter: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                hideAfter: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 200;
                };
                autoClose: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                effect: {
                    readonly type: PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "dark";
                };
                ariaLabel: StringConstructor;
                placement: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                teleported: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                appendTo: {
                    readonly type: PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                disabled: BooleanConstructor;
                offset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 12;
                };
                persistent: BooleanConstructor;
                zIndex: NumberConstructor;
                visible: {
                    readonly type: PropType<boolean | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                trigger: {
                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                triggerKeys: {
                    readonly type: PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                popperOptions: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                transition: StringConstructor;
                content: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                enterable: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                showArrow: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: boolean;
                };
                arrowOffset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 5;
                };
                virtualRef: {
                    readonly type: PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                rawContent: BooleanConstructor;
                gpuAcceleration: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                className: StringConstructor;
                popperClass: StringConstructor;
                popperStyle: PropType<import('../../ele-app/types').StyleValue>;
            }>, {
                tooltipRef: import('vue').Ref<import('../../ele-app/el').ElTooltipInstance | undefined, import('../../ele-app/el').ElTooltipInstance | undefined>;
                rootProps: import('vue').ComputedRef<Partial<import('element-plus').ElTooltipProps>>;
                popperRef: import('vue').ComputedRef<import('../../ele-app/el').ElPopperInstance>;
                contentRef: import('vue').ComputedRef<import('element-plus').TooltipContentInstance | undefined>;
                isFocusInsideContent: () => void;
                updatePopper: () => void;
                handleOpen: (opt?: Event) => void;
                handleClose: (opt?: Event) => void;
                hide: (opt?: Event) => void;
                handleUpdateVisible: (visible: boolean) => void;
                handlePopBeforeShow: (e: Event) => void;
                handlePopBeforeHide: (e: Event) => void;
                handlePopShow: (e: Event) => void;
                handlePopHide: (e: Event) => void;
                handlePopOpen: (e: any) => void;
                handlePopClose: (e: any) => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, import('../../ele-tooltip/props').TooltipEmits, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
                bg: StringConstructor;
                arrowBg: StringConstructor;
                width: (StringConstructor | NumberConstructor)[];
                isPopover: BooleanConstructor;
                showAfter: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                hideAfter: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 200;
                };
                autoClose: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 0;
                };
                effect: {
                    readonly type: PropType<import('element-plus').PopperEffect>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "dark";
                };
                ariaLabel: StringConstructor;
                placement: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "bottom";
                };
                teleported: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                appendTo: {
                    readonly type: PropType<string | HTMLElement>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                disabled: BooleanConstructor;
                offset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 12;
                };
                persistent: BooleanConstructor;
                zIndex: NumberConstructor;
                visible: {
                    readonly type: PropType<boolean | null>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: null;
                };
                trigger: {
                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "hover";
                };
                triggerKeys: {
                    readonly type: PropType<string[]>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => string[];
                };
                popperOptions: {
                    readonly type: PropType<any>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: () => {};
                };
                transition: StringConstructor;
                content: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: "";
                };
                enterable: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                showArrow: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: boolean;
                };
                arrowOffset: {
                    readonly type: PropType<number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: 5;
                };
                virtualRef: {
                    readonly type: PropType<import('element-plus').Measurable>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                virtualTriggering: BooleanConstructor;
                rawContent: BooleanConstructor;
                gpuAcceleration: {
                    readonly type: PropType<boolean>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                } & {
                    readonly default: true;
                };
                className: StringConstructor;
                popperClass: StringConstructor;
                popperStyle: PropType<import('../../ele-app/types').StyleValue>;
            }>> & Readonly<{
                onClose?: ((e: any) => any) | undefined;
                onHide?: ((e: Event) => any) | undefined;
                onOpen?: ((e: any) => any) | undefined;
                "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
                "onBefore-show"?: ((e: Event) => any) | undefined;
                "onBefore-hide"?: ((e: Event) => any) | undefined;
                onShow?: ((e: Event) => any) | undefined;
            }>, {
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                effect: import('element-plus').PopperEffect;
                placement: string;
                teleported: boolean;
                disabled: boolean;
                offset: number;
                persistent: boolean;
                visible: boolean | null;
                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                triggerKeys: string[];
                popperOptions: any;
                content: string;
                enterable: boolean;
                showArrow: boolean;
                arrowOffset: number;
                virtualTriggering: boolean;
                rawContent: boolean;
                gpuAcceleration: boolean;
                isPopover: boolean;
            }, {}, {
                ElTooltip: {
                    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                        showArrow: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: boolean;
                        };
                        arrowOffset: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 5;
                        };
                        disabled: BooleanConstructor;
                        trigger: {
                            readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "hover";
                        };
                        triggerKeys: {
                            readonly type: PropType<string[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => string[];
                        };
                        virtualRef: {
                            readonly type: PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        onMouseenter: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onMouseleave: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onClick: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onKeydown: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onFocus: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onBlur: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onContextmenu: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        id: StringConstructor;
                        open: BooleanConstructor;
                        ariaLabel: StringConstructor;
                        appendTo: {
                            readonly type: PropType<string | HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        content: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        rawContent: BooleanConstructor;
                        persistent: BooleanConstructor;
                        visible: {
                            readonly type: PropType<boolean | null>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: null;
                        };
                        transition: StringConstructor;
                        teleported: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        style: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        className: {
                            readonly type: PropType<string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | any[] | {
                                [x: string]: boolean;
                            })[])[])[])[])[])[])[])[])[])[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        effect: {
                            readonly type: PropType<import('element-plus').PopperEffect>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "dark";
                        };
                        enterable: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        pure: BooleanConstructor;
                        focusOnShow: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        trapping: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        popperClass: {
                            readonly type: PropType<string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | any[] | {
                                [x: string]: boolean;
                            })[])[])[])[])[])[])[])[])[])[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        popperStyle: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        referenceEl: {
                            readonly type: PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        triggerTargetEl: {
                            readonly type: PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        stopPopperMouseEvent: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        zIndex: NumberConstructor;
                        boundariesPadding: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        fallbackPlacements: {
                            readonly type: PropType<Placement[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        gpuAcceleration: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        offset: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 12;
                        };
                        placement: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "bottom";
                        };
                        popperOptions: {
                            readonly type: PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => {};
                        };
                        strategy: {
                            readonly type: PropType<"fixed" | "absolute">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "absolute";
                        };
                        showAfter: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        hideAfter: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 200;
                        };
                        autoClose: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        "onUpdate:visible": {
                            readonly type: PropType<(val: boolean) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        role: {
                            readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "tooltip";
                        };
                    }>>, {
                        popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                        contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
                        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                        updatePopper: () => void;
                        onOpen: (event?: Event) => void;
                        onClose: (event?: Event) => void;
                        hide: (event?: Event) => void;
                    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                        [x: string]: (...args: any[]) => void;
                    }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
                        disabled: boolean;
                        content: string;
                        offset: number;
                        visible: boolean | null;
                        open: boolean;
                        placement: string;
                        strategy: "fixed" | "absolute";
                        effect: import('element-plus').PopperEffect;
                        showAfter: number;
                        hideAfter: number;
                        autoClose: number;
                        trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                        role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                        virtualTriggering: boolean;
                        arrowOffset: number;
                        boundariesPadding: number;
                        fallbackPlacements: Placement[];
                        gpuAcceleration: boolean;
                        popperOptions: Partial<Options>;
                        enterable: boolean;
                        focusOnShow: boolean;
                        trapping: boolean;
                        stopPopperMouseEvent: boolean;
                        pure: boolean;
                        triggerKeys: string[];
                        teleported: boolean;
                        rawContent: boolean;
                        persistent: boolean;
                        showArrow: boolean;
                    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<import('vue').ExtractPropTypes<{
                        showArrow: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: boolean;
                        };
                        arrowOffset: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 5;
                        };
                        disabled: BooleanConstructor;
                        trigger: {
                            readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "hover";
                        };
                        triggerKeys: {
                            readonly type: PropType<string[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => string[];
                        };
                        virtualRef: {
                            readonly type: PropType<import('element-plus').Measurable>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        virtualTriggering: BooleanConstructor;
                        onMouseenter: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onMouseleave: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onClick: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onKeydown: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onFocus: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onBlur: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        onContextmenu: {
                            readonly type: PropType<(e: Event) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        id: StringConstructor;
                        open: BooleanConstructor;
                        ariaLabel: StringConstructor;
                        appendTo: {
                            readonly type: PropType<string | HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        content: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "";
                        };
                        rawContent: BooleanConstructor;
                        persistent: BooleanConstructor;
                        visible: {
                            readonly type: PropType<boolean | null>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: null;
                        };
                        transition: StringConstructor;
                        teleported: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        style: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        className: {
                            readonly type: PropType<string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | any[] | {
                                [x: string]: boolean;
                            })[])[])[])[])[])[])[])[])[])[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        effect: {
                            readonly type: PropType<import('element-plus').PopperEffect>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "dark";
                        };
                        enterable: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        pure: BooleanConstructor;
                        focusOnShow: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        trapping: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: false;
                        };
                        popperClass: {
                            readonly type: PropType<string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | {
                                [x: string]: boolean;
                            } | (string | any[] | {
                                [x: string]: boolean;
                            })[])[])[])[])[])[])[])[])[])[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        popperStyle: {
                            readonly type: PropType<import('vue').StyleValue>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        referenceEl: {
                            readonly type: PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        triggerTargetEl: {
                            readonly type: PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        stopPopperMouseEvent: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        zIndex: NumberConstructor;
                        boundariesPadding: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        fallbackPlacements: {
                            readonly type: PropType<Placement[]>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: undefined;
                        };
                        gpuAcceleration: {
                            readonly type: PropType<boolean>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: true;
                        };
                        offset: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 12;
                        };
                        placement: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "bottom";
                        };
                        popperOptions: {
                            readonly type: PropType<any>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: () => {};
                        };
                        strategy: {
                            readonly type: PropType<"fixed" | "absolute">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "absolute";
                        };
                        showAfter: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        hideAfter: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 200;
                        };
                        autoClose: {
                            readonly type: PropType<number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: 0;
                        };
                        "onUpdate:visible": {
                            readonly type: PropType<(val: boolean) => void>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        role: {
                            readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        } & {
                            readonly default: "tooltip";
                        };
                    }>>, {
                        popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                        contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
                        isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                        updatePopper: () => void;
                        onOpen: (event?: Event) => void;
                        onClose: (event?: Event) => void;
                        hide: (event?: Event) => void;
                    }, {}, {}, {}, {
                        disabled: boolean;
                        content: string;
                        offset: number;
                        visible: boolean | null;
                        open: boolean;
                        placement: string;
                        strategy: "fixed" | "absolute";
                        effect: import('element-plus').PopperEffect;
                        showAfter: number;
                        hideAfter: number;
                        autoClose: number;
                        trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                        role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                        virtualTriggering: boolean;
                        arrowOffset: number;
                        boundariesPadding: number;
                        fallbackPlacements: Placement[];
                        gpuAcceleration: boolean;
                        popperOptions: Partial<Options>;
                        enterable: boolean;
                        focusOnShow: boolean;
                        trapping: boolean;
                        stopPopperMouseEvent: boolean;
                        pure: boolean;
                        triggerKeys: string[];
                        teleported: boolean;
                        rawContent: boolean;
                        persistent: boolean;
                        showArrow: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                    showArrow: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: boolean;
                    };
                    arrowOffset: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 5;
                    };
                    disabled: BooleanConstructor;
                    trigger: {
                        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "hover";
                    };
                    triggerKeys: {
                        readonly type: PropType<string[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => string[];
                    };
                    virtualRef: {
                        readonly type: PropType<import('element-plus').Measurable>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    virtualTriggering: BooleanConstructor;
                    onMouseenter: {
                        readonly type: PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onMouseleave: {
                        readonly type: PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onClick: {
                        readonly type: PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onKeydown: {
                        readonly type: PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onFocus: {
                        readonly type: PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onBlur: {
                        readonly type: PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    onContextmenu: {
                        readonly type: PropType<(e: Event) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    id: StringConstructor;
                    open: BooleanConstructor;
                    ariaLabel: StringConstructor;
                    appendTo: {
                        readonly type: PropType<string | HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    content: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "";
                    };
                    rawContent: BooleanConstructor;
                    persistent: BooleanConstructor;
                    visible: {
                        readonly type: PropType<boolean | null>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: null;
                    };
                    transition: StringConstructor;
                    teleported: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    style: {
                        readonly type: PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    className: {
                        readonly type: PropType<string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | any[] | {
                            [x: string]: boolean;
                        })[])[])[])[])[])[])[])[])[])[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    effect: {
                        readonly type: PropType<import('element-plus').PopperEffect>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "dark";
                    };
                    enterable: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    pure: BooleanConstructor;
                    focusOnShow: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    trapping: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: false;
                    };
                    popperClass: {
                        readonly type: PropType<string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | {
                            [x: string]: boolean;
                        } | (string | any[] | {
                            [x: string]: boolean;
                        })[])[])[])[])[])[])[])[])[])[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    popperStyle: {
                        readonly type: PropType<import('vue').StyleValue>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    referenceEl: {
                        readonly type: PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    triggerTargetEl: {
                        readonly type: PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    stopPopperMouseEvent: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    zIndex: NumberConstructor;
                    boundariesPadding: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    fallbackPlacements: {
                        readonly type: PropType<Placement[]>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: undefined;
                    };
                    gpuAcceleration: {
                        readonly type: PropType<boolean>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: true;
                    };
                    offset: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 12;
                    };
                    placement: {
                        readonly type: PropType<string>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "bottom";
                    };
                    popperOptions: {
                        readonly type: PropType<any>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: () => {};
                    };
                    strategy: {
                        readonly type: PropType<"fixed" | "absolute">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "absolute";
                    };
                    showAfter: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    hideAfter: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 200;
                    };
                    autoClose: {
                        readonly type: PropType<number>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: 0;
                    };
                    "onUpdate:visible": {
                        readonly type: PropType<(val: boolean) => void>;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    };
                    role: {
                        readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
                        readonly required: false;
                        readonly validator: ((val: unknown) => boolean) | undefined;
                        __epPropKey: true;
                    } & {
                        readonly default: "tooltip";
                    };
                }>>, {
                    popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
                    contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
                    isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
                    updatePopper: () => void;
                    onOpen: (event?: Event) => void;
                    onClose: (event?: Event) => void;
                    hide: (event?: Event) => void;
                }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    [x: string]: (...args: any[]) => void;
                }, string, {
                    disabled: boolean;
                    content: string;
                    offset: number;
                    visible: boolean | null;
                    open: boolean;
                    placement: string;
                    strategy: "fixed" | "absolute";
                    effect: import('element-plus').PopperEffect;
                    showAfter: number;
                    hideAfter: number;
                    autoClose: number;
                    trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
                    role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
                    virtualTriggering: boolean;
                    arrowOffset: number;
                    boundariesPadding: number;
                    fallbackPlacements: Placement[];
                    gpuAcceleration: boolean;
                    popperOptions: Partial<Options>;
                    enterable: boolean;
                    focusOnShow: boolean;
                    trapping: boolean;
                    stopPopperMouseEvent: boolean;
                    pure: boolean;
                    triggerKeys: string[];
                    teleported: boolean;
                    rawContent: boolean;
                    persistent: boolean;
                    showArrow: boolean;
                }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                    $slots: {
                        default?(_: {}): any;
                        content?(_: {}): any;
                    };
                }) & import('vue').Plugin;
            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            DropdownMenus: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                items: {
                    type: PropType<DropdownItem[]>;
                    required: true;
                };
                selected: PropType<DropdownItem["command"]>;
                menuStyle: PropType<import('../../ele-app/types').StyleValue>;
                iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
            }>, {
                handleItemClick: (item: DropdownItem) => void;
                handleWrapperContext: (e: MouseEvent) => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                itemClick: (_item: DropdownItem) => true;
                wrapperContext: (_e: MouseEvent) => true;
            }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                items: {
                    type: PropType<DropdownItem[]>;
                    required: true;
                };
                selected: PropType<DropdownItem["command"]>;
                menuStyle: PropType<import('../../ele-app/types').StyleValue>;
                iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
            }>> & Readonly<{
                onItemClick?: ((_item: DropdownItem) => any) | undefined;
                onWrapperContext?: ((_e: MouseEvent) => any) | undefined;
            }>, {}, {}, {
                DropdownMenuItem: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
                    item: {
                        type: PropType<DropdownItem>;
                        required: true;
                    };
                    selected: PropType<DropdownItem["command"]>;
                    iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                }>, {
                    itemRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                    subMenuRef: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
                    placement: import('vue').Ref<"rightEnd" | "leftStart" | "leftEnd" | undefined, "rightEnd" | "leftStart" | "leftEnd" | undefined>;
                    handleItemClick: () => void;
                    handleItemMouseenter: () => void;
                    handleWrapperContext: (e: MouseEvent) => void;
                }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                    itemClick: (_item: DropdownItem) => true;
                    wrapperContext: (_e: MouseEvent) => true;
                }, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
                    item: {
                        type: PropType<DropdownItem>;
                        required: true;
                    };
                    selected: PropType<DropdownItem["command"]>;
                    iconProps: PropType<import('../../ele-app/el').ElIconProps>;
                }>> & Readonly<{
                    onItemClick?: ((_item: DropdownItem) => any) | undefined;
                    onWrapperContext?: ((_e: MouseEvent) => any) | undefined;
                }>, {}, {}, {
                    ElIcon: {
                        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                            readonly size: {
                                readonly type: PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly color: {
                                readonly type: PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                            P: {};
                            B: {};
                            D: {};
                            C: {};
                            M: {};
                            Defaults: {};
                        }, Readonly<import('vue').ExtractPropTypes<{
                            readonly size: {
                                readonly type: PropType<string | number>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                            readonly color: {
                                readonly type: PropType<string>;
                                readonly required: false;
                                readonly validator: ((val: unknown) => boolean) | undefined;
                                __epPropKey: true;
                            };
                        }>>, {}, {}, {}, {}, {}>;
                        __isFragment?: never;
                        __isTeleport?: never;
                        __isSuspense?: never;
                    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                        readonly size: {
                            readonly type: PropType<string | number>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                        readonly color: {
                            readonly type: PropType<string>;
                            readonly required: false;
                            readonly validator: ((val: unknown) => boolean) | undefined;
                            __epPropKey: true;
                        };
                    }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
                        $slots: {
                            default?(_: {}): any;
                        };
                    }) & import('vue').Plugin;
                    ArrowRight: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
                }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
            }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    EleTabTool: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
        tab: BooleanConstructor;
        active: BooleanConstructor;
        tabName: (StringConstructor | NumberConstructor)[];
    }>, {
        handleItemClick: (e: MouseEvent) => void;
        handleItemContextmenu: (e: MouseEvent) => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
        tab: BooleanConstructor;
        active: BooleanConstructor;
        tabName: (StringConstructor | NumberConstructor)[];
    }>> & Readonly<{}>, {
        tab: boolean;
        active: boolean;
    }, {}, {
        ElIcon: {
            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {}, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<import('vue').ExtractPropTypes<{
                readonly size: {
                    readonly type: PropType<string | number>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
                readonly color: {
                    readonly type: PropType<string>;
                    readonly required: false;
                    readonly validator: ((val: unknown) => boolean) | undefined;
                    __epPropKey: true;
                };
            }>>, {}, {}, {}, {}, {}>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
            readonly size: {
                readonly type: PropType<string | number>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
            readonly color: {
                readonly type: PropType<string>;
                readonly required: false;
                readonly validator: ((val: unknown) => boolean) | undefined;
                __epPropKey: true;
            };
        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
            $slots: {
                default?(_: {}): any;
            };
        }) & import('vue').Plugin;
        CornerLeftFilled: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
        CornerRightFilled: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
export default _default;