import { nextTick } from 'vue';
import type { ComponentPublicInstance, SetupContext } from 'vue';
import type { SelectOptionProxy, QueryChangeCtx } from './token';
export declare function useSelectStates(props: any): {
    options: Map<any, any>;
    cachedOptions: Map<any, any>;
    disabledOptions: Map<any, any>;
    createdLabel: any;
    createdSelected: boolean;
    selected: any;
    initialInputHeight: number;
    optionsCount: number;
    filteredOptionsCount: number;
    visible: boolean;
    selectedLabel: string;
    hoverIndex: number;
    query: string;
    previousQuery: string;
    inputHovering: boolean;
    cachedPlaceHolder: string | (() => string);
    currentPlaceholder: string | (() => string);
    menuVisibleOnFocus: boolean;
    isOnComposition: boolean;
    prefixWidth: any;
    tagInMultiLine: boolean;
    mouseEnter: boolean;
    focused: boolean;
};
declare type States = ReturnType<typeof useSelectStates>;
export declare const useSelect: (props: any, states: States, ctx: SetupContext<any>) => {
    optionList: import("vue").Ref<string[]>;
    optionsArray: import("vue").ComputedRef<any[]>;
    hoverOption: import("vue").Ref<any>;
    selectSize: import("vue").ComputedRef<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
    handleResize: () => void;
    debouncedOnInputChange: import("lodash").DebouncedFunc<() => void>;
    debouncedQueryChange: import("lodash").DebouncedFunc<(e: any) => void>;
    deletePrevTag: (e: KeyboardEvent) => void;
    deleteTag: (event: Event, tag: any) => void;
    deleteSelected: (event: Event) => void;
    handleOptionSelect: (option: any) => void;
    scrollToOption: (option: any) => void;
    readonly: import("vue").ComputedRef<boolean>;
    resetInputHeight: () => void;
    showClose: import("vue").ComputedRef<boolean>;
    iconClass: import("vue").ComputedRef<"select-caret is-open" | "select-caret">;
    showIcon: import("vue").ComputedRef<boolean>;
    showNewOption: import("vue").ComputedRef<boolean>;
    setSelected: () => void;
    managePlaceholder: () => void;
    selectDisabled: import("vue").ComputedRef<boolean>;
    selectFill: import("vue").ComputedRef<boolean>;
    emptyText: import("vue").ComputedRef<any>;
    toggleLastOptionHitState: (hit?: boolean) => any;
    resetInputState: (e: KeyboardEvent) => void;
    handleComposition: (event: Event) => void;
    onOptionCreate: (vm: SelectOptionProxy) => void;
    onOptionDestroy: (key: any, vm: SelectOptionProxy) => void;
    handleMenuEnter: () => void;
    handleFocus: (event: FocusEvent) => void;
    blur: () => void;
    focus: () => void;
    handleBlur: (event: FocusEvent) => void;
    handleClearClick: (event: Event) => void;
    handleClose: () => void;
    toggleMenu: (e?: PointerEvent) => void;
    handleKeydownEscape: (event: KeyboardEvent) => void;
    selectOption: () => void;
    getValueKey: (item: any) => any;
    navigateOptions: (direction: string) => void;
    handleDeleteTooltipTag: (event: Event, tag: any) => void;
    dropMenuVisible: import("vue").WritableComputedRef<boolean>;
    queryChange: import("vue").ShallowRef<QueryChangeCtx>;
    groupQueryChange: import("vue").ShallowRef<string>;
    showTagList: import("vue").ComputedRef<any>;
    collapseTagList: import("vue").ComputedRef<any>;
    reference: import("vue").Ref<ComponentPublicInstance<{
        focus: () => void;
        blur: () => void;
        input: HTMLInputElement;
    }, {}, {}, {}, {}, {}, {
        focus: () => void;
        blur: () => void;
        input: HTMLInputElement;
    }, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>>;
    input: import("vue").Ref<HTMLInputElement>;
    tooltipRef: import("vue").Ref<{
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            disabled: boolean;
            trigger: import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>, unknown, unknown>;
            offset: number;
            placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
            transition: string;
            effect: string;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            boundariesPadding: number;
            gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            popperOptions: Partial<import("@popperjs/core").Options>;
            strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
            enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            pure: boolean;
            virtualTriggering: boolean;
            content: string;
            teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
            rawContent: boolean;
            persistent: boolean;
            open: boolean;
            role: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>;
            triggerKeys: string[];
            arrowOffset: number;
            showArrow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        }> & Omit<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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
            popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "trigger" | "offset" | "placement" | "transition" | "effect" | "showAfter" | "hideAfter" | "autoClose" | "boundariesPadding" | "gpuAcceleration" | "popperOptions" | "strategy" | "enterable" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "pure" | "virtualTriggering" | "content" | "teleported" | "outsideIgnore" | "rawContent" | "persistent" | "open" | "role" | "triggerKeys" | "arrowOffset" | "showArrow">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot;
        }>;
        $root: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $parent: 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<{
            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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
            popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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;
        }, {
            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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
                popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
                $parent: 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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof 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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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").PropType<string>, unknown, unknown, "", boolean>;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            }, {
                props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                    readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                    readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                }>> & {
                    [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
                }>>;
                selector: import("vue").ComputedRef<string>;
                contentRef: any;
                stopHandle: () => void;
                controlled: import("vue").Ref<boolean>;
                id: import("vue").Ref<string>;
                open: import("vue").Ref<boolean>;
                trigger: import("vue").Ref<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>;
                onClose: (e?: Event) => void;
                onOpen: (e?: Event) => void;
                onShow: () => void;
                onHide: () => void;
                onBeforeShow: () => void;
                onBeforeHide: () => void;
                persistentRef: import("vue").ComputedRef<boolean>;
                shouldRender: import("vue").ComputedRef<boolean>;
                shouldShow: import("vue").ComputedRef<boolean>;
                appendTo: import("vue").ComputedRef<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                contentStyle: import("vue").ComputedRef<any>;
                ariaHidden: import("vue").ComputedRef<boolean>;
                onTransitionLeave: () => void;
                stopWhenControlled: () => boolean;
                onContentEnter: (event: unknown) => void;
                onContentLeave: (event: unknown) => void;
                onBeforeEnter: () => void;
                onBeforeLeave: () => void;
                onAfterShow: () => void;
                onBlur: () => void;
                HlTeleport: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
                    readonly to: {
                        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                        readonly required: true;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }, {
                    COMPONENT_NAME: string;
                }, 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 to: {
                        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                        readonly required: true;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }>>, {
                    disabled: boolean;
                }>> & Record<string, any>;
                HlPopperContent: import("vue").DefineComponent<{
                    readonly ariaLabel: StringConstructor;
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly visible: BooleanConstructor;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                }, {
                    emit: ((event: "blur") => void) & ((event: "focus") => void) & ((event: "close") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
                    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                        readonly ariaLabel: StringConstructor;
                        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").PropType<string>, unknown, unknown, "", boolean>;
                        readonly visible: BooleanConstructor;
                        readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        readonly pure: BooleanConstructor;
                        readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        readonly 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;
                        };
                        readonly popperStyle: {
                            readonly type: import("vue").PropType<unknown>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly referenceEl: {
                            readonly type: import("vue").PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly triggerTargetEl: {
                            readonly type: import("vue").PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        readonly virtualTriggering: BooleanConstructor;
                        readonly zIndex: NumberConstructor;
                        readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        readonly fallbackPlacements: {
                            readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                        readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                        readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                        readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                    }>> & {
                        onClose?: () => any;
                        onBlur?: () => any;
                        onFocus?: () => any;
                        onMouseleave?: (evt: MouseEvent) => any;
                        onMouseenter?: (evt: MouseEvent) => any;
                    }>>;
                    focusStartRef: import("vue").Ref<HTMLElement | "first" | "container">;
                    trapped: import("vue").Ref<boolean>;
                    onFocusAfterReleased: (event: CustomEvent<any>) => void;
                    onFocusAfterTrapped: () => void;
                    onFocusInTrap: (event: FocusEvent) => void;
                    onFocusoutPrevented: (event: CustomEvent<any>) => void;
                    onReleaseRequested: () => void;
                    attributes: import("vue").ComputedRef<{
                        [x: string]: {
                            [x: string]: string | boolean;
                        };
                    }>;
                    arrowRef: import("vue").Ref<HTMLElement>;
                    contentRef: import("vue").Ref<HTMLElement>;
                    styles: import("vue").ComputedRef<{
                        [x: string]: {
                            [x: number]: string;
                            accentColor?: string;
                            alignContent?: string;
                            alignItems?: string;
                            alignSelf?: string;
                            alignmentBaseline?: string;
                            all?: string;
                            animation?: string;
                            animationDelay?: string;
                            animationDirection?: string;
                            animationDuration?: string;
                            animationFillMode?: string;
                            animationIterationCount?: string;
                            animationName?: string;
                            animationPlayState?: string;
                            animationTimingFunction?: string;
                            appearance?: string;
                            aspectRatio?: string;
                            backfaceVisibility?: string;
                            background?: string;
                            backgroundAttachment?: string;
                            backgroundBlendMode?: string;
                            backgroundClip?: string;
                            backgroundColor?: string;
                            backgroundImage?: string;
                            backgroundOrigin?: string;
                            backgroundPosition?: string;
                            backgroundPositionX?: string;
                            backgroundPositionY?: string;
                            backgroundRepeat?: string;
                            backgroundSize?: string;
                            baselineShift?: string;
                            blockSize?: string;
                            border?: string;
                            borderBlock?: string;
                            borderBlockColor?: string;
                            borderBlockEnd?: string;
                            borderBlockEndColor?: string;
                            borderBlockEndStyle?: string;
                            borderBlockEndWidth?: string;
                            borderBlockStart?: string;
                            borderBlockStartColor?: string;
                            borderBlockStartStyle?: string;
                            borderBlockStartWidth?: string;
                            borderBlockStyle?: string;
                            borderBlockWidth?: string;
                            borderBottom?: string;
                            borderBottomColor?: string;
                            borderBottomLeftRadius?: string;
                            borderBottomRightRadius?: string;
                            borderBottomStyle?: string;
                            borderBottomWidth?: string;
                            borderCollapse?: string;
                            borderColor?: string;
                            borderEndEndRadius?: string;
                            borderEndStartRadius?: string;
                            borderImage?: string;
                            borderImageOutset?: string;
                            borderImageRepeat?: string;
                            borderImageSlice?: string;
                            borderImageSource?: string;
                            borderImageWidth?: string;
                            borderInline?: string;
                            borderInlineColor?: string;
                            borderInlineEnd?: string;
                            borderInlineEndColor?: string;
                            borderInlineEndStyle?: string;
                            borderInlineEndWidth?: string;
                            borderInlineStart?: string;
                            borderInlineStartColor?: string;
                            borderInlineStartStyle?: string;
                            borderInlineStartWidth?: string;
                            borderInlineStyle?: string;
                            borderInlineWidth?: string;
                            borderLeft?: string;
                            borderLeftColor?: string;
                            borderLeftStyle?: string;
                            borderLeftWidth?: string;
                            borderRadius?: string;
                            borderRight?: string;
                            borderRightColor?: string;
                            borderRightStyle?: string;
                            borderRightWidth?: string;
                            borderSpacing?: string;
                            borderStartEndRadius?: string;
                            borderStartStartRadius?: string;
                            borderStyle?: string;
                            borderTop?: string;
                            borderTopColor?: string;
                            borderTopLeftRadius?: string;
                            borderTopRightRadius?: string;
                            borderTopStyle?: string;
                            borderTopWidth?: string;
                            borderWidth?: string;
                            bottom?: string;
                            boxShadow?: string;
                            boxSizing?: string;
                            breakAfter?: string;
                            breakBefore?: string;
                            breakInside?: string;
                            captionSide?: string;
                            caretColor?: string;
                            clear?: string;
                            clip?: string;
                            clipPath?: string;
                            clipRule?: string;
                            color?: string;
                            colorInterpolation?: string;
                            colorInterpolationFilters?: string;
                            colorScheme?: string;
                            columnCount?: string;
                            columnFill?: string;
                            columnGap?: string;
                            columnRule?: string;
                            columnRuleColor?: string;
                            columnRuleStyle?: string;
                            columnRuleWidth?: string;
                            columnSpan?: string;
                            columnWidth?: string;
                            columns?: string;
                            contain?: string;
                            content?: string;
                            counterIncrement?: string;
                            counterReset?: string;
                            counterSet?: string;
                            cssFloat?: string;
                            cssText?: string;
                            cursor?: string;
                            direction?: string;
                            display?: string;
                            dominantBaseline?: string;
                            emptyCells?: string;
                            fill?: string;
                            fillOpacity?: string;
                            fillRule?: string;
                            filter?: string;
                            flex?: string;
                            flexBasis?: string;
                            flexDirection?: string;
                            flexFlow?: string;
                            flexGrow?: string;
                            flexShrink?: string;
                            flexWrap?: string;
                            float?: string;
                            floodColor?: string;
                            floodOpacity?: string;
                            font?: string;
                            fontFamily?: string;
                            fontFeatureSettings?: string;
                            fontKerning?: string;
                            fontOpticalSizing?: string;
                            fontSize?: string;
                            fontSizeAdjust?: string;
                            fontStretch?: string;
                            fontStyle?: string;
                            fontSynthesis?: string;
                            fontVariant?: string;
                            fontVariantAlternates?: string;
                            fontVariantCaps?: string;
                            fontVariantEastAsian?: string;
                            fontVariantLigatures?: string;
                            fontVariantNumeric?: string;
                            fontVariantPosition?: string;
                            fontVariationSettings?: string;
                            fontWeight?: string;
                            gap?: string;
                            grid?: string;
                            gridArea?: string;
                            gridAutoColumns?: string;
                            gridAutoFlow?: string;
                            gridAutoRows?: string;
                            gridColumn?: string;
                            gridColumnEnd?: string;
                            gridColumnGap?: string;
                            gridColumnStart?: string;
                            gridGap?: string;
                            gridRow?: string;
                            gridRowEnd?: string;
                            gridRowGap?: string;
                            gridRowStart?: string;
                            gridTemplate?: string;
                            gridTemplateAreas?: string;
                            gridTemplateColumns?: string;
                            gridTemplateRows?: string;
                            height?: string;
                            hyphens?: string;
                            imageOrientation?: string;
                            imageRendering?: string;
                            inlineSize?: string;
                            inset?: string;
                            insetBlock?: string;
                            insetBlockEnd?: string;
                            insetBlockStart?: string;
                            insetInline?: string;
                            insetInlineEnd?: string;
                            insetInlineStart?: string;
                            isolation?: string;
                            justifyContent?: string;
                            justifyItems?: string;
                            justifySelf?: string;
                            left?: string;
                            readonly length?: number;
                            letterSpacing?: string;
                            lightingColor?: string;
                            lineBreak?: string;
                            lineHeight?: string;
                            listStyle?: string;
                            listStyleImage?: string;
                            listStylePosition?: string;
                            listStyleType?: string;
                            margin?: string;
                            marginBlock?: string;
                            marginBlockEnd?: string;
                            marginBlockStart?: string;
                            marginBottom?: string;
                            marginInline?: string;
                            marginInlineEnd?: string;
                            marginInlineStart?: string;
                            marginLeft?: string;
                            marginRight?: string;
                            marginTop?: string;
                            marker?: string;
                            markerEnd?: string;
                            markerMid?: string;
                            markerStart?: string;
                            mask?: string;
                            maskType?: string;
                            maxBlockSize?: string;
                            maxHeight?: string;
                            maxInlineSize?: string;
                            maxWidth?: string;
                            minBlockSize?: string;
                            minHeight?: string;
                            minInlineSize?: string;
                            minWidth?: string;
                            mixBlendMode?: string;
                            objectFit?: string;
                            objectPosition?: string;
                            offset?: string;
                            offsetAnchor?: string;
                            offsetDistance?: string;
                            offsetPath?: string;
                            offsetRotate?: string;
                            opacity?: string;
                            order?: string;
                            orphans?: string;
                            outline?: string;
                            outlineColor?: string;
                            outlineOffset?: string;
                            outlineStyle?: string;
                            outlineWidth?: string;
                            overflow?: string;
                            overflowAnchor?: string;
                            overflowWrap?: string;
                            overflowX?: string;
                            overflowY?: string;
                            overscrollBehavior?: string;
                            overscrollBehaviorBlock?: string;
                            overscrollBehaviorInline?: string;
                            overscrollBehaviorX?: string;
                            overscrollBehaviorY?: string;
                            padding?: string;
                            paddingBlock?: string;
                            paddingBlockEnd?: string;
                            paddingBlockStart?: string;
                            paddingBottom?: string;
                            paddingInline?: string;
                            paddingInlineEnd?: string;
                            paddingInlineStart?: string;
                            paddingLeft?: string;
                            paddingRight?: string;
                            paddingTop?: string;
                            pageBreakAfter?: string;
                            pageBreakBefore?: string;
                            pageBreakInside?: string;
                            paintOrder?: string;
                            readonly parentRule?: {
                                cssText: string;
                                readonly parentRule: any;
                                readonly parentStyleSheet: {
                                    readonly cssRules: {
                                        [x: number]: any;
                                        readonly length: number;
                                        item: (index: number) => CSSRule;
                                        [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                    };
                                    readonly ownerRule: any;
                                    readonly rules: {
                                        [x: number]: any;
                                        readonly length: number;
                                        item: (index: number) => CSSRule;
                                        [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                    };
                                    addRule: (selector?: string, style?: string, index?: number) => number;
                                    deleteRule: (index: number) => void;
                                    insertRule: (rule: string, index?: number) => number;
                                    removeRule: (index?: number) => void;
                                    disabled: boolean;
                                    readonly href: string;
                                    readonly media: {
                                        [x: number]: string;
                                        readonly length: number;
                                        mediaText: string;
                                        toString: () => string;
                                        appendMedium: (medium: string) => void;
                                        deleteMedium: (medium: string) => void;
                                        item: (index: number) => string;
                                        [Symbol.iterator]: () => IterableIterator<string>;
                                    };
                                    readonly ownerNode: Element | ProcessingInstruction;
                                    readonly parentStyleSheet: any;
                                    readonly title: string;
                                    readonly type: string;
                                };
                                readonly type: number;
                                readonly CHARSET_RULE: number;
                                readonly FONT_FACE_RULE: number;
                                readonly IMPORT_RULE: number;
                                readonly KEYFRAMES_RULE: number;
                                readonly KEYFRAME_RULE: number;
                                readonly MEDIA_RULE: number;
                                readonly NAMESPACE_RULE: number;
                                readonly PAGE_RULE: number;
                                readonly STYLE_RULE: number;
                                readonly SUPPORTS_RULE: number;
                            };
                            perspective?: string;
                            perspectiveOrigin?: string;
                            placeContent?: string;
                            placeItems?: string;
                            placeSelf?: string;
                            pointerEvents?: string;
                            position?: string;
                            quotes?: string;
                            resize?: string;
                            right?: string;
                            rotate?: string;
                            rowGap?: string;
                            rubyPosition?: string;
                            scale?: string;
                            scrollBehavior?: string;
                            scrollMargin?: string;
                            scrollMarginBlock?: string;
                            scrollMarginBlockEnd?: string;
                            scrollMarginBlockStart?: string;
                            scrollMarginBottom?: string;
                            scrollMarginInline?: string;
                            scrollMarginInlineEnd?: string;
                            scrollMarginInlineStart?: string;
                            scrollMarginLeft?: string;
                            scrollMarginRight?: string;
                            scrollMarginTop?: string;
                            scrollPadding?: string;
                            scrollPaddingBlock?: string;
                            scrollPaddingBlockEnd?: string;
                            scrollPaddingBlockStart?: string;
                            scrollPaddingBottom?: string;
                            scrollPaddingInline?: string;
                            scrollPaddingInlineEnd?: string;
                            scrollPaddingInlineStart?: string;
                            scrollPaddingLeft?: string;
                            scrollPaddingRight?: string;
                            scrollPaddingTop?: string;
                            scrollSnapAlign?: string;
                            scrollSnapStop?: string;
                            scrollSnapType?: string;
                            shapeImageThreshold?: string;
                            shapeMargin?: string;
                            shapeOutside?: string;
                            shapeRendering?: string;
                            stopColor?: string;
                            stopOpacity?: string;
                            stroke?: string;
                            strokeDasharray?: string;
                            strokeDashoffset?: string;
                            strokeLinecap?: string;
                            strokeLinejoin?: string;
                            strokeMiterlimit?: string;
                            strokeOpacity?: string;
                            strokeWidth?: string;
                            tabSize?: string;
                            tableLayout?: string;
                            textAlign?: string;
                            textAlignLast?: string;
                            textAnchor?: string;
                            textCombineUpright?: string;
                            textDecoration?: string;
                            textDecorationColor?: string;
                            textDecorationLine?: string;
                            textDecorationSkipInk?: string;
                            textDecorationStyle?: string;
                            textDecorationThickness?: string;
                            textEmphasis?: string;
                            textEmphasisColor?: string;
                            textEmphasisPosition?: string;
                            textEmphasisStyle?: string;
                            textIndent?: string;
                            textOrientation?: string;
                            textOverflow?: string;
                            textRendering?: string;
                            textShadow?: string;
                            textTransform?: string;
                            textUnderlineOffset?: string;
                            textUnderlinePosition?: string;
                            top?: string;
                            touchAction?: string;
                            transform?: string;
                            transformBox?: string;
                            transformOrigin?: string;
                            transformStyle?: string;
                            transition?: string;
                            transitionDelay?: string;
                            transitionDuration?: string;
                            transitionProperty?: string;
                            transitionTimingFunction?: string;
                            translate?: string;
                            unicodeBidi?: string;
                            userSelect?: string;
                            verticalAlign?: string;
                            visibility?: string;
                            webkitAlignContent?: string;
                            webkitAlignItems?: string;
                            webkitAlignSelf?: string;
                            webkitAnimation?: string;
                            webkitAnimationDelay?: string;
                            webkitAnimationDirection?: string;
                            webkitAnimationDuration?: string;
                            webkitAnimationFillMode?: string;
                            webkitAnimationIterationCount?: string;
                            webkitAnimationName?: string;
                            webkitAnimationPlayState?: string;
                            webkitAnimationTimingFunction?: string;
                            webkitAppearance?: string;
                            webkitBackfaceVisibility?: string;
                            webkitBackgroundClip?: string;
                            webkitBackgroundOrigin?: string;
                            webkitBackgroundSize?: string;
                            webkitBorderBottomLeftRadius?: string;
                            webkitBorderBottomRightRadius?: string;
                            webkitBorderRadius?: string;
                            webkitBorderTopLeftRadius?: string;
                            webkitBorderTopRightRadius?: string;
                            webkitBoxAlign?: string;
                            webkitBoxFlex?: string;
                            webkitBoxOrdinalGroup?: string;
                            webkitBoxOrient?: string;
                            webkitBoxPack?: string;
                            webkitBoxShadow?: string;
                            webkitBoxSizing?: string;
                            webkitFilter?: string;
                            webkitFlex?: string;
                            webkitFlexBasis?: string;
                            webkitFlexDirection?: string;
                            webkitFlexFlow?: string;
                            webkitFlexGrow?: string;
                            webkitFlexShrink?: string;
                            webkitFlexWrap?: string;
                            webkitJustifyContent?: string;
                            webkitLineClamp?: string;
                            webkitMask?: string;
                            webkitMaskBoxImage?: string;
                            webkitMaskBoxImageOutset?: string;
                            webkitMaskBoxImageRepeat?: string;
                            webkitMaskBoxImageSlice?: string;
                            webkitMaskBoxImageSource?: string;
                            webkitMaskBoxImageWidth?: string;
                            webkitMaskClip?: string;
                            webkitMaskComposite?: string;
                            webkitMaskImage?: string;
                            webkitMaskOrigin?: string;
                            webkitMaskPosition?: string;
                            webkitMaskRepeat?: string;
                            webkitMaskSize?: string;
                            webkitOrder?: string;
                            webkitPerspective?: string;
                            webkitPerspectiveOrigin?: string;
                            webkitTextFillColor?: string;
                            webkitTextStroke?: string;
                            webkitTextStrokeColor?: string;
                            webkitTextStrokeWidth?: string;
                            webkitTransform?: string;
                            webkitTransformOrigin?: string;
                            webkitTransformStyle?: string;
                            webkitTransition?: string;
                            webkitTransitionDelay?: string;
                            webkitTransitionDuration?: string;
                            webkitTransitionProperty?: string;
                            webkitTransitionTimingFunction?: string;
                            webkitUserSelect?: string;
                            whiteSpace?: string;
                            widows?: string;
                            width?: string;
                            willChange?: string;
                            wordBreak?: string;
                            wordSpacing?: string;
                            wordWrap?: string;
                            writingMode?: string;
                            zIndex?: string;
                            getPropertyPriority?: (property: string) => string;
                            getPropertyValue?: (property: string) => string;
                            item?: (index: number) => string;
                            removeProperty?: (property: string) => string;
                            setProperty?: (property: string, value: string, priority?: string) => void;
                            [Symbol.iterator]?: () => IterableIterator<string>;
                        };
                    }>;
                    instanceRef: import("vue").ComputedRef<import("@popperjs/core").Instance>;
                    role: import("vue").ComputedRef<string>;
                    update: () => Promise<Partial<import("@popperjs/core").State>>;
                    ariaModal: import("vue").ComputedRef<string>;
                    arrowStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
                    contentAttrs: import("vue").ComputedRef<{
                        [x: string]: string | boolean;
                    }>;
                    contentClass: import("vue").ComputedRef<(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)[])[])[])[])[])[])[])[])[])[])[])[]>;
                    contentStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
                    updateZIndex: () => void;
                    formItemContext: import("hongluan-ui/es/tokens").FormItemContext;
                    arrowOffset: import("vue").Ref<number>;
                    triggerTargetAriaStopWatch: import("vue").WatchStopHandle;
                    updatePopper: (shouldUpdateZIndex?: boolean) => void;
                    togglePopperAlive: () => void;
                    HlFocusTrap: import("vue").DefineComponent<{
                        loop: BooleanConstructor;
                        trapped: BooleanConstructor;
                        focusTrapEl: import("vue").PropType<HTMLElement>;
                        focusStartEl: {
                            type: import("vue").PropType<HTMLElement | "first" | "container">;
                            default: string;
                        };
                    }, {
                        onKeydown: (e: KeyboardEvent) => void;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested")[], "focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                        loop: BooleanConstructor;
                        trapped: BooleanConstructor;
                        focusTrapEl: import("vue").PropType<HTMLElement>;
                        focusStartEl: {
                            type: import("vue").PropType<HTMLElement | "first" | "container">;
                            default: string;
                        };
                    }>> & {
                        onFocusAfterReleased?: (...args: any[]) => any;
                        onFocusAfterTrapped?: (...args: any[]) => any;
                        onFocusin?: (...args: any[]) => any;
                        onFocusout?: (...args: any[]) => any;
                        "onFocusout-prevented"?: (...args: any[]) => any;
                        "onRelease-requested"?: (...args: any[]) => any;
                    }, {
                        trapped: boolean;
                        loop: boolean;
                        focusStartEl: HTMLElement | "first" | "container";
                    }>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    mouseenter: (evt: MouseEvent) => boolean;
                    mouseleave: (evt: MouseEvent) => boolean;
                    focus: () => boolean;
                    blur: () => boolean;
                    close: () => boolean;
                }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly visible: BooleanConstructor;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                }>> & {
                    onClose?: () => any;
                    onBlur?: () => any;
                    onFocus?: () => any;
                    onMouseleave?: (evt: MouseEvent) => any;
                    onMouseenter?: (evt: MouseEvent) => any;
                }, {
                    offset: number;
                    placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                    effect: string;
                    visible: boolean;
                    boundariesPadding: number;
                    gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    popperOptions: Partial<import("@popperjs/core").Options>;
                    strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                    enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    pure: boolean;
                    virtualTriggering: 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 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").PropType<string>, unknown, unknown, "", boolean>;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            }>>, {
                disabled: boolean;
                offset: number;
                placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                transition: string;
                effect: string;
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                boundariesPadding: number;
                gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                popperOptions: Partial<import("@popperjs/core").Options>;
                strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                pure: boolean;
                virtualTriggering: boolean;
                content: string;
                teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
                rawContent: boolean;
                persistent: boolean;
            }>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, {
            disabled: boolean;
            trigger: import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>, unknown, unknown>;
            offset: number;
            placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
            transition: string;
            effect: string;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            boundariesPadding: number;
            gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            popperOptions: Partial<import("@popperjs/core").Options>;
            strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
            enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            pure: boolean;
            virtualTriggering: boolean;
            content: string;
            teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
            rawContent: boolean;
            persistent: boolean;
            open: boolean;
            role: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>;
            triggerKeys: string[];
            arrowOffset: number;
            showArrow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, 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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof nextTick;
        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
    } & 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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
        popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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;
    } & import("vue").ShallowUnwrapRef<{
        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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
            popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
            $parent: 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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof 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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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").PropType<string>, unknown, unknown, "", boolean>;
            readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly pure: BooleanConstructor;
            readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly 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;
            };
            readonly popperStyle: {
                readonly type: import("vue").PropType<unknown>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly referenceEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly triggerTargetEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly virtualTriggering: BooleanConstructor;
            readonly zIndex: NumberConstructor;
            readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly fallbackPlacements: {
                readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
            readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
            readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
            readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
            readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        }, {
            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                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").PropType<string>, unknown, unknown, "", boolean>;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            }>> & {
                [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
            }>>;
            selector: import("vue").ComputedRef<string>;
            contentRef: any;
            stopHandle: () => void;
            controlled: import("vue").Ref<boolean>;
            id: import("vue").Ref<string>;
            open: import("vue").Ref<boolean>;
            trigger: import("vue").Ref<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>;
            onClose: (e?: Event) => void;
            onOpen: (e?: Event) => void;
            onShow: () => void;
            onHide: () => void;
            onBeforeShow: () => void;
            onBeforeHide: () => void;
            persistentRef: import("vue").ComputedRef<boolean>;
            shouldRender: import("vue").ComputedRef<boolean>;
            shouldShow: import("vue").ComputedRef<boolean>;
            appendTo: import("vue").ComputedRef<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
            contentStyle: import("vue").ComputedRef<any>;
            ariaHidden: import("vue").ComputedRef<boolean>;
            onTransitionLeave: () => void;
            stopWhenControlled: () => boolean;
            onContentEnter: (event: unknown) => void;
            onContentLeave: (event: unknown) => void;
            onBeforeEnter: () => void;
            onBeforeLeave: () => void;
            onAfterShow: () => void;
            onBlur: () => void;
            HlTeleport: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
                readonly to: {
                    readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                    readonly required: true;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
            }, {
                COMPONENT_NAME: string;
            }, 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 to: {
                    readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                    readonly required: true;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
            }>>, {
                disabled: boolean;
            }>> & Record<string, any>;
            HlPopperContent: import("vue").DefineComponent<{
                readonly ariaLabel: StringConstructor;
                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").PropType<string>, unknown, unknown, "", boolean>;
                readonly visible: BooleanConstructor;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            }, {
                emit: ((event: "blur") => void) & ((event: "focus") => void) & ((event: "close") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
                props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly visible: BooleanConstructor;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                }>> & {
                    onClose?: () => any;
                    onBlur?: () => any;
                    onFocus?: () => any;
                    onMouseleave?: (evt: MouseEvent) => any;
                    onMouseenter?: (evt: MouseEvent) => any;
                }>>;
                focusStartRef: import("vue").Ref<HTMLElement | "first" | "container">;
                trapped: import("vue").Ref<boolean>;
                onFocusAfterReleased: (event: CustomEvent<any>) => void;
                onFocusAfterTrapped: () => void;
                onFocusInTrap: (event: FocusEvent) => void;
                onFocusoutPrevented: (event: CustomEvent<any>) => void;
                onReleaseRequested: () => void;
                attributes: import("vue").ComputedRef<{
                    [x: string]: {
                        [x: string]: string | boolean;
                    };
                }>;
                arrowRef: import("vue").Ref<HTMLElement>;
                contentRef: import("vue").Ref<HTMLElement>;
                styles: import("vue").ComputedRef<{
                    [x: string]: {
                        [x: number]: string;
                        accentColor?: string;
                        alignContent?: string;
                        alignItems?: string;
                        alignSelf?: string;
                        alignmentBaseline?: string;
                        all?: string;
                        animation?: string;
                        animationDelay?: string;
                        animationDirection?: string;
                        animationDuration?: string;
                        animationFillMode?: string;
                        animationIterationCount?: string;
                        animationName?: string;
                        animationPlayState?: string;
                        animationTimingFunction?: string;
                        appearance?: string;
                        aspectRatio?: string;
                        backfaceVisibility?: string;
                        background?: string;
                        backgroundAttachment?: string;
                        backgroundBlendMode?: string;
                        backgroundClip?: string;
                        backgroundColor?: string;
                        backgroundImage?: string;
                        backgroundOrigin?: string;
                        backgroundPosition?: string;
                        backgroundPositionX?: string;
                        backgroundPositionY?: string;
                        backgroundRepeat?: string;
                        backgroundSize?: string;
                        baselineShift?: string;
                        blockSize?: string;
                        border?: string;
                        borderBlock?: string;
                        borderBlockColor?: string;
                        borderBlockEnd?: string;
                        borderBlockEndColor?: string;
                        borderBlockEndStyle?: string;
                        borderBlockEndWidth?: string;
                        borderBlockStart?: string;
                        borderBlockStartColor?: string;
                        borderBlockStartStyle?: string;
                        borderBlockStartWidth?: string;
                        borderBlockStyle?: string;
                        borderBlockWidth?: string;
                        borderBottom?: string;
                        borderBottomColor?: string;
                        borderBottomLeftRadius?: string;
                        borderBottomRightRadius?: string;
                        borderBottomStyle?: string;
                        borderBottomWidth?: string;
                        borderCollapse?: string;
                        borderColor?: string;
                        borderEndEndRadius?: string;
                        borderEndStartRadius?: string;
                        borderImage?: string;
                        borderImageOutset?: string;
                        borderImageRepeat?: string;
                        borderImageSlice?: string;
                        borderImageSource?: string;
                        borderImageWidth?: string;
                        borderInline?: string;
                        borderInlineColor?: string;
                        borderInlineEnd?: string;
                        borderInlineEndColor?: string;
                        borderInlineEndStyle?: string;
                        borderInlineEndWidth?: string;
                        borderInlineStart?: string;
                        borderInlineStartColor?: string;
                        borderInlineStartStyle?: string;
                        borderInlineStartWidth?: string;
                        borderInlineStyle?: string;
                        borderInlineWidth?: string;
                        borderLeft?: string;
                        borderLeftColor?: string;
                        borderLeftStyle?: string;
                        borderLeftWidth?: string;
                        borderRadius?: string;
                        borderRight?: string;
                        borderRightColor?: string;
                        borderRightStyle?: string;
                        borderRightWidth?: string;
                        borderSpacing?: string;
                        borderStartEndRadius?: string;
                        borderStartStartRadius?: string;
                        borderStyle?: string;
                        borderTop?: string;
                        borderTopColor?: string;
                        borderTopLeftRadius?: string;
                        borderTopRightRadius?: string;
                        borderTopStyle?: string;
                        borderTopWidth?: string;
                        borderWidth?: string;
                        bottom?: string;
                        boxShadow?: string;
                        boxSizing?: string;
                        breakAfter?: string;
                        breakBefore?: string;
                        breakInside?: string;
                        captionSide?: string;
                        caretColor?: string;
                        clear?: string;
                        clip?: string;
                        clipPath?: string;
                        clipRule?: string;
                        color?: string;
                        colorInterpolation?: string;
                        colorInterpolationFilters?: string;
                        colorScheme?: string;
                        columnCount?: string;
                        columnFill?: string;
                        columnGap?: string;
                        columnRule?: string;
                        columnRuleColor?: string;
                        columnRuleStyle?: string;
                        columnRuleWidth?: string;
                        columnSpan?: string;
                        columnWidth?: string;
                        columns?: string;
                        contain?: string;
                        content?: string;
                        counterIncrement?: string;
                        counterReset?: string;
                        counterSet?: string;
                        cssFloat?: string;
                        cssText?: string;
                        cursor?: string;
                        direction?: string;
                        display?: string;
                        dominantBaseline?: string;
                        emptyCells?: string;
                        fill?: string;
                        fillOpacity?: string;
                        fillRule?: string;
                        filter?: string;
                        flex?: string;
                        flexBasis?: string;
                        flexDirection?: string;
                        flexFlow?: string;
                        flexGrow?: string;
                        flexShrink?: string;
                        flexWrap?: string;
                        float?: string;
                        floodColor?: string;
                        floodOpacity?: string;
                        font?: string;
                        fontFamily?: string;
                        fontFeatureSettings?: string;
                        fontKerning?: string;
                        fontOpticalSizing?: string;
                        fontSize?: string;
                        fontSizeAdjust?: string;
                        fontStretch?: string;
                        fontStyle?: string;
                        fontSynthesis?: string;
                        fontVariant?: string;
                        fontVariantAlternates?: string;
                        fontVariantCaps?: string;
                        fontVariantEastAsian?: string;
                        fontVariantLigatures?: string;
                        fontVariantNumeric?: string;
                        fontVariantPosition?: string;
                        fontVariationSettings?: string;
                        fontWeight?: string;
                        gap?: string;
                        grid?: string;
                        gridArea?: string;
                        gridAutoColumns?: string;
                        gridAutoFlow?: string;
                        gridAutoRows?: string;
                        gridColumn?: string;
                        gridColumnEnd?: string;
                        gridColumnGap?: string;
                        gridColumnStart?: string;
                        gridGap?: string;
                        gridRow?: string;
                        gridRowEnd?: string;
                        gridRowGap?: string;
                        gridRowStart?: string;
                        gridTemplate?: string;
                        gridTemplateAreas?: string;
                        gridTemplateColumns?: string;
                        gridTemplateRows?: string;
                        height?: string;
                        hyphens?: string;
                        imageOrientation?: string;
                        imageRendering?: string;
                        inlineSize?: string;
                        inset?: string;
                        insetBlock?: string;
                        insetBlockEnd?: string;
                        insetBlockStart?: string;
                        insetInline?: string;
                        insetInlineEnd?: string;
                        insetInlineStart?: string;
                        isolation?: string;
                        justifyContent?: string;
                        justifyItems?: string;
                        justifySelf?: string;
                        left?: string;
                        readonly length?: number;
                        letterSpacing?: string;
                        lightingColor?: string;
                        lineBreak?: string;
                        lineHeight?: string;
                        listStyle?: string;
                        listStyleImage?: string;
                        listStylePosition?: string;
                        listStyleType?: string;
                        margin?: string;
                        marginBlock?: string;
                        marginBlockEnd?: string;
                        marginBlockStart?: string;
                        marginBottom?: string;
                        marginInline?: string;
                        marginInlineEnd?: string;
                        marginInlineStart?: string;
                        marginLeft?: string;
                        marginRight?: string;
                        marginTop?: string;
                        marker?: string;
                        markerEnd?: string;
                        markerMid?: string;
                        markerStart?: string;
                        mask?: string;
                        maskType?: string;
                        maxBlockSize?: string;
                        maxHeight?: string;
                        maxInlineSize?: string;
                        maxWidth?: string;
                        minBlockSize?: string;
                        minHeight?: string;
                        minInlineSize?: string;
                        minWidth?: string;
                        mixBlendMode?: string;
                        objectFit?: string;
                        objectPosition?: string;
                        offset?: string;
                        offsetAnchor?: string;
                        offsetDistance?: string;
                        offsetPath?: string;
                        offsetRotate?: string;
                        opacity?: string;
                        order?: string;
                        orphans?: string;
                        outline?: string;
                        outlineColor?: string;
                        outlineOffset?: string;
                        outlineStyle?: string;
                        outlineWidth?: string;
                        overflow?: string;
                        overflowAnchor?: string;
                        overflowWrap?: string;
                        overflowX?: string;
                        overflowY?: string;
                        overscrollBehavior?: string;
                        overscrollBehaviorBlock?: string;
                        overscrollBehaviorInline?: string;
                        overscrollBehaviorX?: string;
                        overscrollBehaviorY?: string;
                        padding?: string;
                        paddingBlock?: string;
                        paddingBlockEnd?: string;
                        paddingBlockStart?: string;
                        paddingBottom?: string;
                        paddingInline?: string;
                        paddingInlineEnd?: string;
                        paddingInlineStart?: string;
                        paddingLeft?: string;
                        paddingRight?: string;
                        paddingTop?: string;
                        pageBreakAfter?: string;
                        pageBreakBefore?: string;
                        pageBreakInside?: string;
                        paintOrder?: string;
                        readonly parentRule?: {
                            cssText: string;
                            readonly parentRule: any;
                            readonly parentStyleSheet: {
                                readonly cssRules: {
                                    [x: number]: any;
                                    readonly length: number;
                                    item: (index: number) => CSSRule;
                                    [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                };
                                readonly ownerRule: any;
                                readonly rules: {
                                    [x: number]: any;
                                    readonly length: number;
                                    item: (index: number) => CSSRule;
                                    [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                };
                                addRule: (selector?: string, style?: string, index?: number) => number;
                                deleteRule: (index: number) => void;
                                insertRule: (rule: string, index?: number) => number;
                                removeRule: (index?: number) => void;
                                disabled: boolean;
                                readonly href: string;
                                readonly media: {
                                    [x: number]: string;
                                    readonly length: number;
                                    mediaText: string;
                                    toString: () => string;
                                    appendMedium: (medium: string) => void;
                                    deleteMedium: (medium: string) => void;
                                    item: (index: number) => string;
                                    [Symbol.iterator]: () => IterableIterator<string>;
                                };
                                readonly ownerNode: Element | ProcessingInstruction;
                                readonly parentStyleSheet: any;
                                readonly title: string;
                                readonly type: string;
                            };
                            readonly type: number;
                            readonly CHARSET_RULE: number;
                            readonly FONT_FACE_RULE: number;
                            readonly IMPORT_RULE: number;
                            readonly KEYFRAMES_RULE: number;
                            readonly KEYFRAME_RULE: number;
                            readonly MEDIA_RULE: number;
                            readonly NAMESPACE_RULE: number;
                            readonly PAGE_RULE: number;
                            readonly STYLE_RULE: number;
                            readonly SUPPORTS_RULE: number;
                        };
                        perspective?: string;
                        perspectiveOrigin?: string;
                        placeContent?: string;
                        placeItems?: string;
                        placeSelf?: string;
                        pointerEvents?: string;
                        position?: string;
                        quotes?: string;
                        resize?: string;
                        right?: string;
                        rotate?: string;
                        rowGap?: string;
                        rubyPosition?: string;
                        scale?: string;
                        scrollBehavior?: string;
                        scrollMargin?: string;
                        scrollMarginBlock?: string;
                        scrollMarginBlockEnd?: string;
                        scrollMarginBlockStart?: string;
                        scrollMarginBottom?: string;
                        scrollMarginInline?: string;
                        scrollMarginInlineEnd?: string;
                        scrollMarginInlineStart?: string;
                        scrollMarginLeft?: string;
                        scrollMarginRight?: string;
                        scrollMarginTop?: string;
                        scrollPadding?: string;
                        scrollPaddingBlock?: string;
                        scrollPaddingBlockEnd?: string;
                        scrollPaddingBlockStart?: string;
                        scrollPaddingBottom?: string;
                        scrollPaddingInline?: string;
                        scrollPaddingInlineEnd?: string;
                        scrollPaddingInlineStart?: string;
                        scrollPaddingLeft?: string;
                        scrollPaddingRight?: string;
                        scrollPaddingTop?: string;
                        scrollSnapAlign?: string;
                        scrollSnapStop?: string;
                        scrollSnapType?: string;
                        shapeImageThreshold?: string;
                        shapeMargin?: string;
                        shapeOutside?: string;
                        shapeRendering?: string;
                        stopColor?: string;
                        stopOpacity?: string;
                        stroke?: string;
                        strokeDasharray?: string;
                        strokeDashoffset?: string;
                        strokeLinecap?: string;
                        strokeLinejoin?: string;
                        strokeMiterlimit?: string;
                        strokeOpacity?: string;
                        strokeWidth?: string;
                        tabSize?: string;
                        tableLayout?: string;
                        textAlign?: string;
                        textAlignLast?: string;
                        textAnchor?: string;
                        textCombineUpright?: string;
                        textDecoration?: string;
                        textDecorationColor?: string;
                        textDecorationLine?: string;
                        textDecorationSkipInk?: string;
                        textDecorationStyle?: string;
                        textDecorationThickness?: string;
                        textEmphasis?: string;
                        textEmphasisColor?: string;
                        textEmphasisPosition?: string;
                        textEmphasisStyle?: string;
                        textIndent?: string;
                        textOrientation?: string;
                        textOverflow?: string;
                        textRendering?: string;
                        textShadow?: string;
                        textTransform?: string;
                        textUnderlineOffset?: string;
                        textUnderlinePosition?: string;
                        top?: string;
                        touchAction?: string;
                        transform?: string;
                        transformBox?: string;
                        transformOrigin?: string;
                        transformStyle?: string;
                        transition?: string;
                        transitionDelay?: string;
                        transitionDuration?: string;
                        transitionProperty?: string;
                        transitionTimingFunction?: string;
                        translate?: string;
                        unicodeBidi?: string;
                        userSelect?: string;
                        verticalAlign?: string;
                        visibility?: string;
                        webkitAlignContent?: string;
                        webkitAlignItems?: string;
                        webkitAlignSelf?: string;
                        webkitAnimation?: string;
                        webkitAnimationDelay?: string;
                        webkitAnimationDirection?: string;
                        webkitAnimationDuration?: string;
                        webkitAnimationFillMode?: string;
                        webkitAnimationIterationCount?: string;
                        webkitAnimationName?: string;
                        webkitAnimationPlayState?: string;
                        webkitAnimationTimingFunction?: string;
                        webkitAppearance?: string;
                        webkitBackfaceVisibility?: string;
                        webkitBackgroundClip?: string;
                        webkitBackgroundOrigin?: string;
                        webkitBackgroundSize?: string;
                        webkitBorderBottomLeftRadius?: string;
                        webkitBorderBottomRightRadius?: string;
                        webkitBorderRadius?: string;
                        webkitBorderTopLeftRadius?: string;
                        webkitBorderTopRightRadius?: string;
                        webkitBoxAlign?: string;
                        webkitBoxFlex?: string;
                        webkitBoxOrdinalGroup?: string;
                        webkitBoxOrient?: string;
                        webkitBoxPack?: string;
                        webkitBoxShadow?: string;
                        webkitBoxSizing?: string;
                        webkitFilter?: string;
                        webkitFlex?: string;
                        webkitFlexBasis?: string;
                        webkitFlexDirection?: string;
                        webkitFlexFlow?: string;
                        webkitFlexGrow?: string;
                        webkitFlexShrink?: string;
                        webkitFlexWrap?: string;
                        webkitJustifyContent?: string;
                        webkitLineClamp?: string;
                        webkitMask?: string;
                        webkitMaskBoxImage?: string;
                        webkitMaskBoxImageOutset?: string;
                        webkitMaskBoxImageRepeat?: string;
                        webkitMaskBoxImageSlice?: string;
                        webkitMaskBoxImageSource?: string;
                        webkitMaskBoxImageWidth?: string;
                        webkitMaskClip?: string;
                        webkitMaskComposite?: string;
                        webkitMaskImage?: string;
                        webkitMaskOrigin?: string;
                        webkitMaskPosition?: string;
                        webkitMaskRepeat?: string;
                        webkitMaskSize?: string;
                        webkitOrder?: string;
                        webkitPerspective?: string;
                        webkitPerspectiveOrigin?: string;
                        webkitTextFillColor?: string;
                        webkitTextStroke?: string;
                        webkitTextStrokeColor?: string;
                        webkitTextStrokeWidth?: string;
                        webkitTransform?: string;
                        webkitTransformOrigin?: string;
                        webkitTransformStyle?: string;
                        webkitTransition?: string;
                        webkitTransitionDelay?: string;
                        webkitTransitionDuration?: string;
                        webkitTransitionProperty?: string;
                        webkitTransitionTimingFunction?: string;
                        webkitUserSelect?: string;
                        whiteSpace?: string;
                        widows?: string;
                        width?: string;
                        willChange?: string;
                        wordBreak?: string;
                        wordSpacing?: string;
                        wordWrap?: string;
                        writingMode?: string;
                        zIndex?: string;
                        getPropertyPriority?: (property: string) => string;
                        getPropertyValue?: (property: string) => string;
                        item?: (index: number) => string;
                        removeProperty?: (property: string) => string;
                        setProperty?: (property: string, value: string, priority?: string) => void;
                        [Symbol.iterator]?: () => IterableIterator<string>;
                    };
                }>;
                instanceRef: import("vue").ComputedRef<import("@popperjs/core").Instance>;
                role: import("vue").ComputedRef<string>;
                update: () => Promise<Partial<import("@popperjs/core").State>>;
                ariaModal: import("vue").ComputedRef<string>;
                arrowStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
                contentAttrs: import("vue").ComputedRef<{
                    [x: string]: string | boolean;
                }>;
                contentClass: import("vue").ComputedRef<(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)[])[])[])[])[])[])[])[])[])[])[])[]>;
                contentStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
                updateZIndex: () => void;
                formItemContext: import("hongluan-ui/es/tokens").FormItemContext;
                arrowOffset: import("vue").Ref<number>;
                triggerTargetAriaStopWatch: import("vue").WatchStopHandle;
                updatePopper: (shouldUpdateZIndex?: boolean) => void;
                togglePopperAlive: () => void;
                HlFocusTrap: import("vue").DefineComponent<{
                    loop: BooleanConstructor;
                    trapped: BooleanConstructor;
                    focusTrapEl: import("vue").PropType<HTMLElement>;
                    focusStartEl: {
                        type: import("vue").PropType<HTMLElement | "first" | "container">;
                        default: string;
                    };
                }, {
                    onKeydown: (e: KeyboardEvent) => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested")[], "focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                    loop: BooleanConstructor;
                    trapped: BooleanConstructor;
                    focusTrapEl: import("vue").PropType<HTMLElement>;
                    focusStartEl: {
                        type: import("vue").PropType<HTMLElement | "first" | "container">;
                        default: string;
                    };
                }>> & {
                    onFocusAfterReleased?: (...args: any[]) => any;
                    onFocusAfterTrapped?: (...args: any[]) => any;
                    onFocusin?: (...args: any[]) => any;
                    onFocusout?: (...args: any[]) => any;
                    "onFocusout-prevented"?: (...args: any[]) => any;
                    "onRelease-requested"?: (...args: any[]) => any;
                }, {
                    trapped: boolean;
                    loop: boolean;
                    focusStartEl: HTMLElement | "first" | "container";
                }>;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                mouseenter: (evt: MouseEvent) => boolean;
                mouseleave: (evt: MouseEvent) => boolean;
                focus: () => boolean;
                blur: () => boolean;
                close: () => boolean;
            }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                readonly ariaLabel: StringConstructor;
                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").PropType<string>, unknown, unknown, "", boolean>;
                readonly visible: BooleanConstructor;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            }>> & {
                onClose?: () => any;
                onBlur?: () => any;
                onFocus?: () => any;
                onMouseleave?: (evt: MouseEvent) => any;
                onMouseenter?: (evt: MouseEvent) => any;
            }, {
                offset: number;
                placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                effect: string;
                visible: boolean;
                boundariesPadding: number;
                gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                popperOptions: Partial<import("@popperjs/core").Options>;
                strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                pure: boolean;
                virtualTriggering: 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 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").PropType<string>, unknown, unknown, "", boolean>;
            readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly pure: BooleanConstructor;
            readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly 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;
            };
            readonly popperStyle: {
                readonly type: import("vue").PropType<unknown>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly referenceEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly triggerTargetEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly virtualTriggering: BooleanConstructor;
            readonly zIndex: NumberConstructor;
            readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly fallbackPlacements: {
                readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
            readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
            readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
            readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
            readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        }>>, {
            disabled: boolean;
            offset: number;
            placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
            transition: string;
            effect: string;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            boundariesPadding: number;
            gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            popperOptions: Partial<import("@popperjs/core").Options>;
            strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
            enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            pure: boolean;
            virtualTriggering: boolean;
            content: string;
            teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
            rawContent: boolean;
            persistent: boolean;
        }>;
    }> & {} & {} & import("vue").ComponentCustomProperties>;
    tagTooltipRef: import("vue").Ref<{
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            disabled: boolean;
            trigger: import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>, unknown, unknown>;
            offset: number;
            placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
            transition: string;
            effect: string;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            boundariesPadding: number;
            gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            popperOptions: Partial<import("@popperjs/core").Options>;
            strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
            enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            pure: boolean;
            virtualTriggering: boolean;
            content: string;
            teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
            rawContent: boolean;
            persistent: boolean;
            open: boolean;
            role: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>;
            triggerKeys: string[];
            arrowOffset: number;
            showArrow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
        }> & Omit<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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
            popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "disabled" | "trigger" | "offset" | "placement" | "transition" | "effect" | "showAfter" | "hideAfter" | "autoClose" | "boundariesPadding" | "gpuAcceleration" | "popperOptions" | "strategy" | "enterable" | "focusOnShow" | "trapping" | "stopPopperMouseEvent" | "pure" | "virtualTriggering" | "content" | "teleported" | "outsideIgnore" | "rawContent" | "persistent" | "open" | "role" | "triggerKeys" | "arrowOffset" | "showArrow">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot;
        }>;
        $root: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $parent: 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<{
            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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
            popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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;
        }, {
            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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
                popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
                $parent: 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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
                };
                $forceUpdate: () => void;
                $nextTick: typeof 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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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").PropType<string>, unknown, unknown, "", boolean>;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            }, {
                props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                    readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                    readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                }>> & {
                    [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
                }>>;
                selector: import("vue").ComputedRef<string>;
                contentRef: any;
                stopHandle: () => void;
                controlled: import("vue").Ref<boolean>;
                id: import("vue").Ref<string>;
                open: import("vue").Ref<boolean>;
                trigger: import("vue").Ref<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>;
                onClose: (e?: Event) => void;
                onOpen: (e?: Event) => void;
                onShow: () => void;
                onHide: () => void;
                onBeforeShow: () => void;
                onBeforeHide: () => void;
                persistentRef: import("vue").ComputedRef<boolean>;
                shouldRender: import("vue").ComputedRef<boolean>;
                shouldShow: import("vue").ComputedRef<boolean>;
                appendTo: import("vue").ComputedRef<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                contentStyle: import("vue").ComputedRef<any>;
                ariaHidden: import("vue").ComputedRef<boolean>;
                onTransitionLeave: () => void;
                stopWhenControlled: () => boolean;
                onContentEnter: (event: unknown) => void;
                onContentLeave: (event: unknown) => void;
                onBeforeEnter: () => void;
                onBeforeLeave: () => void;
                onAfterShow: () => void;
                onBlur: () => void;
                HlTeleport: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
                    readonly to: {
                        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                        readonly required: true;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }, {
                    COMPONENT_NAME: string;
                }, 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 to: {
                        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                        readonly required: true;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly disabled: BooleanConstructor;
                }>>, {
                    disabled: boolean;
                }>> & Record<string, any>;
                HlPopperContent: import("vue").DefineComponent<{
                    readonly ariaLabel: StringConstructor;
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly visible: BooleanConstructor;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                }, {
                    emit: ((event: "blur") => void) & ((event: "focus") => void) & ((event: "close") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
                    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                        readonly ariaLabel: StringConstructor;
                        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").PropType<string>, unknown, unknown, "", boolean>;
                        readonly visible: BooleanConstructor;
                        readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        readonly pure: BooleanConstructor;
                        readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                        readonly 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;
                        };
                        readonly popperStyle: {
                            readonly type: import("vue").PropType<unknown>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly referenceEl: {
                            readonly type: import("vue").PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly triggerTargetEl: {
                            readonly type: import("vue").PropType<HTMLElement>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        readonly virtualTriggering: BooleanConstructor;
                        readonly zIndex: NumberConstructor;
                        readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                        readonly fallbackPlacements: {
                            readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                            readonly required: false;
                            readonly validator: (val: unknown) => boolean;
                            __epPropKey: true;
                        };
                        readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                        readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                        readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                        readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                        readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                    }>> & {
                        onClose?: () => any;
                        onBlur?: () => any;
                        onFocus?: () => any;
                        onMouseleave?: (evt: MouseEvent) => any;
                        onMouseenter?: (evt: MouseEvent) => any;
                    }>>;
                    focusStartRef: import("vue").Ref<HTMLElement | "first" | "container">;
                    trapped: import("vue").Ref<boolean>;
                    onFocusAfterReleased: (event: CustomEvent<any>) => void;
                    onFocusAfterTrapped: () => void;
                    onFocusInTrap: (event: FocusEvent) => void;
                    onFocusoutPrevented: (event: CustomEvent<any>) => void;
                    onReleaseRequested: () => void;
                    attributes: import("vue").ComputedRef<{
                        [x: string]: {
                            [x: string]: string | boolean;
                        };
                    }>;
                    arrowRef: import("vue").Ref<HTMLElement>;
                    contentRef: import("vue").Ref<HTMLElement>;
                    styles: import("vue").ComputedRef<{
                        [x: string]: {
                            [x: number]: string;
                            accentColor?: string;
                            alignContent?: string;
                            alignItems?: string;
                            alignSelf?: string;
                            alignmentBaseline?: string;
                            all?: string;
                            animation?: string;
                            animationDelay?: string;
                            animationDirection?: string;
                            animationDuration?: string;
                            animationFillMode?: string;
                            animationIterationCount?: string;
                            animationName?: string;
                            animationPlayState?: string;
                            animationTimingFunction?: string;
                            appearance?: string;
                            aspectRatio?: string;
                            backfaceVisibility?: string;
                            background?: string;
                            backgroundAttachment?: string;
                            backgroundBlendMode?: string;
                            backgroundClip?: string;
                            backgroundColor?: string;
                            backgroundImage?: string;
                            backgroundOrigin?: string;
                            backgroundPosition?: string;
                            backgroundPositionX?: string;
                            backgroundPositionY?: string;
                            backgroundRepeat?: string;
                            backgroundSize?: string;
                            baselineShift?: string;
                            blockSize?: string;
                            border?: string;
                            borderBlock?: string;
                            borderBlockColor?: string;
                            borderBlockEnd?: string;
                            borderBlockEndColor?: string;
                            borderBlockEndStyle?: string;
                            borderBlockEndWidth?: string;
                            borderBlockStart?: string;
                            borderBlockStartColor?: string;
                            borderBlockStartStyle?: string;
                            borderBlockStartWidth?: string;
                            borderBlockStyle?: string;
                            borderBlockWidth?: string;
                            borderBottom?: string;
                            borderBottomColor?: string;
                            borderBottomLeftRadius?: string;
                            borderBottomRightRadius?: string;
                            borderBottomStyle?: string;
                            borderBottomWidth?: string;
                            borderCollapse?: string;
                            borderColor?: string;
                            borderEndEndRadius?: string;
                            borderEndStartRadius?: string;
                            borderImage?: string;
                            borderImageOutset?: string;
                            borderImageRepeat?: string;
                            borderImageSlice?: string;
                            borderImageSource?: string;
                            borderImageWidth?: string;
                            borderInline?: string;
                            borderInlineColor?: string;
                            borderInlineEnd?: string;
                            borderInlineEndColor?: string;
                            borderInlineEndStyle?: string;
                            borderInlineEndWidth?: string;
                            borderInlineStart?: string;
                            borderInlineStartColor?: string;
                            borderInlineStartStyle?: string;
                            borderInlineStartWidth?: string;
                            borderInlineStyle?: string;
                            borderInlineWidth?: string;
                            borderLeft?: string;
                            borderLeftColor?: string;
                            borderLeftStyle?: string;
                            borderLeftWidth?: string;
                            borderRadius?: string;
                            borderRight?: string;
                            borderRightColor?: string;
                            borderRightStyle?: string;
                            borderRightWidth?: string;
                            borderSpacing?: string;
                            borderStartEndRadius?: string;
                            borderStartStartRadius?: string;
                            borderStyle?: string;
                            borderTop?: string;
                            borderTopColor?: string;
                            borderTopLeftRadius?: string;
                            borderTopRightRadius?: string;
                            borderTopStyle?: string;
                            borderTopWidth?: string;
                            borderWidth?: string;
                            bottom?: string;
                            boxShadow?: string;
                            boxSizing?: string;
                            breakAfter?: string;
                            breakBefore?: string;
                            breakInside?: string;
                            captionSide?: string;
                            caretColor?: string;
                            clear?: string;
                            clip?: string;
                            clipPath?: string;
                            clipRule?: string;
                            color?: string;
                            colorInterpolation?: string;
                            colorInterpolationFilters?: string;
                            colorScheme?: string;
                            columnCount?: string;
                            columnFill?: string;
                            columnGap?: string;
                            columnRule?: string;
                            columnRuleColor?: string;
                            columnRuleStyle?: string;
                            columnRuleWidth?: string;
                            columnSpan?: string;
                            columnWidth?: string;
                            columns?: string;
                            contain?: string;
                            content?: string;
                            counterIncrement?: string;
                            counterReset?: string;
                            counterSet?: string;
                            cssFloat?: string;
                            cssText?: string;
                            cursor?: string;
                            direction?: string;
                            display?: string;
                            dominantBaseline?: string;
                            emptyCells?: string;
                            fill?: string;
                            fillOpacity?: string;
                            fillRule?: string;
                            filter?: string;
                            flex?: string;
                            flexBasis?: string;
                            flexDirection?: string;
                            flexFlow?: string;
                            flexGrow?: string;
                            flexShrink?: string;
                            flexWrap?: string;
                            float?: string;
                            floodColor?: string;
                            floodOpacity?: string;
                            font?: string;
                            fontFamily?: string;
                            fontFeatureSettings?: string;
                            fontKerning?: string;
                            fontOpticalSizing?: string;
                            fontSize?: string;
                            fontSizeAdjust?: string;
                            fontStretch?: string;
                            fontStyle?: string;
                            fontSynthesis?: string;
                            fontVariant?: string;
                            fontVariantAlternates?: string;
                            fontVariantCaps?: string;
                            fontVariantEastAsian?: string;
                            fontVariantLigatures?: string;
                            fontVariantNumeric?: string;
                            fontVariantPosition?: string;
                            fontVariationSettings?: string;
                            fontWeight?: string;
                            gap?: string;
                            grid?: string;
                            gridArea?: string;
                            gridAutoColumns?: string;
                            gridAutoFlow?: string;
                            gridAutoRows?: string;
                            gridColumn?: string;
                            gridColumnEnd?: string;
                            gridColumnGap?: string;
                            gridColumnStart?: string;
                            gridGap?: string;
                            gridRow?: string;
                            gridRowEnd?: string;
                            gridRowGap?: string;
                            gridRowStart?: string;
                            gridTemplate?: string;
                            gridTemplateAreas?: string;
                            gridTemplateColumns?: string;
                            gridTemplateRows?: string;
                            height?: string;
                            hyphens?: string;
                            imageOrientation?: string;
                            imageRendering?: string;
                            inlineSize?: string;
                            inset?: string;
                            insetBlock?: string;
                            insetBlockEnd?: string;
                            insetBlockStart?: string;
                            insetInline?: string;
                            insetInlineEnd?: string;
                            insetInlineStart?: string;
                            isolation?: string;
                            justifyContent?: string;
                            justifyItems?: string;
                            justifySelf?: string;
                            left?: string;
                            readonly length?: number;
                            letterSpacing?: string;
                            lightingColor?: string;
                            lineBreak?: string;
                            lineHeight?: string;
                            listStyle?: string;
                            listStyleImage?: string;
                            listStylePosition?: string;
                            listStyleType?: string;
                            margin?: string;
                            marginBlock?: string;
                            marginBlockEnd?: string;
                            marginBlockStart?: string;
                            marginBottom?: string;
                            marginInline?: string;
                            marginInlineEnd?: string;
                            marginInlineStart?: string;
                            marginLeft?: string;
                            marginRight?: string;
                            marginTop?: string;
                            marker?: string;
                            markerEnd?: string;
                            markerMid?: string;
                            markerStart?: string;
                            mask?: string;
                            maskType?: string;
                            maxBlockSize?: string;
                            maxHeight?: string;
                            maxInlineSize?: string;
                            maxWidth?: string;
                            minBlockSize?: string;
                            minHeight?: string;
                            minInlineSize?: string;
                            minWidth?: string;
                            mixBlendMode?: string;
                            objectFit?: string;
                            objectPosition?: string;
                            offset?: string;
                            offsetAnchor?: string;
                            offsetDistance?: string;
                            offsetPath?: string;
                            offsetRotate?: string;
                            opacity?: string;
                            order?: string;
                            orphans?: string;
                            outline?: string;
                            outlineColor?: string;
                            outlineOffset?: string;
                            outlineStyle?: string;
                            outlineWidth?: string;
                            overflow?: string;
                            overflowAnchor?: string;
                            overflowWrap?: string;
                            overflowX?: string;
                            overflowY?: string;
                            overscrollBehavior?: string;
                            overscrollBehaviorBlock?: string;
                            overscrollBehaviorInline?: string;
                            overscrollBehaviorX?: string;
                            overscrollBehaviorY?: string;
                            padding?: string;
                            paddingBlock?: string;
                            paddingBlockEnd?: string;
                            paddingBlockStart?: string;
                            paddingBottom?: string;
                            paddingInline?: string;
                            paddingInlineEnd?: string;
                            paddingInlineStart?: string;
                            paddingLeft?: string;
                            paddingRight?: string;
                            paddingTop?: string;
                            pageBreakAfter?: string;
                            pageBreakBefore?: string;
                            pageBreakInside?: string;
                            paintOrder?: string;
                            readonly parentRule?: {
                                cssText: string;
                                readonly parentRule: any;
                                readonly parentStyleSheet: {
                                    readonly cssRules: {
                                        [x: number]: any;
                                        readonly length: number;
                                        item: (index: number) => CSSRule;
                                        [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                    };
                                    readonly ownerRule: any;
                                    readonly rules: {
                                        [x: number]: any;
                                        readonly length: number;
                                        item: (index: number) => CSSRule;
                                        [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                    };
                                    addRule: (selector?: string, style?: string, index?: number) => number;
                                    deleteRule: (index: number) => void;
                                    insertRule: (rule: string, index?: number) => number;
                                    removeRule: (index?: number) => void;
                                    disabled: boolean;
                                    readonly href: string;
                                    readonly media: {
                                        [x: number]: string;
                                        readonly length: number;
                                        mediaText: string;
                                        toString: () => string;
                                        appendMedium: (medium: string) => void;
                                        deleteMedium: (medium: string) => void;
                                        item: (index: number) => string;
                                        [Symbol.iterator]: () => IterableIterator<string>;
                                    };
                                    readonly ownerNode: Element | ProcessingInstruction;
                                    readonly parentStyleSheet: any;
                                    readonly title: string;
                                    readonly type: string;
                                };
                                readonly type: number;
                                readonly CHARSET_RULE: number;
                                readonly FONT_FACE_RULE: number;
                                readonly IMPORT_RULE: number;
                                readonly KEYFRAMES_RULE: number;
                                readonly KEYFRAME_RULE: number;
                                readonly MEDIA_RULE: number;
                                readonly NAMESPACE_RULE: number;
                                readonly PAGE_RULE: number;
                                readonly STYLE_RULE: number;
                                readonly SUPPORTS_RULE: number;
                            };
                            perspective?: string;
                            perspectiveOrigin?: string;
                            placeContent?: string;
                            placeItems?: string;
                            placeSelf?: string;
                            pointerEvents?: string;
                            position?: string;
                            quotes?: string;
                            resize?: string;
                            right?: string;
                            rotate?: string;
                            rowGap?: string;
                            rubyPosition?: string;
                            scale?: string;
                            scrollBehavior?: string;
                            scrollMargin?: string;
                            scrollMarginBlock?: string;
                            scrollMarginBlockEnd?: string;
                            scrollMarginBlockStart?: string;
                            scrollMarginBottom?: string;
                            scrollMarginInline?: string;
                            scrollMarginInlineEnd?: string;
                            scrollMarginInlineStart?: string;
                            scrollMarginLeft?: string;
                            scrollMarginRight?: string;
                            scrollMarginTop?: string;
                            scrollPadding?: string;
                            scrollPaddingBlock?: string;
                            scrollPaddingBlockEnd?: string;
                            scrollPaddingBlockStart?: string;
                            scrollPaddingBottom?: string;
                            scrollPaddingInline?: string;
                            scrollPaddingInlineEnd?: string;
                            scrollPaddingInlineStart?: string;
                            scrollPaddingLeft?: string;
                            scrollPaddingRight?: string;
                            scrollPaddingTop?: string;
                            scrollSnapAlign?: string;
                            scrollSnapStop?: string;
                            scrollSnapType?: string;
                            shapeImageThreshold?: string;
                            shapeMargin?: string;
                            shapeOutside?: string;
                            shapeRendering?: string;
                            stopColor?: string;
                            stopOpacity?: string;
                            stroke?: string;
                            strokeDasharray?: string;
                            strokeDashoffset?: string;
                            strokeLinecap?: string;
                            strokeLinejoin?: string;
                            strokeMiterlimit?: string;
                            strokeOpacity?: string;
                            strokeWidth?: string;
                            tabSize?: string;
                            tableLayout?: string;
                            textAlign?: string;
                            textAlignLast?: string;
                            textAnchor?: string;
                            textCombineUpright?: string;
                            textDecoration?: string;
                            textDecorationColor?: string;
                            textDecorationLine?: string;
                            textDecorationSkipInk?: string;
                            textDecorationStyle?: string;
                            textDecorationThickness?: string;
                            textEmphasis?: string;
                            textEmphasisColor?: string;
                            textEmphasisPosition?: string;
                            textEmphasisStyle?: string;
                            textIndent?: string;
                            textOrientation?: string;
                            textOverflow?: string;
                            textRendering?: string;
                            textShadow?: string;
                            textTransform?: string;
                            textUnderlineOffset?: string;
                            textUnderlinePosition?: string;
                            top?: string;
                            touchAction?: string;
                            transform?: string;
                            transformBox?: string;
                            transformOrigin?: string;
                            transformStyle?: string;
                            transition?: string;
                            transitionDelay?: string;
                            transitionDuration?: string;
                            transitionProperty?: string;
                            transitionTimingFunction?: string;
                            translate?: string;
                            unicodeBidi?: string;
                            userSelect?: string;
                            verticalAlign?: string;
                            visibility?: string;
                            webkitAlignContent?: string;
                            webkitAlignItems?: string;
                            webkitAlignSelf?: string;
                            webkitAnimation?: string;
                            webkitAnimationDelay?: string;
                            webkitAnimationDirection?: string;
                            webkitAnimationDuration?: string;
                            webkitAnimationFillMode?: string;
                            webkitAnimationIterationCount?: string;
                            webkitAnimationName?: string;
                            webkitAnimationPlayState?: string;
                            webkitAnimationTimingFunction?: string;
                            webkitAppearance?: string;
                            webkitBackfaceVisibility?: string;
                            webkitBackgroundClip?: string;
                            webkitBackgroundOrigin?: string;
                            webkitBackgroundSize?: string;
                            webkitBorderBottomLeftRadius?: string;
                            webkitBorderBottomRightRadius?: string;
                            webkitBorderRadius?: string;
                            webkitBorderTopLeftRadius?: string;
                            webkitBorderTopRightRadius?: string;
                            webkitBoxAlign?: string;
                            webkitBoxFlex?: string;
                            webkitBoxOrdinalGroup?: string;
                            webkitBoxOrient?: string;
                            webkitBoxPack?: string;
                            webkitBoxShadow?: string;
                            webkitBoxSizing?: string;
                            webkitFilter?: string;
                            webkitFlex?: string;
                            webkitFlexBasis?: string;
                            webkitFlexDirection?: string;
                            webkitFlexFlow?: string;
                            webkitFlexGrow?: string;
                            webkitFlexShrink?: string;
                            webkitFlexWrap?: string;
                            webkitJustifyContent?: string;
                            webkitLineClamp?: string;
                            webkitMask?: string;
                            webkitMaskBoxImage?: string;
                            webkitMaskBoxImageOutset?: string;
                            webkitMaskBoxImageRepeat?: string;
                            webkitMaskBoxImageSlice?: string;
                            webkitMaskBoxImageSource?: string;
                            webkitMaskBoxImageWidth?: string;
                            webkitMaskClip?: string;
                            webkitMaskComposite?: string;
                            webkitMaskImage?: string;
                            webkitMaskOrigin?: string;
                            webkitMaskPosition?: string;
                            webkitMaskRepeat?: string;
                            webkitMaskSize?: string;
                            webkitOrder?: string;
                            webkitPerspective?: string;
                            webkitPerspectiveOrigin?: string;
                            webkitTextFillColor?: string;
                            webkitTextStroke?: string;
                            webkitTextStrokeColor?: string;
                            webkitTextStrokeWidth?: string;
                            webkitTransform?: string;
                            webkitTransformOrigin?: string;
                            webkitTransformStyle?: string;
                            webkitTransition?: string;
                            webkitTransitionDelay?: string;
                            webkitTransitionDuration?: string;
                            webkitTransitionProperty?: string;
                            webkitTransitionTimingFunction?: string;
                            webkitUserSelect?: string;
                            whiteSpace?: string;
                            widows?: string;
                            width?: string;
                            willChange?: string;
                            wordBreak?: string;
                            wordSpacing?: string;
                            wordWrap?: string;
                            writingMode?: string;
                            zIndex?: string;
                            getPropertyPriority?: (property: string) => string;
                            getPropertyValue?: (property: string) => string;
                            item?: (index: number) => string;
                            removeProperty?: (property: string) => string;
                            setProperty?: (property: string, value: string, priority?: string) => void;
                            [Symbol.iterator]?: () => IterableIterator<string>;
                        };
                    }>;
                    instanceRef: import("vue").ComputedRef<import("@popperjs/core").Instance>;
                    role: import("vue").ComputedRef<string>;
                    update: () => Promise<Partial<import("@popperjs/core").State>>;
                    ariaModal: import("vue").ComputedRef<string>;
                    arrowStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
                    contentAttrs: import("vue").ComputedRef<{
                        [x: string]: string | boolean;
                    }>;
                    contentClass: import("vue").ComputedRef<(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)[])[])[])[])[])[])[])[])[])[])[])[]>;
                    contentStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
                    updateZIndex: () => void;
                    formItemContext: import("hongluan-ui/es/tokens").FormItemContext;
                    arrowOffset: import("vue").Ref<number>;
                    triggerTargetAriaStopWatch: import("vue").WatchStopHandle;
                    updatePopper: (shouldUpdateZIndex?: boolean) => void;
                    togglePopperAlive: () => void;
                    HlFocusTrap: import("vue").DefineComponent<{
                        loop: BooleanConstructor;
                        trapped: BooleanConstructor;
                        focusTrapEl: import("vue").PropType<HTMLElement>;
                        focusStartEl: {
                            type: import("vue").PropType<HTMLElement | "first" | "container">;
                            default: string;
                        };
                    }, {
                        onKeydown: (e: KeyboardEvent) => void;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested")[], "focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                        loop: BooleanConstructor;
                        trapped: BooleanConstructor;
                        focusTrapEl: import("vue").PropType<HTMLElement>;
                        focusStartEl: {
                            type: import("vue").PropType<HTMLElement | "first" | "container">;
                            default: string;
                        };
                    }>> & {
                        onFocusAfterReleased?: (...args: any[]) => any;
                        onFocusAfterTrapped?: (...args: any[]) => any;
                        onFocusin?: (...args: any[]) => any;
                        onFocusout?: (...args: any[]) => any;
                        "onFocusout-prevented"?: (...args: any[]) => any;
                        "onRelease-requested"?: (...args: any[]) => any;
                    }, {
                        trapped: boolean;
                        loop: boolean;
                        focusStartEl: HTMLElement | "first" | "container";
                    }>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                    mouseenter: (evt: MouseEvent) => boolean;
                    mouseleave: (evt: MouseEvent) => boolean;
                    focus: () => boolean;
                    blur: () => boolean;
                    close: () => boolean;
                }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly visible: BooleanConstructor;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                }>> & {
                    onClose?: () => any;
                    onBlur?: () => any;
                    onFocus?: () => any;
                    onMouseleave?: (evt: MouseEvent) => any;
                    onMouseenter?: (evt: MouseEvent) => any;
                }, {
                    offset: number;
                    placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                    effect: string;
                    visible: boolean;
                    boundariesPadding: number;
                    gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    popperOptions: Partial<import("@popperjs/core").Options>;
                    strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                    enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    pure: boolean;
                    virtualTriggering: 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 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").PropType<string>, unknown, unknown, "", boolean>;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            }>>, {
                disabled: boolean;
                offset: number;
                placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                transition: string;
                effect: string;
                showAfter: number;
                hideAfter: number;
                autoClose: number;
                boundariesPadding: number;
                gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                popperOptions: Partial<import("@popperjs/core").Options>;
                strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                pure: boolean;
                virtualTriggering: boolean;
                content: string;
                teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
                rawContent: boolean;
                persistent: boolean;
            }>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, string[], string, {
            disabled: boolean;
            trigger: import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>, unknown, unknown>;
            offset: number;
            placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
            transition: string;
            effect: string;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            boundariesPadding: number;
            gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            popperOptions: Partial<import("@popperjs/core").Options>;
            strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
            enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            pure: boolean;
            virtualTriggering: boolean;
            content: string;
            teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
            rawContent: boolean;
            persistent: boolean;
            open: boolean;
            role: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "tooltip" | "listbox" | "grid" | "menu" | "dialog" | "group" | "navigation" | "tree", unknown>;
            triggerKeys: string[];
            arrowOffset: number;
            showArrow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, 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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof nextTick;
        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
    } & 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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
        popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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;
    } & import("vue").ShallowUnwrapRef<{
        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("hongluan-ui/es/components/tooltip").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("@popperjs/core").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("@popperjs/core").Placement, unknown, "bottom", boolean>;
            popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
            $parent: 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: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
            };
            $forceUpdate: () => void;
            $nextTick: typeof 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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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("hongluan-ui/es/components/tooltip").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").PropType<string>, unknown, unknown, "", boolean>;
            readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly pure: BooleanConstructor;
            readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly 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;
            };
            readonly popperStyle: {
                readonly type: import("vue").PropType<unknown>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly referenceEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly triggerTargetEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly virtualTriggering: BooleanConstructor;
            readonly zIndex: NumberConstructor;
            readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly fallbackPlacements: {
                readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
            readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
            readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
            readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
            readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        }, {
            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                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").PropType<string>, unknown, unknown, "", boolean>;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
                readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            }>> & {
                [x: string & `on${string}`]: ((...args: any[]) => any) | ((...args: unknown[]) => any);
            }>>;
            selector: import("vue").ComputedRef<string>;
            contentRef: any;
            stopHandle: () => void;
            controlled: import("vue").Ref<boolean>;
            id: import("vue").Ref<string>;
            open: import("vue").Ref<boolean>;
            trigger: import("vue").Ref<import("hongluan-ui/es/utils").Arrayable<import("hongluan-ui/es/components/tooltip").TooltipTriggerType>>;
            onClose: (e?: Event) => void;
            onOpen: (e?: Event) => void;
            onShow: () => void;
            onHide: () => void;
            onBeforeShow: () => void;
            onBeforeHide: () => void;
            persistentRef: import("vue").ComputedRef<boolean>;
            shouldRender: import("vue").ComputedRef<boolean>;
            shouldShow: import("vue").ComputedRef<boolean>;
            appendTo: import("vue").ComputedRef<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
            contentStyle: import("vue").ComputedRef<any>;
            ariaHidden: import("vue").ComputedRef<boolean>;
            onTransitionLeave: () => void;
            stopWhenControlled: () => boolean;
            onContentEnter: (event: unknown) => void;
            onContentLeave: (event: unknown) => void;
            onBeforeEnter: () => void;
            onBeforeLeave: () => void;
            onAfterShow: () => void;
            onBlur: () => void;
            HlTeleport: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
                readonly to: {
                    readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                    readonly required: true;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
            }, {
                COMPONENT_NAME: string;
            }, 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 to: {
                    readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<import("vue").PropType<string | HTMLElement>, unknown, unknown>>;
                    readonly required: true;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly disabled: BooleanConstructor;
            }>>, {
                disabled: boolean;
            }>> & Record<string, any>;
            HlPopperContent: import("vue").DefineComponent<{
                readonly ariaLabel: StringConstructor;
                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").PropType<string>, unknown, unknown, "", boolean>;
                readonly visible: BooleanConstructor;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            }, {
                emit: ((event: "blur") => void) & ((event: "focus") => void) & ((event: "close") => void) & ((event: "mouseleave", evt: MouseEvent) => void) & ((event: "mouseenter", evt: MouseEvent) => void);
                props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    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").PropType<string>, unknown, unknown, "", boolean>;
                    readonly visible: BooleanConstructor;
                    readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly pure: BooleanConstructor;
                    readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly 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;
                    };
                    readonly popperStyle: {
                        readonly type: import("vue").PropType<unknown>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly referenceEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly triggerTargetEl: {
                        readonly type: import("vue").PropType<HTMLElement>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly virtualTriggering: BooleanConstructor;
                    readonly zIndex: NumberConstructor;
                    readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                    readonly fallbackPlacements: {
                        readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                    readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                    readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                    readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                    readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
                }>> & {
                    onClose?: () => any;
                    onBlur?: () => any;
                    onFocus?: () => any;
                    onMouseleave?: (evt: MouseEvent) => any;
                    onMouseenter?: (evt: MouseEvent) => any;
                }>>;
                focusStartRef: import("vue").Ref<HTMLElement | "first" | "container">;
                trapped: import("vue").Ref<boolean>;
                onFocusAfterReleased: (event: CustomEvent<any>) => void;
                onFocusAfterTrapped: () => void;
                onFocusInTrap: (event: FocusEvent) => void;
                onFocusoutPrevented: (event: CustomEvent<any>) => void;
                onReleaseRequested: () => void;
                attributes: import("vue").ComputedRef<{
                    [x: string]: {
                        [x: string]: string | boolean;
                    };
                }>;
                arrowRef: import("vue").Ref<HTMLElement>;
                contentRef: import("vue").Ref<HTMLElement>;
                styles: import("vue").ComputedRef<{
                    [x: string]: {
                        [x: number]: string;
                        accentColor?: string;
                        alignContent?: string;
                        alignItems?: string;
                        alignSelf?: string;
                        alignmentBaseline?: string;
                        all?: string;
                        animation?: string;
                        animationDelay?: string;
                        animationDirection?: string;
                        animationDuration?: string;
                        animationFillMode?: string;
                        animationIterationCount?: string;
                        animationName?: string;
                        animationPlayState?: string;
                        animationTimingFunction?: string;
                        appearance?: string;
                        aspectRatio?: string;
                        backfaceVisibility?: string;
                        background?: string;
                        backgroundAttachment?: string;
                        backgroundBlendMode?: string;
                        backgroundClip?: string;
                        backgroundColor?: string;
                        backgroundImage?: string;
                        backgroundOrigin?: string;
                        backgroundPosition?: string;
                        backgroundPositionX?: string;
                        backgroundPositionY?: string;
                        backgroundRepeat?: string;
                        backgroundSize?: string;
                        baselineShift?: string;
                        blockSize?: string;
                        border?: string;
                        borderBlock?: string;
                        borderBlockColor?: string;
                        borderBlockEnd?: string;
                        borderBlockEndColor?: string;
                        borderBlockEndStyle?: string;
                        borderBlockEndWidth?: string;
                        borderBlockStart?: string;
                        borderBlockStartColor?: string;
                        borderBlockStartStyle?: string;
                        borderBlockStartWidth?: string;
                        borderBlockStyle?: string;
                        borderBlockWidth?: string;
                        borderBottom?: string;
                        borderBottomColor?: string;
                        borderBottomLeftRadius?: string;
                        borderBottomRightRadius?: string;
                        borderBottomStyle?: string;
                        borderBottomWidth?: string;
                        borderCollapse?: string;
                        borderColor?: string;
                        borderEndEndRadius?: string;
                        borderEndStartRadius?: string;
                        borderImage?: string;
                        borderImageOutset?: string;
                        borderImageRepeat?: string;
                        borderImageSlice?: string;
                        borderImageSource?: string;
                        borderImageWidth?: string;
                        borderInline?: string;
                        borderInlineColor?: string;
                        borderInlineEnd?: string;
                        borderInlineEndColor?: string;
                        borderInlineEndStyle?: string;
                        borderInlineEndWidth?: string;
                        borderInlineStart?: string;
                        borderInlineStartColor?: string;
                        borderInlineStartStyle?: string;
                        borderInlineStartWidth?: string;
                        borderInlineStyle?: string;
                        borderInlineWidth?: string;
                        borderLeft?: string;
                        borderLeftColor?: string;
                        borderLeftStyle?: string;
                        borderLeftWidth?: string;
                        borderRadius?: string;
                        borderRight?: string;
                        borderRightColor?: string;
                        borderRightStyle?: string;
                        borderRightWidth?: string;
                        borderSpacing?: string;
                        borderStartEndRadius?: string;
                        borderStartStartRadius?: string;
                        borderStyle?: string;
                        borderTop?: string;
                        borderTopColor?: string;
                        borderTopLeftRadius?: string;
                        borderTopRightRadius?: string;
                        borderTopStyle?: string;
                        borderTopWidth?: string;
                        borderWidth?: string;
                        bottom?: string;
                        boxShadow?: string;
                        boxSizing?: string;
                        breakAfter?: string;
                        breakBefore?: string;
                        breakInside?: string;
                        captionSide?: string;
                        caretColor?: string;
                        clear?: string;
                        clip?: string;
                        clipPath?: string;
                        clipRule?: string;
                        color?: string;
                        colorInterpolation?: string;
                        colorInterpolationFilters?: string;
                        colorScheme?: string;
                        columnCount?: string;
                        columnFill?: string;
                        columnGap?: string;
                        columnRule?: string;
                        columnRuleColor?: string;
                        columnRuleStyle?: string;
                        columnRuleWidth?: string;
                        columnSpan?: string;
                        columnWidth?: string;
                        columns?: string;
                        contain?: string;
                        content?: string;
                        counterIncrement?: string;
                        counterReset?: string;
                        counterSet?: string;
                        cssFloat?: string;
                        cssText?: string;
                        cursor?: string;
                        direction?: string;
                        display?: string;
                        dominantBaseline?: string;
                        emptyCells?: string;
                        fill?: string;
                        fillOpacity?: string;
                        fillRule?: string;
                        filter?: string;
                        flex?: string;
                        flexBasis?: string;
                        flexDirection?: string;
                        flexFlow?: string;
                        flexGrow?: string;
                        flexShrink?: string;
                        flexWrap?: string;
                        float?: string;
                        floodColor?: string;
                        floodOpacity?: string;
                        font?: string;
                        fontFamily?: string;
                        fontFeatureSettings?: string;
                        fontKerning?: string;
                        fontOpticalSizing?: string;
                        fontSize?: string;
                        fontSizeAdjust?: string;
                        fontStretch?: string;
                        fontStyle?: string;
                        fontSynthesis?: string;
                        fontVariant?: string;
                        fontVariantAlternates?: string;
                        fontVariantCaps?: string;
                        fontVariantEastAsian?: string;
                        fontVariantLigatures?: string;
                        fontVariantNumeric?: string;
                        fontVariantPosition?: string;
                        fontVariationSettings?: string;
                        fontWeight?: string;
                        gap?: string;
                        grid?: string;
                        gridArea?: string;
                        gridAutoColumns?: string;
                        gridAutoFlow?: string;
                        gridAutoRows?: string;
                        gridColumn?: string;
                        gridColumnEnd?: string;
                        gridColumnGap?: string;
                        gridColumnStart?: string;
                        gridGap?: string;
                        gridRow?: string;
                        gridRowEnd?: string;
                        gridRowGap?: string;
                        gridRowStart?: string;
                        gridTemplate?: string;
                        gridTemplateAreas?: string;
                        gridTemplateColumns?: string;
                        gridTemplateRows?: string;
                        height?: string;
                        hyphens?: string;
                        imageOrientation?: string;
                        imageRendering?: string;
                        inlineSize?: string;
                        inset?: string;
                        insetBlock?: string;
                        insetBlockEnd?: string;
                        insetBlockStart?: string;
                        insetInline?: string;
                        insetInlineEnd?: string;
                        insetInlineStart?: string;
                        isolation?: string;
                        justifyContent?: string;
                        justifyItems?: string;
                        justifySelf?: string;
                        left?: string;
                        readonly length?: number;
                        letterSpacing?: string;
                        lightingColor?: string;
                        lineBreak?: string;
                        lineHeight?: string;
                        listStyle?: string;
                        listStyleImage?: string;
                        listStylePosition?: string;
                        listStyleType?: string;
                        margin?: string;
                        marginBlock?: string;
                        marginBlockEnd?: string;
                        marginBlockStart?: string;
                        marginBottom?: string;
                        marginInline?: string;
                        marginInlineEnd?: string;
                        marginInlineStart?: string;
                        marginLeft?: string;
                        marginRight?: string;
                        marginTop?: string;
                        marker?: string;
                        markerEnd?: string;
                        markerMid?: string;
                        markerStart?: string;
                        mask?: string;
                        maskType?: string;
                        maxBlockSize?: string;
                        maxHeight?: string;
                        maxInlineSize?: string;
                        maxWidth?: string;
                        minBlockSize?: string;
                        minHeight?: string;
                        minInlineSize?: string;
                        minWidth?: string;
                        mixBlendMode?: string;
                        objectFit?: string;
                        objectPosition?: string;
                        offset?: string;
                        offsetAnchor?: string;
                        offsetDistance?: string;
                        offsetPath?: string;
                        offsetRotate?: string;
                        opacity?: string;
                        order?: string;
                        orphans?: string;
                        outline?: string;
                        outlineColor?: string;
                        outlineOffset?: string;
                        outlineStyle?: string;
                        outlineWidth?: string;
                        overflow?: string;
                        overflowAnchor?: string;
                        overflowWrap?: string;
                        overflowX?: string;
                        overflowY?: string;
                        overscrollBehavior?: string;
                        overscrollBehaviorBlock?: string;
                        overscrollBehaviorInline?: string;
                        overscrollBehaviorX?: string;
                        overscrollBehaviorY?: string;
                        padding?: string;
                        paddingBlock?: string;
                        paddingBlockEnd?: string;
                        paddingBlockStart?: string;
                        paddingBottom?: string;
                        paddingInline?: string;
                        paddingInlineEnd?: string;
                        paddingInlineStart?: string;
                        paddingLeft?: string;
                        paddingRight?: string;
                        paddingTop?: string;
                        pageBreakAfter?: string;
                        pageBreakBefore?: string;
                        pageBreakInside?: string;
                        paintOrder?: string;
                        readonly parentRule?: {
                            cssText: string;
                            readonly parentRule: any;
                            readonly parentStyleSheet: {
                                readonly cssRules: {
                                    [x: number]: any;
                                    readonly length: number;
                                    item: (index: number) => CSSRule;
                                    [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                };
                                readonly ownerRule: any;
                                readonly rules: {
                                    [x: number]: any;
                                    readonly length: number;
                                    item: (index: number) => CSSRule;
                                    [Symbol.iterator]: () => IterableIterator<CSSRule>;
                                };
                                addRule: (selector?: string, style?: string, index?: number) => number;
                                deleteRule: (index: number) => void;
                                insertRule: (rule: string, index?: number) => number;
                                removeRule: (index?: number) => void;
                                disabled: boolean;
                                readonly href: string;
                                readonly media: {
                                    [x: number]: string;
                                    readonly length: number;
                                    mediaText: string;
                                    toString: () => string;
                                    appendMedium: (medium: string) => void;
                                    deleteMedium: (medium: string) => void;
                                    item: (index: number) => string;
                                    [Symbol.iterator]: () => IterableIterator<string>;
                                };
                                readonly ownerNode: Element | ProcessingInstruction;
                                readonly parentStyleSheet: any;
                                readonly title: string;
                                readonly type: string;
                            };
                            readonly type: number;
                            readonly CHARSET_RULE: number;
                            readonly FONT_FACE_RULE: number;
                            readonly IMPORT_RULE: number;
                            readonly KEYFRAMES_RULE: number;
                            readonly KEYFRAME_RULE: number;
                            readonly MEDIA_RULE: number;
                            readonly NAMESPACE_RULE: number;
                            readonly PAGE_RULE: number;
                            readonly STYLE_RULE: number;
                            readonly SUPPORTS_RULE: number;
                        };
                        perspective?: string;
                        perspectiveOrigin?: string;
                        placeContent?: string;
                        placeItems?: string;
                        placeSelf?: string;
                        pointerEvents?: string;
                        position?: string;
                        quotes?: string;
                        resize?: string;
                        right?: string;
                        rotate?: string;
                        rowGap?: string;
                        rubyPosition?: string;
                        scale?: string;
                        scrollBehavior?: string;
                        scrollMargin?: string;
                        scrollMarginBlock?: string;
                        scrollMarginBlockEnd?: string;
                        scrollMarginBlockStart?: string;
                        scrollMarginBottom?: string;
                        scrollMarginInline?: string;
                        scrollMarginInlineEnd?: string;
                        scrollMarginInlineStart?: string;
                        scrollMarginLeft?: string;
                        scrollMarginRight?: string;
                        scrollMarginTop?: string;
                        scrollPadding?: string;
                        scrollPaddingBlock?: string;
                        scrollPaddingBlockEnd?: string;
                        scrollPaddingBlockStart?: string;
                        scrollPaddingBottom?: string;
                        scrollPaddingInline?: string;
                        scrollPaddingInlineEnd?: string;
                        scrollPaddingInlineStart?: string;
                        scrollPaddingLeft?: string;
                        scrollPaddingRight?: string;
                        scrollPaddingTop?: string;
                        scrollSnapAlign?: string;
                        scrollSnapStop?: string;
                        scrollSnapType?: string;
                        shapeImageThreshold?: string;
                        shapeMargin?: string;
                        shapeOutside?: string;
                        shapeRendering?: string;
                        stopColor?: string;
                        stopOpacity?: string;
                        stroke?: string;
                        strokeDasharray?: string;
                        strokeDashoffset?: string;
                        strokeLinecap?: string;
                        strokeLinejoin?: string;
                        strokeMiterlimit?: string;
                        strokeOpacity?: string;
                        strokeWidth?: string;
                        tabSize?: string;
                        tableLayout?: string;
                        textAlign?: string;
                        textAlignLast?: string;
                        textAnchor?: string;
                        textCombineUpright?: string;
                        textDecoration?: string;
                        textDecorationColor?: string;
                        textDecorationLine?: string;
                        textDecorationSkipInk?: string;
                        textDecorationStyle?: string;
                        textDecorationThickness?: string;
                        textEmphasis?: string;
                        textEmphasisColor?: string;
                        textEmphasisPosition?: string;
                        textEmphasisStyle?: string;
                        textIndent?: string;
                        textOrientation?: string;
                        textOverflow?: string;
                        textRendering?: string;
                        textShadow?: string;
                        textTransform?: string;
                        textUnderlineOffset?: string;
                        textUnderlinePosition?: string;
                        top?: string;
                        touchAction?: string;
                        transform?: string;
                        transformBox?: string;
                        transformOrigin?: string;
                        transformStyle?: string;
                        transition?: string;
                        transitionDelay?: string;
                        transitionDuration?: string;
                        transitionProperty?: string;
                        transitionTimingFunction?: string;
                        translate?: string;
                        unicodeBidi?: string;
                        userSelect?: string;
                        verticalAlign?: string;
                        visibility?: string;
                        webkitAlignContent?: string;
                        webkitAlignItems?: string;
                        webkitAlignSelf?: string;
                        webkitAnimation?: string;
                        webkitAnimationDelay?: string;
                        webkitAnimationDirection?: string;
                        webkitAnimationDuration?: string;
                        webkitAnimationFillMode?: string;
                        webkitAnimationIterationCount?: string;
                        webkitAnimationName?: string;
                        webkitAnimationPlayState?: string;
                        webkitAnimationTimingFunction?: string;
                        webkitAppearance?: string;
                        webkitBackfaceVisibility?: string;
                        webkitBackgroundClip?: string;
                        webkitBackgroundOrigin?: string;
                        webkitBackgroundSize?: string;
                        webkitBorderBottomLeftRadius?: string;
                        webkitBorderBottomRightRadius?: string;
                        webkitBorderRadius?: string;
                        webkitBorderTopLeftRadius?: string;
                        webkitBorderTopRightRadius?: string;
                        webkitBoxAlign?: string;
                        webkitBoxFlex?: string;
                        webkitBoxOrdinalGroup?: string;
                        webkitBoxOrient?: string;
                        webkitBoxPack?: string;
                        webkitBoxShadow?: string;
                        webkitBoxSizing?: string;
                        webkitFilter?: string;
                        webkitFlex?: string;
                        webkitFlexBasis?: string;
                        webkitFlexDirection?: string;
                        webkitFlexFlow?: string;
                        webkitFlexGrow?: string;
                        webkitFlexShrink?: string;
                        webkitFlexWrap?: string;
                        webkitJustifyContent?: string;
                        webkitLineClamp?: string;
                        webkitMask?: string;
                        webkitMaskBoxImage?: string;
                        webkitMaskBoxImageOutset?: string;
                        webkitMaskBoxImageRepeat?: string;
                        webkitMaskBoxImageSlice?: string;
                        webkitMaskBoxImageSource?: string;
                        webkitMaskBoxImageWidth?: string;
                        webkitMaskClip?: string;
                        webkitMaskComposite?: string;
                        webkitMaskImage?: string;
                        webkitMaskOrigin?: string;
                        webkitMaskPosition?: string;
                        webkitMaskRepeat?: string;
                        webkitMaskSize?: string;
                        webkitOrder?: string;
                        webkitPerspective?: string;
                        webkitPerspectiveOrigin?: string;
                        webkitTextFillColor?: string;
                        webkitTextStroke?: string;
                        webkitTextStrokeColor?: string;
                        webkitTextStrokeWidth?: string;
                        webkitTransform?: string;
                        webkitTransformOrigin?: string;
                        webkitTransformStyle?: string;
                        webkitTransition?: string;
                        webkitTransitionDelay?: string;
                        webkitTransitionDuration?: string;
                        webkitTransitionProperty?: string;
                        webkitTransitionTimingFunction?: string;
                        webkitUserSelect?: string;
                        whiteSpace?: string;
                        widows?: string;
                        width?: string;
                        willChange?: string;
                        wordBreak?: string;
                        wordSpacing?: string;
                        wordWrap?: string;
                        writingMode?: string;
                        zIndex?: string;
                        getPropertyPriority?: (property: string) => string;
                        getPropertyValue?: (property: string) => string;
                        item?: (index: number) => string;
                        removeProperty?: (property: string) => string;
                        setProperty?: (property: string, value: string, priority?: string) => void;
                        [Symbol.iterator]?: () => IterableIterator<string>;
                    };
                }>;
                instanceRef: import("vue").ComputedRef<import("@popperjs/core").Instance>;
                role: import("vue").ComputedRef<string>;
                update: () => Promise<Partial<import("@popperjs/core").State>>;
                ariaModal: import("vue").ComputedRef<string>;
                arrowStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
                contentAttrs: import("vue").ComputedRef<{
                    [x: string]: string | boolean;
                }>;
                contentClass: import("vue").ComputedRef<(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)[])[])[])[])[])[])[])[])[])[])[])[]>;
                contentStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
                updateZIndex: () => void;
                formItemContext: import("hongluan-ui/es/tokens").FormItemContext;
                arrowOffset: import("vue").Ref<number>;
                triggerTargetAriaStopWatch: import("vue").WatchStopHandle;
                updatePopper: (shouldUpdateZIndex?: boolean) => void;
                togglePopperAlive: () => void;
                HlFocusTrap: import("vue").DefineComponent<{
                    loop: BooleanConstructor;
                    trapped: BooleanConstructor;
                    focusTrapEl: import("vue").PropType<HTMLElement>;
                    focusStartEl: {
                        type: import("vue").PropType<HTMLElement | "first" | "container">;
                        default: string;
                    };
                }, {
                    onKeydown: (e: KeyboardEvent) => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested")[], "focusAfterTrapped" | "focusAfterReleased" | "focusin" | "focusout" | "focusout-prevented" | "release-requested", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                    loop: BooleanConstructor;
                    trapped: BooleanConstructor;
                    focusTrapEl: import("vue").PropType<HTMLElement>;
                    focusStartEl: {
                        type: import("vue").PropType<HTMLElement | "first" | "container">;
                        default: string;
                    };
                }>> & {
                    onFocusAfterReleased?: (...args: any[]) => any;
                    onFocusAfterTrapped?: (...args: any[]) => any;
                    onFocusin?: (...args: any[]) => any;
                    onFocusout?: (...args: any[]) => any;
                    "onFocusout-prevented"?: (...args: any[]) => any;
                    "onRelease-requested"?: (...args: any[]) => any;
                }, {
                    trapped: boolean;
                    loop: boolean;
                    focusStartEl: HTMLElement | "first" | "container";
                }>;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
                mouseenter: (evt: MouseEvent) => boolean;
                mouseleave: (evt: MouseEvent) => boolean;
                focus: () => boolean;
                blur: () => boolean;
                close: () => boolean;
            }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                readonly ariaLabel: StringConstructor;
                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").PropType<string>, unknown, unknown, "", boolean>;
                readonly visible: BooleanConstructor;
                readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly pure: BooleanConstructor;
                readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly 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;
                };
                readonly popperStyle: {
                    readonly type: import("vue").PropType<unknown>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly referenceEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly triggerTargetEl: {
                    readonly type: import("vue").PropType<HTMLElement>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly virtualTriggering: BooleanConstructor;
                readonly zIndex: NumberConstructor;
                readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
                readonly fallbackPlacements: {
                    readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
                readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
                readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
                readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            }>> & {
                onClose?: () => any;
                onBlur?: () => any;
                onFocus?: () => any;
                onMouseleave?: (evt: MouseEvent) => any;
                onMouseenter?: (evt: MouseEvent) => any;
            }, {
                offset: number;
                placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
                effect: string;
                visible: boolean;
                boundariesPadding: number;
                gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                popperOptions: Partial<import("@popperjs/core").Options>;
                strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
                enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                pure: boolean;
                virtualTriggering: 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 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").PropType<string>, unknown, unknown, "", boolean>;
            readonly enterable: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly pure: BooleanConstructor;
            readonly focusOnShow: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly trapping: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
            readonly 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;
            };
            readonly popperStyle: {
                readonly type: import("vue").PropType<unknown>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly referenceEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly triggerTargetEl: {
                readonly type: import("vue").PropType<HTMLElement>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly virtualTriggering: BooleanConstructor;
            readonly zIndex: NumberConstructor;
            readonly boundariesPadding: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly fallbackPlacements: {
                readonly type: import("vue").PropType<import("@popperjs/core").Placement[]>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly gpuAcceleration: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly offset: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 8, boolean>;
            readonly placement: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, import("@popperjs/core").Placement, unknown, "bottom", boolean>;
            readonly popperOptions: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<Partial<import("@popperjs/core").Options>>, unknown, unknown, () => Partial<import("@popperjs/core").Options>, boolean>;
            readonly strategy: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, "fixed" | "absolute", unknown, "absolute", boolean>;
            readonly showAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
            readonly hideAfter: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 200, boolean>;
            readonly autoClose: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 0, boolean>;
        }>>, {
            disabled: boolean;
            offset: number;
            placement: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, import("@popperjs/core").Placement, unknown>;
            transition: string;
            effect: string;
            showAfter: number;
            hideAfter: number;
            autoClose: number;
            boundariesPadding: number;
            gpuAcceleration: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            popperOptions: Partial<import("@popperjs/core").Options>;
            strategy: import("hongluan-ui/es/utils").EpPropMergeType<StringConstructor, "fixed" | "absolute", unknown>;
            enterable: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            focusOnShow: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            trapping: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            stopPopperMouseEvent: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            pure: boolean;
            virtualTriggering: boolean;
            content: string;
            teleported: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
            outsideIgnore: import("@vueuse/core").MaybeElementRef<import("@vueuse/core").MaybeElement>[];
            rawContent: boolean;
            persistent: boolean;
        }>;
    }> & {} & {} & import("vue").ComponentCustomProperties>;
    tags: import("vue").Ref<HTMLElement>;
    selectWrapper: import("vue").Ref<HTMLElement>;
    scrollbar: import("vue").Ref<{
        handleScroll: () => void;
    }>;
    handleMouseEnter: () => void;
    handleMouseLeave: () => void;
};
export {};