hongluan-ui/es/components/select/src/useSelect.d.ts

Hongluan Component Library for Vue 3

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, a