hongluan-ui/lib/components/tooltip/src/tooltip.vue.d.ts

Hongluan Component Library for Vue 3

declare const _default: import("vue").DefineComponent<{
    showArrow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
    arrowOffset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 4, boolean>;
    disabled: BooleanConstructor;
    trigger: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("./trigger").TooltipTriggerType>>, unknown, unknown, "hover", boolean>;
    triggerKeys: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<string[]>, unknown, unknown, () => string[], boolean>;
    virtualRef: {
        readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    virtualTriggering: BooleanConstructor;
    onMouseenter: {
        readonly type: import("vue").PropType<(e: Event) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    onMouseleave: {
        readonly type: import("vue").PropType<(e: Event) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    onClick: {
        readonly type: import("vue").PropType<(e: Event) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    onKeydown: {
        readonly type: import("vue").PropType<(e: Event) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    onFocus: {
        readonly type: import("vue").PropType<(e: Event) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    onBlur: {
        readonly type: import("vue").PropType<(e: Event) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    onContextmenu: {
        readonly type: import("vue").PropType<(e: Event) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    id: StringConstructor;
    open: BooleanConstructor;
    ariaLabel: StringConstructor;
    appendTo: {
        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    content: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    rawContent: BooleanConstructor;
    persistent: BooleanConstructor;
    visible: {
        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<boolean>, unknown, unknown>>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    transition: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "fade", boolean>;
    teleported: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    outsideIgnore: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[]>, unknown, unknown, () => any[], boolean>;
    style: {
        readonly type: import("vue").PropType<unknown>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    className: {
        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<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;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>, unknown, unknown>>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    effect: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<string>, unknown, unknown, "", boolean>;
    enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    pure: BooleanConstructor;
    focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
    popperClass: {
        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<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;
        } | any)[])[])[])[])[])[])[])[])[])[])[]>, unknown, unknown>>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    popperStyle: {
        readonly type: import("vue").PropType<unknown>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    referenceEl: {
        readonly type: import("vue").PropType<HTMLElement>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    triggerTargetEl: {
        readonly type: import("vue").PropType<HTMLElement>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    zIndex: NumberConstructor;
    boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    fallbackPlacements: {
        readonly type: import("vue").PropType<import("hongluan-ui/es/components/popper").Placement[]>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
    placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("hongluan-ui/es/components/popper").Placement, unknown, "bottom", boolean>;
    popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("hongluan-ui/es/components/popper").Options>>, unknown, unknown, () => Partial<import("hongluan-ui/es/components/popper").Options>, boolean>;
    strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
    showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
    autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
    "onUpdate:visible": {
        readonly type: import("vue").PropType<(val: boolean) => void>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
}, {
    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
        showArrow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, boolean, boolean>;
        arrowOffset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 4, boolean>;
        disabled: BooleanConstructor;
        trigger: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("./trigger").TooltipTriggerType>>, unknown, unknown, "hover", boolean>;
        triggerKeys: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<string[]>, unknown, unknown, () => string[], boolean>;
        virtualRef: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        virtualTriggering: BooleanConstructor;
        onMouseenter: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        onMouseleave: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        onClick: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        onKeydown: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        onFocus: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        onBlur: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        onContextmenu: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        id: StringConstructor;
        open: BooleanConstructor;
        ariaLabel: StringConstructor;
        appendTo: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        content: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        rawContent: BooleanConstructor;
        persistent: BooleanConstructor;
        visible: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<boolean>, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        transition: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "fade", boolean>;
        teleported: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        outsideIgnore: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[]>, unknown, unknown, () => any[], boolean>;
        style: {
            readonly type: import("vue").PropType<unknown>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        className: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<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;
            } | any)[])[])[])[])[])[])[])[])[])[])[]>, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        effect: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<string>, unknown, unknown, "", boolean>;
        enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        pure: BooleanConstructor;
        focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
        popperClass: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<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;
            } | any)[])[])[])[])[])[])[])[])[])[])[]>, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        popperStyle: {
            readonly type: import("vue").PropType<unknown>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        referenceEl: {
            readonly type: import("vue").PropType<HTMLElement>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        triggerTargetEl: {
            readonly type: import("vue").PropType<HTMLElement>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        zIndex: NumberConstructor;
        boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        fallbackPlacements: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/components/popper").Placement[]>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
        placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("hongluan-ui/es/components/popper").Placement, unknown, "bottom", boolean>;
        popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("hongluan-ui/es/components/popper").Options>>, unknown, unknown, () => Partial<import("hongluan-ui/es/components/popper").Options>, boolean>;
        strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
        showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
        autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        "onUpdate:visible": {
            readonly type: import("vue").PropType<(val: boolean) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
    }>> & {
        [x: string & `on${string}`]: (...args: any[]) => any;
    }>>;
    emit: (event: string, ...args: any[]) => void;
    id: import("vue").Ref<string>;
    popperRef: import("vue").Ref<{
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            role: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>;
        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
            readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
        }>> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "role">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot;
        }>;
        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
        }>>, {
            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
            }>> & {
                [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
            }>>;
            triggerRef: import("vue").Ref<HTMLElement>;
            popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance>;
            contentRef: import("vue").Ref<HTMLElement>;
            referenceRef: import("vue").Ref<HTMLElement>;
            role: import("vue").ComputedRef<import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>>;
            popperProvides: import("hongluan-ui/es/tokens").PopperInjectionContext;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, {
            role: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>;
        }> & {
            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<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof import("vue").nextTick;
        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
    } & Readonly<import("vue").ExtractPropTypes<{
        readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
    }>> & import("vue").ShallowUnwrapRef<{
        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
        }>> & {
            [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
        }>>;
        triggerRef: import("vue").Ref<HTMLElement>;
        popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance>;
        contentRef: import("vue").Ref<HTMLElement>;
        referenceRef: import("vue").Ref<HTMLElement>;
        role: import("vue").ComputedRef<import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>>;
        popperProvides: import("hongluan-ui/es/tokens").PopperInjectionContext;
    }> & {} & {} & import("vue").ComponentCustomProperties>;
    contentRef: import("vue").Ref<any>;
    updatePopper: () => void;
    open: import("vue").Ref<boolean>;
    toggleReason: import("vue").Ref<Event>;
    show: (event?: Event) => void;
    hide: (event?: Event) => void;
    hasUpdateHandler: import("vue").ComputedRef<boolean>;
    onOpen: (event?: Event) => void;
    onClose: (event?: Event) => void;
    controlled: import("vue").ComputedRef<boolean>;
    isFocusInsideContent: (event?: FocusEvent) => boolean;
    HlPopper: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
        readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
    }, {
        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
        }>> & {
            [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
        }>>;
        triggerRef: import("vue").Ref<HTMLElement>;
        popperInstanceRef: import("vue").Ref<import("@popperjs/core").Instance>;
        contentRef: import("vue").Ref<HTMLElement>;
        referenceRef: import("vue").Ref<HTMLElement>;
        role: import("vue").ComputedRef<import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>>;
        popperProvides: import("hongluan-ui/es/tokens").PopperInjectionContext;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly role: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown, "tooltip", boolean>;
    }>>, {
        role: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>;
    }>> & Record<string, any>;
    HlPopperArrow: import("vue").DefineComponent<{
        readonly arrowOffset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 4, boolean>;
    }, {
        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            readonly arrowOffset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 4, boolean>;
        }>> & {
            [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
        }>>;
        arrowOffset: import("vue").Ref<number>;
        arrowRef: import("vue").Ref<HTMLElement>;
        arrowStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly arrowOffset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 4, boolean>;
    }>>, {
        arrowOffset: number;
    }>;
    HlTooltipTrigger: import("vue").DefineComponent<{
        readonly disabled: BooleanConstructor;
        readonly trigger: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("./trigger").TooltipTriggerType>>, unknown, unknown, "hover", boolean>;
        readonly triggerKeys: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<string[]>, unknown, unknown, () => string[], boolean>;
        readonly virtualRef: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly virtualTriggering: BooleanConstructor;
        readonly onMouseenter: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onMouseleave: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onClick: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onKeydown: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onFocus: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onBlur: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onContextmenu: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly id: StringConstructor;
        readonly open: BooleanConstructor;
    }, {
        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            readonly disabled: BooleanConstructor;
            readonly trigger: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("./trigger").TooltipTriggerType>>, unknown, unknown, "hover", boolean>;
            readonly triggerKeys: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<string[]>, unknown, unknown, () => string[], boolean>;
            readonly virtualRef: {
                readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly virtualTriggering: BooleanConstructor;
            readonly onMouseenter: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onMouseleave: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onClick: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onKeydown: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onFocus: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onBlur: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onContextmenu: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly id: StringConstructor;
            readonly open: BooleanConstructor;
        }>> & {
            [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
        }>>;
        controlled: import("vue").Ref<boolean>;
        id: import("vue").Ref<string>;
        open: import("vue").Ref<boolean>;
        onOpen: (e?: Event) => void;
        onClose: (e?: Event) => void;
        onToggle: (e: Event) => void;
        triggerRef: import("vue").Ref<{
            forwardRef: HTMLElement;
        }>;
        stopWhenControlledOrDisabled: () => boolean;
        trigger: import("vue").Ref<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("./trigger").TooltipTriggerType>>, unknown, unknown>>;
        onMouseenter: (event: Event) => void;
        onMouseleave: (event: Event) => void;
        onClick: (event: Event) => void;
        onFocus: (event: Event) => void;
        onBlur: (event: Event) => void;
        onContextMenu: (event: Event) => void;
        onKeydown: (event: KeyboardEvent) => void;
        HlPopperTrigger: import("vue").DefineComponent<{
            readonly virtualRef: {
                readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly virtualTriggering: BooleanConstructor;
            readonly onMouseenter: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onMouseleave: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onClick: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onKeydown: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onFocus: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onBlur: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onContextmenu: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly id: StringConstructor;
            readonly open: BooleanConstructor;
        }, {
            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                readonly virtualRef: {
                    readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly virtualTriggering: BooleanConstructor;
                readonly onMouseenter: {
                    readonly type: import("vue").PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly onMouseleave: {
                    readonly type: import("vue").PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly onClick: {
                    readonly type: import("vue").PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly onKeydown: {
                    readonly type: import("vue").PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly onFocus: {
                    readonly type: import("vue").PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly onBlur: {
                    readonly type: import("vue").PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly onContextmenu: {
                    readonly type: import("vue").PropType<(e: Event) => void>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly id: StringConstructor;
                readonly open: BooleanConstructor;
            }>> & {
                [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
            }>>;
            role: import("vue").ComputedRef<string>;
            triggerRef: import("vue").Ref<import("hongluan-ui/es/tokens").Measurable>;
            ariaControls: import("vue").ComputedRef<string>;
            ariaDescribedby: import("vue").ComputedRef<string>;
            ariaHaspopup: import("vue").ComputedRef<string>;
            ariaExpanded: import("vue").ComputedRef<string>;
            virtualTriggerAriaStopWatch: import("vue").WatchStopHandle;
            TRIGGER_ELE_EVENTS: readonly ["onMouseenter", "onMouseleave", "onClick", "onKeydown", "onFocus", "onBlur", "onContextmenu"];
            HlOnlyChild: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
                [key: string]: any;
            }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
            readonly virtualRef: {
                readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly virtualTriggering: BooleanConstructor;
            readonly onMouseenter: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onMouseleave: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onClick: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onKeydown: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onFocus: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onBlur: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly onContextmenu: {
                readonly type: import("vue").PropType<(e: Event) => void>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly id: StringConstructor;
            readonly open: BooleanConstructor;
        }>>, {
            virtualTriggering: boolean;
            open: boolean;
        }>;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
        readonly disabled: BooleanConstructor;
        readonly trigger: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("./trigger").TooltipTriggerType>>, unknown, unknown, "hover", boolean>;
        readonly triggerKeys: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<string[]>, unknown, unknown, () => string[], boolean>;
        readonly virtualRef: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/tokens").Measurable>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly virtualTriggering: BooleanConstructor;
        readonly onMouseenter: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onMouseleave: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onClick: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onKeydown: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onFocus: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onBlur: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly onContextmenu: {
            readonly type: import("vue").PropType<(e: Event) => void>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly id: StringConstructor;
        readonly open: BooleanConstructor;
    }>>, {
        disabled: boolean;
        trigger: import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("./trigger").TooltipTriggerType>>, unknown, unknown>;
        virtualTriggering: boolean;
        open: boolean;
        triggerKeys: string[];
    }>;
    HlTooltipContent: import("vue").DefineComponent<{
        readonly ariaLabel: StringConstructor;
        readonly appendTo: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly content: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        readonly rawContent: BooleanConstructor;
        readonly persistent: BooleanConstructor;
        readonly visible: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<boolean>, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly transition: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "fade", boolean>;
        readonly teleported: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        readonly disabled: BooleanConstructor;
        readonly outsideIgnore: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[]>, unknown, unknown, () => any[], boolean>;
        readonly id: StringConstructor;
        readonly style: {
            readonly type: import("vue").PropType<unknown>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly className: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<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;
            } | any)[])[])[])[])[])[])[])[])[])[])[]>, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly effect: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").P