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;