@minto-ai/mt-ui/dist/tooltip/index.d.ts

UI组件库

export declare const MtTooltip: {
    new (...args: any[]): import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('vue').ExtractPropTypes<{
        content: {
            type: StringConstructor;
            default: string;
        };
        placement: {
            type: import('vue').PropType<import('element-plus').Placement>;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        visible: {
            type: import('vue').PropType<boolean | null>;
            default: null;
        };
        offset: {
            type: NumberConstructor;
            default: undefined;
        };
        'onUpdate:visible': {
            type: import('vue').PropType<(visible: boolean) => void>;
        };
        'visible-arrow': {
            type: BooleanConstructor;
            default: boolean;
        };
        'popper-options': {
            type: import('vue').PropType<Partial<import('element-plus').Options>>;
            default: () => {};
        };
        'show-after': {
            type: NumberConstructor;
            default: number;
        };
        'hide-after': {
            type: NumberConstructor;
            default: number;
        };
        'auto-close': {
            type: BooleanConstructor;
            default: boolean;
        };
        'popper-class': {
            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 | {
                [x: string]: boolean;
            } | (string | {
                [x: string]: boolean;
            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]>;
            default: string;
        };
        enterable: {
            type: BooleanConstructor;
            default: boolean;
        };
        effect: {
            type: import('vue').PropType<import('../popover').PopoverEffect>;
            default: string;
        };
        width: {
            type: import('vue').PropType<string>;
            default: string;
        };
    }>> & Readonly<{}>, {
        hide: () => void;
        show: () => void;
    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
        width: string;
        effect: import('../popover').PopoverEffect;
        offset: number;
        visible: boolean | null;
        content: string;
        disabled: boolean;
        placement: import('element-plus').Placement;
        enterable: boolean;
        'visible-arrow': boolean;
        'popper-options': Partial<import('element-plus').Options>;
        'show-after': number;
        'hide-after': number;
        'auto-close': boolean;
        'popper-class': 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 | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
        popoverRef: ({
            $: import('vue').ComponentInternalInstance;
            $data: {};
            $props: Partial<{
                width: string | number;
                effect: import('../popover').PopoverEffect;
                offset: number;
                visible: boolean | null;
                content: string;
                disabled: boolean;
                appendTo: string | HTMLElement;
                trigger: import('../popover').PopoverTriggerType;
                placement: import('element-plus').Placement;
                strategy: "fixed" | "absolute";
                showArrow: boolean;
                popperOptions: Partial<import('element-plus').Options>;
                fallbackPlacements: import('element-plus').Placement[];
                gpuAcceleration: boolean;
                popperClass: 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 | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
                showAfter: number;
                hideAfter: number;
                autoClose: boolean;
                popperStyle: import('vue').StyleValue;
                rawContent: boolean;
                virtualTriggering: boolean;
                virtualRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
                enterable: boolean;
                teleported: boolean;
            }> & Omit<{
                readonly width: string | number;
                readonly effect: import('../popover').PopoverEffect;
                readonly visible: boolean | null;
                readonly content: string;
                readonly disabled: boolean;
                readonly appendTo: string | HTMLElement;
                readonly trigger: import('../popover').PopoverTriggerType;
                readonly placement: import('element-plus').Placement;
                readonly strategy: "fixed" | "absolute";
                readonly showArrow: boolean;
                readonly popperOptions: Partial<import('element-plus').Options>;
                readonly gpuAcceleration: boolean;
                readonly popperClass: 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 | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly autoClose: boolean;
                readonly popperStyle: string | false | import('vue').CSSProperties | import('vue').StyleValue[] | null;
                readonly rawContent: boolean;
                readonly virtualTriggering: boolean;
                readonly virtualRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
                readonly enterable: boolean;
                readonly teleported: boolean;
                readonly offset?: number | undefined;
                readonly zIndex?: number | undefined;
                readonly 'onUpdate:visible'?: (((visible: boolean) => void) & ((args_0: boolean) => any)) | undefined;
                readonly fallbackPlacements?: import('element-plus').Placement[] | undefined;
                readonly onBeforeLeave?: (() => any) | undefined;
                readonly onBeforeEnter?: (() => any) | undefined;
                readonly onHide?: (() => any) | undefined;
                readonly onShow?: (() => any) | undefined;
            } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, "width" | "effect" | "offset" | "visible" | "content" | "disabled" | "appendTo" | "trigger" | "placement" | "strategy" | "showArrow" | "popperOptions" | "fallbackPlacements" | "gpuAcceleration" | "popperClass" | "showAfter" | "hideAfter" | "autoClose" | "popperStyle" | "rawContent" | "virtualTriggering" | "virtualRef" | "enterable" | "teleported">;
            $attrs: {
                [x: string]: unknown;
            };
            $refs: {
                [x: string]: unknown;
            };
            $slots: Readonly<{
                [name: string]: import('vue').Slot<any> | undefined;
            }>;
            $root: import('vue').ComponentPublicInstance | null;
            $parent: import('vue').ComponentPublicInstance | null;
            $host: Element | null;
            $emit: ((event: "beforeLeave") => void) & ((event: "beforeEnter") => void) & ((event: "hide") => void) & ((event: "show") => void) & ((event: "update:visible", args_0: boolean) => void);
            $el: any;
            $options: import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
                trigger: {
                    type: import('vue').PropType<import('../popover').PopoverTriggerType>;
                    default: string;
                };
                content: {
                    type: StringConstructor;
                    default: string;
                };
                width: {
                    type: import('vue').PropType<number | string>;
                    validator: (value: number | string) => boolean;
                    default: number;
                };
                placement: {
                    type: import('vue').PropType<import('element-plus').Placement>;
                    default: string;
                };
                disabled: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                offset: {
                    type: NumberConstructor;
                    default: undefined;
                };
                visible: {
                    type: import('vue').PropType<boolean | null>;
                    default: null;
                };
                'onUpdate:visible': {
                    type: import('vue').PropType<(visible: boolean) => void>;
                };
                showArrow: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popperOptions: {
                    type: import('vue').PropType<Partial<import('element-plus').Options>>;
                    default: () => {};
                };
                strategy: {
                    type: import('vue').PropType<"absolute" | "fixed">;
                    default: string;
                };
                fallbackPlacements: {
                    type: import('vue').PropType<import('element-plus').Placement[]>;
                    default: undefined;
                };
                gpuAcceleration: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popperClass: {
                    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 | {
                        [x: string]: boolean;
                    } | (string | {
                        [x: string]: boolean;
                    } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]>;
                    default: string;
                };
                showAfter: {
                    type: NumberConstructor;
                    default: number;
                };
                hideAfter: {
                    type: NumberConstructor;
                    default: number;
                };
                autoClose: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                popperStyle: {
                    type: import('vue').PropType<import('vue').StyleValue>;
                    default: () => {};
                };
                appendTo: {
                    type: import('vue').PropType<string | HTMLElement>;
                    default: string;
                };
                effect: {
                    type: import('vue').PropType<import('../popover').PopoverEffect>;
                    default: string;
                };
                rawContent: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                virtualTriggering: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                virtualRef: {
                    type: import('vue').PropType<import('vue').Ref<HTMLElement | null>>;
                    default: () => null;
                };
                zIndex: {
                    type: NumberConstructor;
                };
                enterable: {
                    type: BooleanConstructor;
                    default: boolean;
                };
                teleported: {
                    type: BooleanConstructor;
                    default: boolean;
                };
            }>> & Readonly<{
                onBeforeLeave?: (() => any) | undefined;
                onBeforeEnter?: (() => any) | undefined;
                onHide?: (() => any) | undefined;
                onShow?: (() => any) | undefined;
                "onUpdate:visible"?: ((args_0: boolean) => any) | undefined;
            }>, {
                hide: () => void;
                show: () => void;
            }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
                beforeLeave: () => any;
                beforeEnter: () => any;
                hide: () => any;
                show: () => any;
                "update:visible": (args_0: boolean) => any;
            }, string, {
                width: string | number;
                effect: import('../popover').PopoverEffect;
                offset: number;
                visible: boolean | null;
                content: string;
                disabled: boolean;
                appendTo: string | HTMLElement;
                trigger: import('../popover').PopoverTriggerType;
                placement: import('element-plus').Placement;
                strategy: "fixed" | "absolute";
                showArrow: boolean;
                popperOptions: Partial<import('element-plus').Options>;
                fallbackPlacements: import('element-plus').Placement[];
                gpuAcceleration: boolean;
                popperClass: 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 | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
                showAfter: number;
                hideAfter: number;
                autoClose: boolean;
                popperStyle: import('vue').StyleValue;
                rawContent: boolean;
                virtualTriggering: boolean;
                virtualRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
                enterable: boolean;
                teleported: boolean;
            }, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & {
                beforeCreate?: (() => void) | (() => void)[];
                created?: (() => void) | (() => void)[];
                beforeMount?: (() => void) | (() => void)[];
                mounted?: (() => void) | (() => void)[];
                beforeUpdate?: (() => void) | (() => void)[];
                updated?: (() => void) | (() => void)[];
                activated?: (() => void) | (() => void)[];
                deactivated?: (() => void) | (() => void)[];
                beforeDestroy?: (() => void) | (() => void)[];
                beforeUnmount?: (() => void) | (() => void)[];
                destroyed?: (() => void) | (() => void)[];
                unmounted?: (() => void) | (() => void)[];
                renderTracked?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                renderTriggered?: ((e: import('vue').DebuggerEvent) => void) | ((e: import('vue').DebuggerEvent) => void)[];
                errorCaptured?: ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import('vue').ComponentPublicInstance | null, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof import('vue').nextTick;
            $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import('@vue/reactivity').OnCleanup]) => any : (...args: [any, any, import('@vue/reactivity').OnCleanup]) => any, options?: import('vue').WatchOptions): import('vue').WatchStopHandle;
        } & Readonly<{
            width: string | number;
            effect: import('../popover').PopoverEffect;
            offset: number;
            visible: boolean | null;
            content: string;
            disabled: boolean;
            appendTo: string | HTMLElement;
            trigger: import('../popover').PopoverTriggerType;
            placement: import('element-plus').Placement;
            strategy: "fixed" | "absolute";
            showArrow: boolean;
            popperOptions: Partial<import('element-plus').Options>;
            fallbackPlacements: import('element-plus').Placement[];
            gpuAcceleration: boolean;
            popperClass: 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 | {
                [x: string]: boolean;
            } | (string | {
                [x: string]: boolean;
            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
            showAfter: number;
            hideAfter: number;
            autoClose: boolean;
            popperStyle: import('vue').StyleValue;
            rawContent: boolean;
            virtualTriggering: boolean;
            virtualRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
            enterable: boolean;
            teleported: boolean;
        }> & Omit<Readonly<import('vue').ExtractPropTypes<{
            trigger: {
                type: import('vue').PropType<import('../popover').PopoverTriggerType>;
                default: string;
            };
            content: {
                type: StringConstructor;
                default: string;
            };
            width: {
                type: import('vue').PropType<number | string>;
                validator: (value: number | string) => boolean;
                default: number;
            };
            placement: {
                type: import('vue').PropType<import('element-plus').Placement>;
                default: string;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            offset: {
                type: NumberConstructor;
                default: undefined;
            };
            visible: {
                type: import('vue').PropType<boolean | null>;
                default: null;
            };
            'onUpdate:visible': {
                type: import('vue').PropType<(visible: boolean) => void>;
            };
            showArrow: {
                type: BooleanConstructor;
                default: boolean;
            };
            popperOptions: {
                type: import('vue').PropType<Partial<import('element-plus').Options>>;
                default: () => {};
            };
            strategy: {
                type: import('vue').PropType<"absolute" | "fixed">;
                default: string;
            };
            fallbackPlacements: {
                type: import('vue').PropType<import('element-plus').Placement[]>;
                default: undefined;
            };
            gpuAcceleration: {
                type: BooleanConstructor;
                default: boolean;
            };
            popperClass: {
                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 | {
                    [x: string]: boolean;
                } | (string | {
                    [x: string]: boolean;
                } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]>;
                default: string;
            };
            showAfter: {
                type: NumberConstructor;
                default: number;
            };
            hideAfter: {
                type: NumberConstructor;
                default: number;
            };
            autoClose: {
                type: BooleanConstructor;
                default: boolean;
            };
            popperStyle: {
                type: import('vue').PropType<import('vue').StyleValue>;
                default: () => {};
            };
            appendTo: {
                type: import('vue').PropType<string | HTMLElement>;
                default: string;
            };
            effect: {
                type: import('vue').PropType<import('../popover').PopoverEffect>;
                default: string;
            };
            rawContent: {
                type: BooleanConstructor;
                default: boolean;
            };
            virtualTriggering: {
                type: BooleanConstructor;
                default: boolean;
            };
            virtualRef: {
                type: import('vue').PropType<import('vue').Ref<HTMLElement | null>>;
                default: () => null;
            };
            zIndex: {
                type: NumberConstructor;
            };
            enterable: {
                type: BooleanConstructor;
                default: boolean;
            };
            teleported: {
                type: BooleanConstructor;
                default: boolean;
            };
        }>> & Readonly<{
            onBeforeLeave?: (() => any) | undefined;
            onBeforeEnter?: (() => any) | undefined;
            onHide?: (() => any) | undefined;
            onShow?: (() => any) | undefined;
            "onUpdate:visible"?: ((args_0: boolean) => any) | undefined;
        }>, "hide" | "show" | ("width" | "effect" | "offset" | "visible" | "content" | "disabled" | "appendTo" | "trigger" | "placement" | "strategy" | "showArrow" | "popperOptions" | "fallbackPlacements" | "gpuAcceleration" | "popperClass" | "showAfter" | "hideAfter" | "autoClose" | "popperStyle" | "rawContent" | "virtualTriggering" | "virtualRef" | "enterable" | "teleported")> & import('vue').ShallowUnwrapRef<{
            hide: () => void;
            show: () => void;
        }> & {} & import('vue').ComponentCustomProperties & {} & {
            $slots: Readonly<{
                reference: any;
                default: any;
                content: any;
            }> & {
                reference: any;
                default: any;
                content: any;
            };
        }) | null;
    }, any, import('vue').ComponentProvideOptions, {
        P: {};
        B: {};
        D: {};
        C: {};
        M: {};
        Defaults: {};
    }, Readonly<import('vue').ExtractPropTypes<{
        content: {
            type: StringConstructor;
            default: string;
        };
        placement: {
            type: import('vue').PropType<import('element-plus').Placement>;
            default: string;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        visible: {
            type: import('vue').PropType<boolean | null>;
            default: null;
        };
        offset: {
            type: NumberConstructor;
            default: undefined;
        };
        'onUpdate:visible': {
            type: import('vue').PropType<(visible: boolean) => void>;
        };
        'visible-arrow': {
            type: BooleanConstructor;
            default: boolean;
        };
        'popper-options': {
            type: import('vue').PropType<Partial<import('element-plus').Options>>;
            default: () => {};
        };
        'show-after': {
            type: NumberConstructor;
            default: number;
        };
        'hide-after': {
            type: NumberConstructor;
            default: number;
        };
        'auto-close': {
            type: BooleanConstructor;
            default: boolean;
        };
        'popper-class': {
            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 | {
                [x: string]: boolean;
            } | (string | {
                [x: string]: boolean;
            } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]>;
            default: string;
        };
        enterable: {
            type: BooleanConstructor;
            default: boolean;
        };
        effect: {
            type: import('vue').PropType<import('../popover').PopoverEffect>;
            default: string;
        };
        width: {
            type: import('vue').PropType<string>;
            default: string;
        };
    }>> & Readonly<{}>, {
        hide: () => void;
        show: () => void;
    }, {}, {}, {}, {
        width: string;
        effect: import('../popover').PopoverEffect;
        offset: number;
        visible: boolean | null;
        content: string;
        disabled: boolean;
        placement: import('element-plus').Placement;
        enterable: boolean;
        'visible-arrow': boolean;
        'popper-options': Partial<import('element-plus').Options>;
        'show-after': number;
        'hide-after': number;
        'auto-close': boolean;
        'popper-class': 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 | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
    }>;
    __isFragment?: never;
    __isTeleport?: never;
    __isSuspense?: never;
} & import('vue').ComponentOptionsBase<Readonly<import('vue').ExtractPropTypes<{
    content: {
        type: StringConstructor;
        default: string;
    };
    placement: {
        type: import('vue').PropType<import('element-plus').Placement>;
        default: string;
    };
    disabled: {
        type: BooleanConstructor;
        default: boolean;
    };
    visible: {
        type: import('vue').PropType<boolean | null>;
        default: null;
    };
    offset: {
        type: NumberConstructor;
        default: undefined;
    };
    'onUpdate:visible': {
        type: import('vue').PropType<(visible: boolean) => void>;
    };
    'visible-arrow': {
        type: BooleanConstructor;
        default: boolean;
    };
    'popper-options': {
        type: import('vue').PropType<Partial<import('element-plus').Options>>;
        default: () => {};
    };
    'show-after': {
        type: NumberConstructor;
        default: number;
    };
    'hide-after': {
        type: NumberConstructor;
        default: number;
    };
    'auto-close': {
        type: BooleanConstructor;
        default: boolean;
    };
    'popper-class': {
        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 | {
            [x: string]: boolean;
        } | (string | {
            [x: string]: boolean;
        } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[]>;
        default: string;
    };
    enterable: {
        type: BooleanConstructor;
        default: boolean;
    };
    effect: {
        type: import('vue').PropType<import('../popover').PopoverEffect>;
        default: string;
    };
    width: {
        type: import('vue').PropType<string>;
        default: string;
    };
}>> & Readonly<{}>, {
    hide: () => void;
    show: () => void;
}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, {
    width: string;
    effect: import('../popover').PopoverEffect;
    offset: number;
    visible: boolean | null;
    content: string;
    disabled: boolean;
    placement: import('element-plus').Placement;
    enterable: boolean;
    'visible-arrow': boolean;
    'popper-options': Partial<import('element-plus').Options>;
    'show-after': number;
    'hide-after': number;
    'auto-close': boolean;
    'popper-class': 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 | {
        [x: string]: boolean;
    } | (string | {
        [x: string]: boolean;
    } | /*elided*/ any)[])[])[])[])[])[])[])[])[])[])[];
}, {}, string, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, import('vue').ComponentProvideOptions> & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps & (new () => {
    $slots: Readonly<{
        default: any;
        content: any;
    }> & {
        default: any;
        content: any;
    };
}) & import('vue').Plugin;
export default MtTooltip;
export * from './src/tooltip';
export type * from './src/tooltip';