yuang-framework-ui-pc 1.1.44 → 1.1.46

package/lib/ele-avatar-group/index.d.ts

@@ -0,0 +1,1742 @@
+import { StyleValue } from '../ele-app/types';
+import { AvatarItem, AvatarErrorOption } from './types';
+
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    data: {
+        type: import('vue').PropType<AvatarItem[]>;
+        required: boolean;
+    };
+    maxCount: NumberConstructor;
+    shape: import('vue').PropType<import('../ele-app/el').ElAvatarProps["shape"]>;
+    size: import('vue').PropType<import('../ele-app/el').ElAvatarProps["size"]>;
+    itemStyle: import('vue').PropType<StyleValue>;
+    avatarStyle: import('vue').PropType<StyleValue>;
+    moreStyle: import('vue').PropType<StyleValue>;
+    tooltip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    overflowPopover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    overflowPopoverProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    hoverOpen: BooleanConstructor;
+}>, {
+    tooltipContent: import('vue').Ref<string, string>;
+    virtualRef: import('vue').Ref<any, any>;
+    overflowVisible: import('vue').Ref<boolean, boolean>;
+    commonStyle: import('vue').ComputedRef<Partial<import('vue').CSSProperties>>;
+    isOverflow: import('vue').ComputedRef<boolean>;
+    avatarData: import('vue').ComputedRef<AvatarItem[]>;
+    overflowCount: import('vue').ComputedRef<number>;
+    overflowData: import('vue').ComputedRef<AvatarItem[]>;
+    handleItemHover: (item: AvatarItem, e: MouseEvent) => void;
+    handleItemClick: (item: AvatarItem) => void;
+    handleMoreClick: () => void;
+    handleError: (option: AvatarErrorOption) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    itemClick: (_item: AvatarItem) => boolean;
+    moreClick: () => boolean;
+    error: (_option: AvatarErrorOption) => boolean;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    data: {
+        type: import('vue').PropType<AvatarItem[]>;
+        required: boolean;
+    };
+    maxCount: NumberConstructor;
+    shape: import('vue').PropType<import('../ele-app/el').ElAvatarProps["shape"]>;
+    size: import('vue').PropType<import('../ele-app/el').ElAvatarProps["size"]>;
+    itemStyle: import('vue').PropType<StyleValue>;
+    avatarStyle: import('vue').PropType<StyleValue>;
+    moreStyle: import('vue').PropType<StyleValue>;
+    tooltip: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    overflowPopover: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    overflowPopoverProps: import('vue').PropType<import('../ele-app/plus').EleTooltipProps>;
+    hoverOpen: BooleanConstructor;
+}>> & Readonly<{
+    onError?: ((_option: AvatarErrorOption) => any) | undefined;
+    onItemClick?: ((_item: AvatarItem) => any) | undefined;
+    onMoreClick?: (() => any) | undefined;
+}>, {
+    tooltip: boolean;
+    overflowPopover: boolean;
+    hoverOpen: boolean;
+}, {}, {
+    ElAvatar: {
+        new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: import('vue').PropType<number | "" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly shape: {
+                readonly type: import('vue').PropType<"circle" | "square">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "circle";
+            };
+            readonly icon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly src: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly alt: StringConstructor;
+            readonly srcSet: StringConstructor;
+            readonly fit: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "cover";
+            };
+        }>> & {
+            onError?: ((evt: Event) => any) | undefined;
+        }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            error: (evt: Event) => void;
+        }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+            readonly size: number | "" | "small" | "default" | "large";
+            readonly shape: "circle" | "square";
+            readonly src: string;
+            readonly fit: any;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('vue').ExtractPropTypes<{
+            readonly size: {
+                readonly type: import('vue').PropType<number | "" | "small" | "default" | "large">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly shape: {
+                readonly type: import('vue').PropType<"circle" | "square">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "circle";
+            };
+            readonly icon: {
+                readonly type: import('vue').PropType<string | import('vue').Component>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            readonly src: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            readonly alt: StringConstructor;
+            readonly srcSet: StringConstructor;
+            readonly fit: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "cover";
+            };
+        }>> & {
+            onError?: ((evt: Event) => any) | undefined;
+        }, {}, {}, {}, {}, {
+            readonly size: number | "" | "small" | "default" | "large";
+            readonly shape: "circle" | "square";
+            readonly src: string;
+            readonly fit: any;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+        readonly size: {
+            readonly type: import('vue').PropType<number | "" | "small" | "default" | "large">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly shape: {
+            readonly type: import('vue').PropType<"circle" | "square">;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "circle";
+        };
+        readonly icon: {
+            readonly type: import('vue').PropType<string | import('vue').Component>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        readonly src: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        readonly alt: StringConstructor;
+        readonly srcSet: StringConstructor;
+        readonly fit: {
+            readonly type: import('vue').PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "cover";
+        };
+    }>> & {
+        onError?: ((evt: Event) => any) | undefined;
+    }, {}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        error: (evt: Event) => void;
+    }, string, {
+        readonly size: number | "" | "small" | "default" | "large";
+        readonly shape: "circle" | "square";
+        readonly src: string;
+        readonly fit: any;
+    }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+        $slots: {
+            default?(_: {}): any;
+        };
+    }) & import('vue').Plugin;
+    EleTooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+        bodyStyle: import('vue').PropType<StyleValue>;
+        bg: StringConstructor;
+        arrowBg: StringConstructor;
+        width: (StringConstructor | NumberConstructor)[];
+        isPopover: BooleanConstructor;
+        showAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        hideAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 200;
+        };
+        autoClose: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        effect: {
+            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "dark";
+        };
+        ariaLabel: StringConstructor;
+        placement: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        teleported: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        appendTo: {
+            readonly type: import('vue').PropType<string | HTMLElement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        disabled: BooleanConstructor;
+        offset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 12;
+        };
+        persistent: BooleanConstructor;
+        zIndex: NumberConstructor;
+        visible: {
+            readonly type: import('vue').PropType<boolean | null>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: null;
+        };
+        trigger: {
+            readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        triggerKeys: {
+            readonly type: import('vue').PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        popperOptions: {
+            readonly type: import('vue').PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        transition: StringConstructor;
+        content: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        enterable: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        showArrow: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        arrowOffset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 5;
+        };
+        virtualRef: {
+            readonly type: import('vue').PropType<import('element-plus').Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        virtualTriggering: BooleanConstructor;
+        rawContent: BooleanConstructor;
+        gpuAcceleration: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        className: StringConstructor;
+        popperClass: StringConstructor;
+        popperStyle: import('vue').PropType<StyleValue>;
+    }>, {
+        tooltipRef: import('vue').Ref<import('../ele-app/el').ElTooltipInstance | undefined, import('../ele-app/el').ElTooltipInstance | undefined>;
+        rootProps: import('vue').ComputedRef<Partial<import('element-plus').ElTooltipProps>>;
+        popperRef: import('vue').ComputedRef<import('../ele-app/el').ElPopperInstance>;
+        contentRef: import('vue').ComputedRef<import('element-plus').TooltipContentInstance | undefined>;
+        isFocusInsideContent: () => void;
+        updatePopper: () => void;
+        handleOpen: (opt?: Event) => void;
+        handleClose: (opt?: Event) => void;
+        hide: (opt?: Event) => void;
+        handleUpdateVisible: (visible: boolean) => void;
+        handlePopBeforeShow: (e: Event) => void;
+        handlePopBeforeHide: (e: Event) => void;
+        handlePopShow: (e: Event) => void;
+        handlePopHide: (e: Event) => void;
+        handlePopOpen: (e: any) => void;
+        handlePopClose: (e: any) => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, import('../ele-tooltip/props').TooltipEmits, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+        bodyStyle: import('vue').PropType<StyleValue>;
+        bg: StringConstructor;
+        arrowBg: StringConstructor;
+        width: (StringConstructor | NumberConstructor)[];
+        isPopover: BooleanConstructor;
+        showAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        hideAfter: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 200;
+        };
+        autoClose: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 0;
+        };
+        effect: {
+            readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "dark";
+        };
+        ariaLabel: StringConstructor;
+        placement: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "bottom";
+        };
+        teleported: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        appendTo: {
+            readonly type: import('vue').PropType<string | HTMLElement>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        disabled: BooleanConstructor;
+        offset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 12;
+        };
+        persistent: BooleanConstructor;
+        zIndex: NumberConstructor;
+        visible: {
+            readonly type: import('vue').PropType<boolean | null>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: null;
+        };
+        trigger: {
+            readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "hover";
+        };
+        triggerKeys: {
+            readonly type: import('vue').PropType<string[]>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => string[];
+        };
+        popperOptions: {
+            readonly type: import('vue').PropType<any>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: () => {};
+        };
+        transition: StringConstructor;
+        content: {
+            readonly type: import('vue').PropType<string>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: "";
+        };
+        enterable: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        showArrow: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: boolean;
+        };
+        arrowOffset: {
+            readonly type: import('vue').PropType<number>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: 5;
+        };
+        virtualRef: {
+            readonly type: import('vue').PropType<import('element-plus').Measurable>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        };
+        virtualTriggering: BooleanConstructor;
+        rawContent: BooleanConstructor;
+        gpuAcceleration: {
+            readonly type: import('vue').PropType<boolean>;
+            readonly required: false;
+            readonly validator: ((val: unknown) => boolean) | undefined;
+            __epPropKey: true;
+        } & {
+            readonly default: true;
+        };
+        className: StringConstructor;
+        popperClass: StringConstructor;
+        popperStyle: import('vue').PropType<StyleValue>;
+    }>> & Readonly<{
+        onClose?: ((e: any) => any) | undefined;
+        onHide?: ((e: Event) => any) | undefined;
+        onOpen?: ((e: any) => any) | undefined;
+        "onUpdate:visible"?: ((visible: boolean) => any) | undefined;
+        "onBefore-show"?: ((e: Event) => any) | undefined;
+        "onBefore-hide"?: ((e: Event) => any) | undefined;
+        onShow?: ((e: Event) => any) | undefined;
+    }>, {
+        showAfter: number;
+        hideAfter: number;
+        autoClose: number;
+        effect: import('element-plus').PopperEffect;
+        placement: string;
+        teleported: boolean;
+        disabled: boolean;
+        offset: number;
+        persistent: boolean;
+        visible: boolean | null;
+        trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+        triggerKeys: string[];
+        popperOptions: any;
+        content: string;
+        enterable: boolean;
+        showArrow: boolean;
+        arrowOffset: number;
+        virtualTriggering: boolean;
+        rawContent: boolean;
+        gpuAcceleration: boolean;
+        isPopover: boolean;
+    }, {}, {
+        ElTooltip: {
+            new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: import('vue').PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: import('vue').PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: import('vue').PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: import('vue').PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: import('vue').PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: import('vue').PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+                [x: string]: (...args: any[]) => void;
+            }, import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {}, any, import('vue').ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import('vue').ExtractPropTypes<{
+                showArrow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: boolean;
+                };
+                arrowOffset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 5;
+                };
+                disabled: BooleanConstructor;
+                trigger: {
+                    readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "hover";
+                };
+                triggerKeys: {
+                    readonly type: import('vue').PropType<string[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => string[];
+                };
+                virtualRef: {
+                    readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                virtualTriggering: BooleanConstructor;
+                onMouseenter: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onMouseleave: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onClick: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onKeydown: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onFocus: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onBlur: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                onContextmenu: {
+                    readonly type: import('vue').PropType<(e: Event) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                id: StringConstructor;
+                open: BooleanConstructor;
+                ariaLabel: StringConstructor;
+                appendTo: {
+                    readonly type: import('vue').PropType<string | HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                content: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "";
+                };
+                rawContent: BooleanConstructor;
+                persistent: BooleanConstructor;
+                visible: {
+                    readonly type: import('vue').PropType<boolean | null>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: null;
+                };
+                transition: StringConstructor;
+                teleported: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                style: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                className: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                effect: {
+                    readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "dark";
+                };
+                enterable: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                pure: BooleanConstructor;
+                focusOnShow: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                trapping: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: false;
+                };
+                popperClass: {
+                    readonly type: import('vue').PropType<string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | {
+                        [x: string]: boolean;
+                    } | (string | any[] | {
+                        [x: string]: boolean;
+                    })[])[])[])[])[])[])[])[])[])[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                popperStyle: {
+                    readonly type: import('vue').PropType<import('vue').StyleValue>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                referenceEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                triggerTargetEl: {
+                    readonly type: import('vue').PropType<HTMLElement>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                stopPopperMouseEvent: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                zIndex: NumberConstructor;
+                boundariesPadding: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                fallbackPlacements: {
+                    readonly type: import('vue').PropType<Placement[]>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: undefined;
+                };
+                gpuAcceleration: {
+                    readonly type: import('vue').PropType<boolean>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: true;
+                };
+                offset: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 12;
+                };
+                placement: {
+                    readonly type: import('vue').PropType<string>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "bottom";
+                };
+                popperOptions: {
+                    readonly type: import('vue').PropType<any>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: () => {};
+                };
+                strategy: {
+                    readonly type: import('vue').PropType<"fixed" | "absolute">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "absolute";
+                };
+                showAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                hideAfter: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 200;
+                };
+                autoClose: {
+                    readonly type: import('vue').PropType<number>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: 0;
+                };
+                "onUpdate:visible": {
+                    readonly type: import('vue').PropType<(val: boolean) => void>;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                };
+                role: {
+                    readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                    readonly required: false;
+                    readonly validator: ((val: unknown) => boolean) | undefined;
+                    __epPropKey: true;
+                } & {
+                    readonly default: "tooltip";
+                };
+            }>>, {
+                popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+                contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+                isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+                updatePopper: () => void;
+                onOpen: (event?: Event) => void;
+                onClose: (event?: Event) => void;
+                hide: (event?: Event) => void;
+            }, {}, {}, {}, {
+                disabled: boolean;
+                content: string;
+                offset: number;
+                visible: boolean | null;
+                open: boolean;
+                placement: string;
+                strategy: "fixed" | "absolute";
+                effect: import('element-plus').PopperEffect;
+                showAfter: number;
+                hideAfter: number;
+                autoClose: number;
+                trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+                role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+                virtualTriggering: boolean;
+                arrowOffset: number;
+                boundariesPadding: number;
+                fallbackPlacements: Placement[];
+                gpuAcceleration: boolean;
+                popperOptions: Partial<Options>;
+                enterable: boolean;
+                focusOnShow: boolean;
+                trapping: boolean;
+                stopPopperMouseEvent: boolean;
+                pure: boolean;
+                triggerKeys: string[];
+                teleported: boolean;
+                rawContent: boolean;
+                persistent: boolean;
+                showArrow: boolean;
+            }>;
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
+            showArrow: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: boolean;
+            };
+            arrowOffset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 5;
+            };
+            disabled: BooleanConstructor;
+            trigger: {
+                readonly type: import('vue').PropType<import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "hover";
+            };
+            triggerKeys: {
+                readonly type: import('vue').PropType<string[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => string[];
+            };
+            virtualRef: {
+                readonly type: import('vue').PropType<import('element-plus').Measurable>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            virtualTriggering: BooleanConstructor;
+            onMouseenter: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onMouseleave: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onClick: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onKeydown: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onFocus: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onBlur: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            onContextmenu: {
+                readonly type: import('vue').PropType<(e: Event) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            id: StringConstructor;
+            open: BooleanConstructor;
+            ariaLabel: StringConstructor;
+            appendTo: {
+                readonly type: import('vue').PropType<string | HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            content: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "";
+            };
+            rawContent: BooleanConstructor;
+            persistent: BooleanConstructor;
+            visible: {
+                readonly type: import('vue').PropType<boolean | null>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: null;
+            };
+            transition: StringConstructor;
+            teleported: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            style: {
+                readonly type: import('vue').PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            className: {
+                readonly type: import('vue').PropType<string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            effect: {
+                readonly type: import('vue').PropType<import('element-plus').PopperEffect>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "dark";
+            };
+            enterable: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            pure: BooleanConstructor;
+            focusOnShow: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            trapping: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: false;
+            };
+            popperClass: {
+                readonly type: import('vue').PropType<string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | {
+                    [x: string]: boolean;
+                } | (string | any[] | {
+                    [x: string]: boolean;
+                })[])[])[])[])[])[])[])[])[])[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            popperStyle: {
+                readonly type: import('vue').PropType<import('vue').StyleValue>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            referenceEl: {
+                readonly type: import('vue').PropType<HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            triggerTargetEl: {
+                readonly type: import('vue').PropType<HTMLElement>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            stopPopperMouseEvent: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            zIndex: NumberConstructor;
+            boundariesPadding: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            fallbackPlacements: {
+                readonly type: import('vue').PropType<Placement[]>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: undefined;
+            };
+            gpuAcceleration: {
+                readonly type: import('vue').PropType<boolean>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: true;
+            };
+            offset: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 12;
+            };
+            placement: {
+                readonly type: import('vue').PropType<string>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "bottom";
+            };
+            popperOptions: {
+                readonly type: import('vue').PropType<any>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: () => {};
+            };
+            strategy: {
+                readonly type: import('vue').PropType<"fixed" | "absolute">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "absolute";
+            };
+            showAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            hideAfter: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 200;
+            };
+            autoClose: {
+                readonly type: import('vue').PropType<number>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: 0;
+            };
+            "onUpdate:visible": {
+                readonly type: import('vue').PropType<(val: boolean) => void>;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            };
+            role: {
+                readonly type: import('vue').PropType<"dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation">;
+                readonly required: false;
+                readonly validator: ((val: unknown) => boolean) | undefined;
+                __epPropKey: true;
+            } & {
+                readonly default: "tooltip";
+            };
+        }>>, {
+            popperRef: import('vue').Ref<import('element-plus').PopperInstance | undefined>;
+            contentRef: import('vue').Ref<import('element-plus').TooltipContentInstance | undefined>;
+            isFocusInsideContent: (event?: FocusEvent) => boolean | undefined;
+            updatePopper: () => void;
+            onOpen: (event?: Event) => void;
+            onClose: (event?: Event) => void;
+            hide: (event?: Event) => void;
+        }, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+            [x: string]: (...args: any[]) => void;
+        }, string, {
+            disabled: boolean;
+            content: string;
+            offset: number;
+            visible: boolean | null;
+            open: boolean;
+            placement: string;
+            strategy: "fixed" | "absolute";
+            effect: import('element-plus').PopperEffect;
+            showAfter: number;
+            hideAfter: number;
+            autoClose: number;
+            trigger: import('element-plus').TooltipTriggerType | import('element-plus').TooltipTriggerType[];
+            role: "dialog" | "menu" | "grid" | "listbox" | "tooltip" | "tree" | "group" | "navigation";
+            virtualTriggering: boolean;
+            arrowOffset: number;
+            boundariesPadding: number;
+            fallbackPlacements: Placement[];
+            gpuAcceleration: boolean;
+            popperOptions: Partial<Options>;
+            enterable: boolean;
+            focusOnShow: boolean;
+            trapping: boolean;
+            stopPopperMouseEvent: boolean;
+            pure: boolean;
+            triggerKeys: string[];
+            teleported: boolean;
+            rawContent: boolean;
+            persistent: boolean;
+            showArrow: boolean;
+        }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
+            $slots: {
+                default?(_: {}): any;
+                content?(_: {}): any;
+            };
+        }) & import('vue').Plugin;
+    }, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;