yuang-framework-ui-pc 1.1.44 → 1.1.45

package/es/ele-dropdown/components/pro-dropdown.d.ts

@@ -0,0 +1,2912 @@
+import { PropType } from 'vue';
+import { EleTooltipInstance } from '../../ele-app/plus';
+import { DropdownItem } from '../types';
+
+declare const _default: 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>;
+    type: {
+        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    effect: {
+        readonly default: "light";
+        readonly type: PropType<import('element-plus').PopperEffect>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    placement: {
+        readonly type: PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "bottom";
+    };
+    popperClass: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    teleported: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    disabled: BooleanConstructor;
+    persistent: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    triggerKeys: {
+        readonly type: PropType<string[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => string[];
+    };
+    popperOptions: {
+        readonly type: PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {};
+    };
+    id: StringConstructor;
+    splitButton: BooleanConstructor;
+    hideOnClick: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    loop: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    showTimeout: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 150;
+    };
+    hideTimeout: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 150;
+    };
+    tabindex: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 0;
+    };
+    maxHeight: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    role: {
+        readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "menu";
+    };
+    buttonProps: {
+        readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
+    ariaLabel: StringConstructor;
+    appendTo: {
+        readonly type: PropType<string | HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    offset: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    bg: StringConstructor;
+    zIndex: NumberConstructor;
+    visible: {
+        readonly type: PropType<boolean | null>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: null;
+    };
+    trigger: {
+        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "hover";
+    };
+    popperStyle: PropType<import('../../ele-app/types').StyleValue>;
+    enterable: {
+        readonly default: true;
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    showArrow: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    arrowOffset: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 5;
+    };
+    virtualRef: {
+        readonly type: PropType<import('element-plus').Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    virtualTriggering: BooleanConstructor;
+    className: StringConstructor;
+    gpuAcceleration: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    arrowBg: StringConstructor;
+}>, {
+    ArrowDown: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    tooltipRef: import('vue').Ref<EleTooltipInstance, 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>;
+    type: {
+        readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    effect: {
+        readonly default: "light";
+        readonly type: PropType<import('element-plus').PopperEffect>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    placement: {
+        readonly type: PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "bottom";
+    };
+    popperClass: {
+        readonly type: PropType<string>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    teleported: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    disabled: BooleanConstructor;
+    persistent: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    triggerKeys: {
+        readonly type: PropType<string[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => string[];
+    };
+    popperOptions: {
+        readonly type: PropType<any>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: () => {};
+    };
+    id: StringConstructor;
+    splitButton: BooleanConstructor;
+    hideOnClick: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    loop: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    showTimeout: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 150;
+    };
+    hideTimeout: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 150;
+    };
+    tabindex: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 0;
+    };
+    maxHeight: {
+        readonly type: PropType<string | number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "";
+    };
+    role: {
+        readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "menu";
+    };
+    buttonProps: {
+        readonly type: PropType<Partial<import('element-plus').ButtonProps>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    size: PropType<import('../../ele-app/el').ElButtonProps["size"]>;
+    ariaLabel: StringConstructor;
+    appendTo: {
+        readonly type: PropType<string | HTMLElement>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    offset: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: undefined;
+    };
+    bg: StringConstructor;
+    zIndex: NumberConstructor;
+    visible: {
+        readonly type: PropType<boolean | null>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: null;
+    };
+    trigger: {
+        readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: "hover";
+    };
+    popperStyle: PropType<import('../../ele-app/types').StyleValue>;
+    enterable: {
+        readonly default: true;
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        readonly __epPropKey: true;
+    };
+    showArrow: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    arrowOffset: {
+        readonly type: PropType<number>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: 5;
+    };
+    virtualRef: {
+        readonly type: PropType<import('element-plus').Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    virtualTriggering: BooleanConstructor;
+    className: StringConstructor;
+    gpuAcceleration: {
+        readonly type: PropType<boolean>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    } & {
+        readonly default: true;
+    };
+    arrowBg: StringConstructor;
+}>> & Readonly<{
+    onChange?: ((_active: (string | number | Record<string, any>) | undefined) => any) | undefined;
+    onClick?: ((_e: MouseEvent) => any) | undefined;
+    onCommand?: ((_command: (string | number | Record<string, any>) | undefined) => any) | undefined;
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    onVisibleChange?: ((_visible: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((_value: (string | number | Record<string, any>) | undefined) => any) | undefined;
+    "onBefore-enter"?: (() => any) | undefined;
+    "onBefore-leave"?: (() => any) | undefined;
+    "onAfter-enter"?: (() => any) | undefined;
+    "onAfter-leave"?: (() => any) | undefined;
+}>, {
+    effect: import('element-plus').PopperEffect;
+    placement: any;
+    popperClass: string;
+    teleported: boolean;
+    disabled: boolean;
+    offset: number;
+    persistent: boolean;
+    visible: boolean | null;
+    trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+    triggerKeys: string[];
+    popperOptions: any;
+    splitButton: boolean;
+    hideOnClick: boolean;
+    loop: boolean;
+    showTimeout: number;
+    hideTimeout: number;
+    tabindex: string | number;
+    maxHeight: string | number;
+    role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+    transition: string;
+    enterable: boolean;
+    showArrow: boolean;
+    arrowOffset: number;
+    virtualTriggering: boolean;
+    gpuAcceleration: boolean;
+    preventContextmenu: boolean;
+}, {}, {
+    ElButton: ({
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly type: {
+                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly nativeType: {
+                readonly type: PropType<"button" | "reset" | "submit">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => any;
+            };
+            readonly plain: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly text: BooleanConstructor;
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly circle: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly tag: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }, {
+            ref: import('vue').Ref<HTMLButtonElement | undefined>;
+            size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+            type: import('vue').ComputedRef<string>;
+            disabled: import('vue').ComputedRef<boolean>;
+            shouldAddSpace: import('vue').ComputedRef<boolean>;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            click: (evt: MouseEvent) => void;
+        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly link: boolean;
+            readonly circle: boolean;
+            readonly text: boolean;
+            readonly disabled: boolean;
+            readonly round: boolean;
+            readonly dark: boolean;
+            readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
+            readonly bg: boolean;
+            readonly loading: boolean;
+            readonly autofocus: boolean;
+            readonly tag: string | import('vue').Component;
+            readonly plain: boolean;
+            readonly nativeType: "button" | "reset" | "submit";
+            readonly loadingIcon: string | import('vue').Component;
+            readonly autoInsertSpace: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly disabled: BooleanConstructor;
+            readonly type: {
+                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly icon: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly nativeType: {
+                readonly type: PropType<"button" | "reset" | "submit">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+            readonly loading: BooleanConstructor;
+            readonly loadingIcon: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => any;
+            };
+            readonly plain: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly text: BooleanConstructor;
+            readonly link: BooleanConstructor;
+            readonly bg: BooleanConstructor;
+            readonly autofocus: BooleanConstructor;
+            readonly round: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly circle: BooleanConstructor;
+            readonly color: StringConstructor;
+            readonly dark: BooleanConstructor;
+            readonly autoInsertSpace: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly tag: {
+                readonly type: PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "button";
+            };
+        }>> & {
+            onClick?: ((evt: MouseEvent) => any) | undefined;
+        }, {
+            ref: import('vue').Ref<HTMLButtonElement | undefined>;
+            size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+            type: import('vue').ComputedRef<string>;
+            disabled: import('vue').ComputedRef<boolean>;
+            shouldAddSpace: import('vue').ComputedRef<boolean>;
+        }, {}, {}, {}, {
+            readonly link: boolean;
+            readonly circle: boolean;
+            readonly text: boolean;
+            readonly disabled: boolean;
+            readonly round: boolean;
+            readonly dark: boolean;
+            readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
+            readonly bg: boolean;
+            readonly loading: boolean;
+            readonly autofocus: boolean;
+            readonly tag: string | import('vue').Component;
+            readonly plain: boolean;
+            readonly nativeType: "button" | "reset" | "submit";
+            readonly loadingIcon: string | import('vue').Component;
+            readonly autoInsertSpace: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly size: {
+            readonly type: PropType<"" | "small" | "default" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly disabled: BooleanConstructor;
+        readonly type: {
+            readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly icon: {
+            readonly type: PropType<string | import('vue').Component>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly nativeType: {
+            readonly type: PropType<"button" | "reset" | "submit">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "button";
+        };
+        readonly loading: BooleanConstructor;
+        readonly loadingIcon: {
+            readonly type: PropType<string | import('vue').Component>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => any;
+        };
+        readonly plain: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly text: BooleanConstructor;
+        readonly link: BooleanConstructor;
+        readonly bg: BooleanConstructor;
+        readonly autofocus: BooleanConstructor;
+        readonly round: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly circle: BooleanConstructor;
+        readonly color: StringConstructor;
+        readonly dark: BooleanConstructor;
+        readonly autoInsertSpace: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly tag: {
+            readonly type: PropType<string | import('vue').Component>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "button";
+        };
+    }>> & {
+        onClick?: ((evt: MouseEvent) => any) | undefined;
+    }, {
+        ref: import('vue').Ref<HTMLButtonElement | undefined>;
+        size: import('vue').ComputedRef<"" | "small" | "default" | "large">;
+        type: import('vue').ComputedRef<string>;
+        disabled: import('vue').ComputedRef<boolean>;
+        shouldAddSpace: import('vue').ComputedRef<boolean>;
+    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        click: (evt: MouseEvent) => void;
+    }, string, {
+        readonly link: boolean;
+        readonly circle: boolean;
+        readonly text: boolean;
+        readonly disabled: boolean;
+        readonly round: boolean;
+        readonly dark: boolean;
+        readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
+        readonly bg: boolean;
+        readonly loading: boolean;
+        readonly autofocus: boolean;
+        readonly tag: string | import('vue').Component;
+        readonly plain: boolean;
+        readonly nativeType: "button" | "reset" | "submit";
+        readonly loadingIcon: string | import('vue').Component;
+        readonly autoInsertSpace: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            loading?(_: {}): any;
+            icon?(_: {}): any;
+            default?(_: {}): any;
+        };
+    }) & import('vue').Plugin) & {
+        ButtonGroup: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly type: {
+                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+            }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                readonly size: {
+                    readonly type: PropType<"" | "small" | "default" | "large">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                readonly type: {
+                    readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+            }>>, {}, {}, {}, {}, {
+                readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: PropType<"" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly type: {
+                readonly type: PropType<"" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+        }>>, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, Record<string, any>, string, {
+            readonly type: "" | "default" | "text" | "success" | "primary" | "warning" | "info" | "danger";
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+            };
+        });
+    };
+    ElScrollbar: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly height: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly wrapStyle: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly noresize: BooleanConstructor;
+            readonly tag: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & {
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+        }, {
+            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            scroll: (args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => void;
+            "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly always: boolean;
+            readonly tabindex: string | number;
+            readonly minSize: number;
+            readonly native: boolean;
+            readonly wrapStyle: import('vue').StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | Record<string, any> | unknown[];
+            readonly tag: string;
+            readonly noresize: boolean;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly ariaLabel: StringConstructor;
+            readonly ariaOrientation: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly height: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly maxHeight: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly native: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            readonly wrapStyle: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly wrapClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewClass: {
+                readonly type: PropType<string | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly viewStyle: {
+                readonly type: PropType<string | Record<string, any> | unknown[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly noresize: BooleanConstructor;
+            readonly tag: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "div";
+            };
+            readonly always: BooleanConstructor;
+            readonly minSize: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 20;
+            };
+            readonly tabindex: {
+                readonly type: PropType<string | number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            readonly id: StringConstructor;
+            readonly role: StringConstructor;
+        }>> & {
+            onScroll?: ((args_0: {
+                scrollTop: number;
+                scrollLeft: number;
+            }) => any) | undefined;
+            "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+        }, {
+            wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+            update: () => void;
+            scrollTo: {
+                (xCord: number, yCord?: number): void;
+                (options: ScrollToOptions): void;
+            };
+            setScrollTop: (value: number) => void;
+            setScrollLeft: (value: number) => void;
+            handleScroll: () => void;
+        }, {}, {}, {}, {
+            readonly height: string | number;
+            readonly maxHeight: string | number;
+            readonly always: boolean;
+            readonly tabindex: string | number;
+            readonly minSize: number;
+            readonly native: boolean;
+            readonly wrapStyle: import('vue').StyleValue;
+            readonly wrapClass: string | unknown[];
+            readonly viewClass: string | unknown[];
+            readonly viewStyle: string | Record<string, any> | unknown[];
+            readonly tag: string;
+            readonly noresize: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly ariaLabel: StringConstructor;
+        readonly ariaOrientation: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly height: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly maxHeight: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly native: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: false;
+        };
+        readonly wrapStyle: {
+            readonly type: PropType<import('vue').StyleValue>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly wrapClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewClass: {
+            readonly type: PropType<string | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly viewStyle: {
+            readonly type: PropType<string | Record<string, any> | unknown[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly noresize: BooleanConstructor;
+        readonly tag: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "div";
+        };
+        readonly always: BooleanConstructor;
+        readonly minSize: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 20;
+        };
+        readonly tabindex: {
+            readonly type: PropType<string | number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: undefined;
+        };
+        readonly id: StringConstructor;
+        readonly role: StringConstructor;
+    }>> & {
+        onScroll?: ((args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => any) | undefined;
+        "onEnd-reached"?: ((direction: import('element-plus').ScrollbarDirection) => any) | undefined;
+    }, {
+        wrapRef: import('vue').Ref<HTMLDivElement | undefined>;
+        update: () => void;
+        scrollTo: {
+            (xCord: number, yCord?: number): void;
+            (options: ScrollToOptions): void;
+        };
+        setScrollTop: (value: number) => void;
+        setScrollLeft: (value: number) => void;
+        handleScroll: () => void;
+    }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        scroll: (args_0: {
+            scrollTop: number;
+            scrollLeft: number;
+        }) => void;
+        "end-reached": (direction: import('element-plus').ScrollbarDirection) => void;
+    }, string, {
+        readonly height: string | number;
+        readonly maxHeight: string | number;
+        readonly always: boolean;
+        readonly tabindex: string | number;
+        readonly minSize: number;
+        readonly native: boolean;
+        readonly wrapStyle: import('vue').StyleValue;
+        readonly wrapClass: string | unknown[];
+        readonly viewClass: string | unknown[];
+        readonly viewStyle: string | Record<string, any> | unknown[];
+        readonly tag: string;
+        readonly noresize: boolean;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) & import('vue').Plugin;
+    EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
+        bg: StringConstructor;
+        arrowBg: StringConstructor;
+        width: (StringConstructor | NumberConstructor)[];
+        isPopover: BooleanConstructor;
+        showAfter: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        hideAfter: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 200;
+        };
+        autoClose: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        effect: {
+            readonly type: PropType<import('element-plus').PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "dark";
+        };
+        ariaLabel: StringConstructor;
+        placement: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        teleported: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        appendTo: {
+            readonly type: PropType<string | HTMLElement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        disabled: BooleanConstructor;
+        offset: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 12;
+        };
+        persistent: BooleanConstructor;
+        zIndex: NumberConstructor;
+        visible: {
+            readonly type: PropType<boolean | null>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: null;
+        };
+        trigger: {
+            readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        triggerKeys: {
+            readonly type: PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        popperOptions: {
+            readonly type: PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        transition: StringConstructor;
+        content: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        enterable: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        showArrow: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        arrowOffset: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 5;
+        };
+        virtualRef: {
+            readonly type: PropType<import('element-plus').Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        virtualTriggering: BooleanConstructor;
+        rawContent: BooleanConstructor;
+        gpuAcceleration: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        className: StringConstructor;
+        popperClass: StringConstructor;
+        popperStyle: PropType<import('../../ele-app/types').StyleValue>;
+    }>, {
+        tooltipRef: import('vue').Ref<import('../../ele-app/el').ElTooltipInstance | undefined, import('../../ele-app/el').ElTooltipInstance | undefined>;
+        rootProps: import('vue').ComputedRef<Partial<import('element-plus').ElTooltipProps>>;
+        popperRef: import('vue').ComputedRef<import('../../ele-app/el').ElPopperInstance>;
+        contentRef: import('vue').ComputedRef<import('element-plus').TooltipContentInstance | undefined>;
+        isFocusInsideContent: () => void;
+        updatePopper: () => void;
+        handleOpen: (opt?: Event) => void;
+        handleClose: (opt?: Event) => void;
+        hide: (opt?: Event) => void;
+        handleUpdateVisible: (visible: boolean) => void;
+        handlePopBeforeShow: (e: Event) => void;
+        handlePopBeforeHide: (e: Event) => void;
+        handlePopShow: (e: Event) => void;
+        handlePopHide: (e: Event) => void;
+        handlePopOpen: (e: any) => void;
+        handlePopClose: (e: any) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, import('../../ele-tooltip/props').TooltipEmits, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        bodyStyle: PropType<import('../../ele-app/types').StyleValue>;
+        bg: StringConstructor;
+        arrowBg: StringConstructor;
+        width: (StringConstructor | NumberConstructor)[];
+        isPopover: BooleanConstructor;
+        showAfter: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        hideAfter: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 200;
+        };
+        autoClose: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        effect: {
+            readonly type: PropType<import('element-plus').PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "dark";
+        };
+        ariaLabel: StringConstructor;
+        placement: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        teleported: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        appendTo: {
+            readonly type: PropType<string | HTMLElement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        disabled: BooleanConstructor;
+        offset: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 12;
+        };
+        persistent: BooleanConstructor;
+        zIndex: NumberConstructor;
+        visible: {
+            readonly type: PropType<boolean | null>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: null;
+        };
+        trigger: {
+            readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        triggerKeys: {
+            readonly type: PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        popperOptions: {
+            readonly type: PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        transition: StringConstructor;
+        content: {
+            readonly type: PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        enterable: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        showArrow: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        arrowOffset: {
+            readonly type: PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 5;
+        };
+        virtualRef: {
+            readonly type: PropType<import('element-plus').Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        virtualTriggering: BooleanConstructor;
+        rawContent: BooleanConstructor;
+        gpuAcceleration: {
+            readonly type: PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        className: StringConstructor;
+        popperClass: StringConstructor;
+        popperStyle: PropType<import('../../ele-app/types').StyleValue>;
+    }>> & Readonly<{
+        onClose?: ((e: any) => any) | undefined;
+        onHide?: ((e: Event) => any) | undefined;
+        onOpen?: ((e: any) => any) | undefined;
+        "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+        "onBefore-show"?: ((e: Event) => any) | undefined;
+        "onBefore-hide"?: ((e: Event) => any) | undefined;
+        onShow?: ((e: Event) => any) | undefined;
+    }>, {
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        effect: import('element-plus').PopperEffect;
+        placement: string;
+        teleported: boolean;
+        disabled: boolean;
+        offset: number;
+        persistent: boolean;
+        visible: boolean | null;
+        trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+        triggerKeys: string[];
+        popperOptions: any;
+        content: string;
+        enterable: boolean;
+        showArrow: boolean;
+        arrowOffset: number;
+        virtualTriggering: boolean;
+        rawContent: boolean;
+        gpuAcceleration: boolean;
+        isPopover: boolean;
+    }, {}, {
+        ElTooltip: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                [x: string]: (...args: any[]) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            showArrow: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            arrowOffset: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 5;
+            };
+            disabled: BooleanConstructor;
+            trigger: {
+                readonly type: PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            triggerKeys: {
+                readonly type: PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            virtualRef: {
+                readonly type: PropType<import('element-plus').Measurable>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            virtualTriggering: BooleanConstructor;
+            onMouseenter: {
+                readonly type: PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onMouseleave: {
+                readonly type: PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onClick: {
+                readonly type: PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onKeydown: {
+                readonly type: PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onFocus: {
+                readonly type: PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: {
+                readonly type: PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onContextmenu: {
+                readonly type: PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            id: StringConstructor;
+            open: BooleanConstructor;
+            ariaLabel: StringConstructor;
+            appendTo: {
+                readonly type: PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            content: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            rawContent: BooleanConstructor;
+            persistent: BooleanConstructor;
+            visible: {
+                readonly type: PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            transition: StringConstructor;
+            teleported: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            style: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            className: {
+                readonly type: PropType<string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            effect: {
+                readonly type: PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "dark";
+            };
+            enterable: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            pure: BooleanConstructor;
+            focusOnShow: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            trapping: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            popperClass: {
+                readonly type: PropType<string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            popperStyle: {
+                readonly type: PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            referenceEl: {
+                readonly type: PropType<HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            triggerTargetEl: {
+                readonly type: PropType<HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            stopPopperMouseEvent: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            zIndex: NumberConstructor;
+            boundariesPadding: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            fallbackPlacements: {
+                readonly type: PropType<Placement[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            gpuAcceleration: {
+                readonly type: PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            offset: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 12;
+            };
+            placement: {
+                readonly type: PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            popperOptions: {
+                readonly type: PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            strategy: {
+                readonly type: PropType<"fixed" | "absolute">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "absolute";
+            };
+            showAfter: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            hideAfter: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            autoClose: {
+                readonly type: PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            "onUpdate:visible": {
+                readonly type: PropType<(val: boolean) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            role: {
+                readonly type: PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "tooltip";
+            };
+        }>>, {
+            popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+            contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event) => void;
+            onClose: (event?: Event) => void;
+            hide: (event?: Event) => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            [x: string]: (...args: any[]) => void;
+        }, string, {
+            disabled: boolean;
+            content: string;
+            offset: number;
+            visible: boolean | null;
+            open: boolean;
+            placement: string;
+            strategy: "fixed" | "absolute";
+            effect: import('element-plus').PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+            virtualTriggering: boolean;
+            arrowOffset: number;
+            boundariesPadding: number;
+            fallbackPlacements: Placement[];
+            gpuAcceleration: boolean;
+            popperOptions: Partial<Options>;
+            enterable: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            stopPopperMouseEvent: boolean;
+            pure: boolean;
+            triggerKeys: string[];
+            teleported: boolean;
+            rawContent: boolean;
+            persistent: boolean;
+            showArrow: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+                content?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+    DropdownMenus: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        items: {
+            type: PropType<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>;
+export default _default;