hongluan-ui/lib/components/autocomplete/index.d.ts

Hongluan Component Library for Vue 3

export declare const HlAutocomplete: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
    ariaLabel: StringConstructor;
    valueKey: {
        type: StringConstructor;
        default: string;
    };
    modelValue: {
        type: (StringConstructor | NumberConstructor)[];
        default: string;
    };
    debounce: {
        type: NumberConstructor;
        default: number;
    };
    placement: {
        type: import("vue").PropType<import("@popperjs/core").Placement>;
        validator: (val: string) => boolean;
        default: string;
    };
    fetchSuggestions: {
        type: import("vue").PropType<import("./src/autocomplete").AutocompleteFetchSuggestions>;
        default: () => void;
    };
    popperClass: {
        type: StringConstructor;
        default: string;
    };
    triggerOnFocus: {
        type: BooleanConstructor;
        default: boolean;
    };
    selectWhenUnmatched: {
        type: BooleanConstructor;
        default: boolean;
    };
    hideLoading: {
        type: BooleanConstructor;
        default: boolean;
    };
    popperAppendToBody: {
        type: BooleanConstructor;
        default: any;
    };
    teleported: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    highlightFirstItem: {
        type: BooleanConstructor;
        default: boolean;
    };
    block: {
        type: BooleanConstructor;
        default: boolean;
    };
    size: {
        type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
        validator: (val: string) => boolean;
    };
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    disabled: BooleanConstructor;
    fill: BooleanConstructor;
    thin: BooleanConstructor;
    popperOffset: {
        type: NumberConstructor;
        default: number;
    };
    fitInputWidth: {
        type: BooleanConstructor;
        default: boolean;
    };
    transition: {
        type: StringConstructor;
        default: string;
    };
    name: StringConstructor;
}, {
    COMPONENT_NAME: string;
    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
        ariaLabel: StringConstructor;
        valueKey: {
            type: StringConstructor;
            default: string;
        };
        modelValue: {
            type: (StringConstructor | NumberConstructor)[];
            default: string;
        };
        debounce: {
            type: NumberConstructor;
            default: number;
        };
        placement: {
            type: import("vue").PropType<import("@popperjs/core").Placement>;
            validator: (val: string) => boolean;
            default: string;
        };
        fetchSuggestions: {
            type: import("vue").PropType<import("./src/autocomplete").AutocompleteFetchSuggestions>;
            default: () => void;
        };
        popperClass: {
            type: StringConstructor;
            default: string;
        };
        triggerOnFocus: {
            type: BooleanConstructor;
            default: boolean;
        };
        selectWhenUnmatched: {
            type: BooleanConstructor;
            default: boolean;
        };
        hideLoading: {
            type: BooleanConstructor;
            default: boolean;
        };
        popperAppendToBody: {
            type: BooleanConstructor;
            default: any;
        };
        teleported: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        highlightFirstItem: {
            type: BooleanConstructor;
            default: boolean;
        };
        block: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
            validator: (val: string) => boolean;
        };
        clearable: {
            type: BooleanConstructor;
            default: boolean;
        };
        disabled: BooleanConstructor;
        fill: BooleanConstructor;
        thin: BooleanConstructor;
        popperOffset: {
            type: NumberConstructor;
            default: number;
        };
        fitInputWidth: {
            type: BooleanConstructor;
            default: boolean;
        };
        transition: {
            type: StringConstructor;
            default: string;
        };
        name: StringConstructor;
    }>> & {
        onChange?: (value: string) => any;
        onSelect?: (item: Record<string, any>) => any;
        "onUpdate:modelValue"?: (value: string) => any;
        onInput?: (value: string) => any;
        onBlur?: (evt: FocusEvent) => any;
        onFocus?: (evt: FocusEvent) => any;
        onClear?: () => any;
    }>>;
    emit: ((event: "update:modelValue", value: string) => void) & ((event: "change", value: string) => void) & ((event: "input", value: string) => void) & ((event: "blur", evt: FocusEvent) => void) & ((event: "focus", evt: FocusEvent) => void) & ((event: "select", item: Record<string, any>) => void) & ((event: "clear") => void);
    attrs: import("vue").ComputedRef<Record<string, unknown>>;
    rawAttrs: {
        [x: string]: unknown;
    };
    inputSize: import("vue").ComputedRef<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
    inputDisabled: import("vue").ComputedRef<boolean>;
    inputFill: import("vue").ComputedRef<boolean>;
    namespace: import("vue").ComputedRef<string>;
    compatTeleported: import("vue").ComputedRef<boolean>;
    inputRef: import("vue").Ref<{
        $: import("vue").ComponentInternalInstance;
        $data: {};
        $props: Partial<{
            label: string;
            id: string;
            validateEvent: boolean;
            block: boolean;
            disabled: boolean;
            fill: boolean;
            modelValue: string | number;
            round: boolean;
            clearable: boolean;
            thin: boolean;
            nativeType: string;
            rows: number;
            autosize: boolean | {
                minRows?: number;
                maxRows?: number;
            };
            autocomplete: string;
            readonly: boolean;
            showPassword: boolean;
            showWordLimit: boolean;
            containerRole: string;
            tabindex: string | number;
            inputStyle: Record<string, any>;
            autofocus: boolean;
        }> & Omit<Readonly<import("vue").ExtractPropTypes<{
            ariaLabel: StringConstructor;
            id: {
                type: StringConstructor;
                default: any;
            };
            modelValue: {
                type: import("vue").PropType<string | number>;
                default: string;
            };
            maxlength: {
                type: (StringConstructor | NumberConstructor)[];
            };
            minlength: {
                type: (StringConstructor | NumberConstructor)[];
            };
            nativeType: {
                type: StringConstructor;
                default: string;
            };
            size: {
                type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
                validator: (val: string) => boolean;
            };
            resize: {
                type: import("vue").PropType<"horizontal" | "vertical" | "none" | "both">;
                validator: (val: string) => boolean;
            };
            rows: {
                type: NumberConstructor;
                default: number;
            };
            autosize: {
                type: import("vue").PropType<import("..").InputAutoSize>;
                default: import("..").InputAutoSize;
            };
            autocomplete: {
                type: StringConstructor;
                default: string;
            };
            type: {
                type: import("vue").PropType<"success" | "info" | "warning" | "danger" | "link" | "primary">;
                validator: (val: string) => boolean;
            };
            formatter: {
                type: FunctionConstructor;
            };
            parser: {
                type: FunctionConstructor;
            };
            placeholder: {
                type: StringConstructor;
            };
            form: {
                type: StringConstructor;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly: BooleanConstructor;
            clearable: BooleanConstructor;
            showPassword: BooleanConstructor;
            showWordLimit: BooleanConstructor;
            block: BooleanConstructor;
            label: {
                type: StringConstructor;
                default: any;
            };
            containerRole: {
                type: StringConstructor;
                default: any;
            };
            tabindex: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            validateEvent: {
                type: BooleanConstructor;
                default: boolean;
            };
            round: BooleanConstructor;
            fill: BooleanConstructor;
            thin: BooleanConstructor;
            inputStyle: {
                type: ObjectConstructor;
                default: () => {};
            };
            autofocus: BooleanConstructor;
        }>> & {
            onChange?: (...args: any[]) => any;
            "onUpdate:modelValue"?: (...args: any[]) => any;
            onInput?: (...args: any[]) => any;
            onBlur?: (...args: any[]) => any;
            onFocus?: (...args: any[]) => any;
            onClear?: (...args: any[]) => any;
            onMouseleave?: (...args: any[]) => any;
            onMouseenter?: (...args: any[]) => any;
            onKeydown?: (...args: any[]) => any;
            onCompositionstart?: (...args: any[]) => any;
            onCompositionupdate?: (...args: any[]) => any;
            onCompositionend?: (...args: any[]) => any;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "label" | "id" | "validateEvent" | "block" | "disabled" | "fill" | "modelValue" | "round" | "clearable" | "thin" | "nativeType" | "rows" | "autosize" | "autocomplete" | "readonly" | "showPassword" | "showWordLimit" | "containerRole" | "tabindex" | "inputStyle" | "autofocus">;
        $attrs: {
            [x: string]: unknown;
        };
        $refs: {
            [x: string]: unknown;
        };
        $slots: Readonly<{
            [name: string]: import("vue").Slot;
        }>;
        $root: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $emit: (event: "update:modelValue" | "change" | "input" | "blur" | "focus" | "clear" | "mouseleave" | "mouseenter" | "keydown" | "compositionstart" | "compositionupdate" | "compositionend", ...args: any[]) => void;
        $el: any;
        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            ariaLabel: StringConstructor;
            id: {
                type: StringConstructor;
                default: any;
            };
            modelValue: {
                type: import("vue").PropType<string | number>;
                default: string;
            };
            maxlength: {
                type: (StringConstructor | NumberConstructor)[];
            };
            minlength: {
                type: (StringConstructor | NumberConstructor)[];
            };
            nativeType: {
                type: StringConstructor;
                default: string;
            };
            size: {
                type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
                validator: (val: string) => boolean;
            };
            resize: {
                type: import("vue").PropType<"horizontal" | "vertical" | "none" | "both">;
                validator: (val: string) => boolean;
            };
            rows: {
                type: NumberConstructor;
                default: number;
            };
            autosize: {
                type: import("vue").PropType<import("..").InputAutoSize>;
                default: import("..").InputAutoSize;
            };
            autocomplete: {
                type: StringConstructor;
                default: string;
            };
            type: {
                type: import("vue").PropType<"success" | "info" | "warning" | "danger" | "link" | "primary">;
                validator: (val: string) => boolean;
            };
            formatter: {
                type: FunctionConstructor;
            };
            parser: {
                type: FunctionConstructor;
            };
            placeholder: {
                type: StringConstructor;
            };
            form: {
                type: StringConstructor;
            };
            disabled: {
                type: BooleanConstructor;
                default: boolean;
            };
            readonly: BooleanConstructor;
            clearable: BooleanConstructor;
            showPassword: BooleanConstructor;
            showWordLimit: BooleanConstructor;
            block: BooleanConstructor;
            label: {
                type: StringConstructor;
                default: any;
            };
            containerRole: {
                type: StringConstructor;
                default: any;
            };
            tabindex: {
                type: (StringConstructor | NumberConstructor)[];
                default: number;
            };
            validateEvent: {
                type: BooleanConstructor;
                default: boolean;
            };
            round: BooleanConstructor;
            fill: BooleanConstructor;
            thin: BooleanConstructor;
            inputStyle: {
                type: ObjectConstructor;
                default: () => {};
            };
            autofocus: BooleanConstructor;
        }>> & {
            onChange?: (...args: any[]) => any;
            "onUpdate:modelValue"?: (...args: any[]) => any;
            onInput?: (...args: any[]) => any;
            onBlur?: (...args: any[]) => any;
            onFocus?: (...args: any[]) => any;
            onClear?: (...args: any[]) => any;
            onMouseleave?: (...args: any[]) => any;
            onMouseenter?: (...args: any[]) => any;
            onKeydown?: (...args: any[]) => any;
            onCompositionstart?: (...args: any[]) => any;
            onCompositionupdate?: (...args: any[]) => any;
            onCompositionend?: (...args: any[]) => any;
        }, {
            namespace: import("vue").ComputedRef<string>;
            isComposing: import("vue").Ref<boolean>;
            input: import("vue").Ref<HTMLInputElement>;
            inputId: import("vue").Ref<string>;
            textarea: import("vue").Ref<HTMLTextAreaElement>;
            attrs: import("vue").ComputedRef<Record<string, unknown>>;
            containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;
            inputSize: import("vue").ComputedRef<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
            validateState: import("vue").ComputedRef<"success" | "error" | "" | "validating">;
            textareaStyle: import("vue").ComputedRef<import("hongluan-ui/es/utils").StyleValue>;
            countStyle: import("vue").Ref<import("hongluan-ui/es/utils").StyleValue>;
            resizeTextarea: () => void;
            inputDisabled: import("vue").ComputedRef<boolean>;
            inputFill: import("vue").ComputedRef<boolean>;
            showClear: import("vue").ComputedRef<boolean>;
            showPwdVisible: import("vue").ComputedRef<boolean>;
            isWordLimitVisible: import("vue").ComputedRef<boolean>;
            textLength: import("vue").ComputedRef<number>;
            hovering: import("vue").Ref<boolean>;
            inputExceed: import("vue").ComputedRef<boolean>;
            passwordVisible: import("vue").Ref<boolean>;
            inputOrTextarea: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement>;
            wrapperRef: import("vue").ShallowRef<HTMLElement>;
            handleInput: (event: Event) => void;
            handleChange: (event: Event) => void;
            handleFocus: (event: FocusEvent) => void;
            handleBlur: (event: FocusEvent) => void;
            handleCompositionStart: (event: CompositionEvent) => void;
            handleCompositionUpdate: (event: CompositionEvent) => void;
            handleCompositionEnd: (event: CompositionEvent) => void;
            handlePasswordVisible: () => void;
            clear: () => void;
            select: () => void;
            focus: () => void;
            blur: () => void;
            isFocused: import("vue").Ref<boolean>;
            getSuffixVisible: () => boolean | import("vue").Slot;
            getPwdVisible: () => boolean;
            handleMouseLeave: (e: MouseEvent) => void;
            handleMouseEnter: (e: MouseEvent) => void;
            handleKeydown: (e: KeyboardEvent) => void;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "change" | "input" | "blur" | "focus" | "clear" | "mouseleave" | "mouseenter" | "keydown" | "compositionstart" | "compositionupdate" | "compositionend")[], string, {
            label: string;
            id: string;
            validateEvent: boolean;
            block: boolean;
            disabled: boolean;
            fill: boolean;
            modelValue: string | number;
            round: boolean;
            clearable: boolean;
            thin: boolean;
            nativeType: string;
            rows: number;
            autosize: boolean | {
                minRows?: number;
                maxRows?: number;
            };
            autocomplete: string;
            readonly: boolean;
            showPassword: boolean;
            showWordLimit: boolean;
            containerRole: string;
            tabindex: string | number;
            inputStyle: Record<string, any>;
            autofocus: boolean;
        }> & {
            beforeCreate?: (() => void) | (() => void)[];
            created?: (() => void) | (() => void)[];
            beforeMount?: (() => void) | (() => void)[];
            mounted?: (() => void) | (() => void)[];
            beforeUpdate?: (() => void) | (() => void)[];
            updated?: (() => void) | (() => void)[];
            activated?: (() => void) | (() => void)[];
            deactivated?: (() => void) | (() => void)[];
            beforeDestroy?: (() => void) | (() => void)[];
            beforeUnmount?: (() => void) | (() => void)[];
            destroyed?: (() => void) | (() => void)[];
            unmounted?: (() => void) | (() => void)[];
            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>, info: string) => boolean | void)[];
        };
        $forceUpdate: () => void;
        $nextTick: typeof import("vue").nextTick;
        $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
    } & Readonly<import("vue").ExtractPropTypes<{
        ariaLabel: StringConstructor;
        id: {
            type: StringConstructor;
            default: any;
        };
        modelValue: {
            type: import("vue").PropType<string | number>;
            default: string;
        };
        maxlength: {
            type: (StringConstructor | NumberConstructor)[];
        };
        minlength: {
            type: (StringConstructor | NumberConstructor)[];
        };
        nativeType: {
            type: StringConstructor;
            default: string;
        };
        size: {
            type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
            validator: (val: string) => boolean;
        };
        resize: {
            type: import("vue").PropType<"horizontal" | "vertical" | "none" | "both">;
            validator: (val: string) => boolean;
        };
        rows: {
            type: NumberConstructor;
            default: number;
        };
        autosize: {
            type: import("vue").PropType<import("..").InputAutoSize>;
            default: import("..").InputAutoSize;
        };
        autocomplete: {
            type: StringConstructor;
            default: string;
        };
        type: {
            type: import("vue").PropType<"success" | "info" | "warning" | "danger" | "link" | "primary">;
            validator: (val: string) => boolean;
        };
        formatter: {
            type: FunctionConstructor;
        };
        parser: {
            type: FunctionConstructor;
        };
        placeholder: {
            type: StringConstructor;
        };
        form: {
            type: StringConstructor;
        };
        disabled: {
            type: BooleanConstructor;
            default: boolean;
        };
        readonly: BooleanConstructor;
        clearable: BooleanConstructor;
        showPassword: BooleanConstructor;
        showWordLimit: BooleanConstructor;
        block: BooleanConstructor;
        label: {
            type: StringConstructor;
            default: any;
        };
        containerRole: {
            type: StringConstructor;
            default: any;
        };
        tabindex: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        validateEvent: {
            type: BooleanConstructor;
            default: boolean;
        };
        round: BooleanConstructor;
        fill: BooleanConstructor;
        thin: BooleanConstructor;
        inputStyle: {
            type: ObjectConstructor;
            default: () => {};
        };
        autofocus: BooleanConstructor;
    }>> & {
        onChange?: (...args: any[]) => any;
        "onUpdate:modelValue"?: (...args: any[]) => any;
        onInput?: (...args: any[]) => any;
        onBlur?: (...args: any[]) => any;
        onFocus?: (...args: any[]) => any;
        onClear?: (...args: any[]) => any;
        onMouseleave?: (...args: any[]) => any;
        onMouseenter?: (...args: any[]) => any;
        onKeydown?: (...args: any[]) => any;
        onCompositionstart?: (...args: any[]) => any;
        onCompositionupdate?: (...args: any[]) => any;
        onCompositionend?: (...args: any[]) => any;
    } & import("vue").ShallowUnwrapRef<{
        namespace: import("vue").ComputedRef<string>;
        isComposing: import("vue").Ref<boolean>;
        input: import("vue").Ref<HTMLInputElement>;
        inputId: import("vue").Ref<string>;
        textarea: import("vue").Ref<HTMLTextAreaElement>;
        attrs: import("vue").ComputedRef<Record<string, unknown>>;
        containerAttrs: import("vue").ComputedRef<Record<string, unknown>>;
        inputSize: import("vue").ComputedRef<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
        validateState: import("vue").ComputedRef<"success" | "error" | "" | "validating">;
        textareaStyle: import("vue").ComputedRef<import("hongluan-ui/es/utils").StyleValue>;
        countStyle: import("vue").Ref<import("hongluan-ui/es/utils").StyleValue>;
        resizeTextarea: () => void;
        inputDisabled: import("vue").ComputedRef<boolean>;
        inputFill: import("vue").ComputedRef<boolean>;
        showClear: import("vue").ComputedRef<boolean>;
        showPwdVisible: import("vue").ComputedRef<boolean>;
        isWordLimitVisible: import("vue").ComputedRef<boolean>;
        textLength: import("vue").ComputedRef<number>;
        hovering: import("vue").Ref<boolean>;
        inputExceed: import("vue").ComputedRef<boolean>;
        passwordVisible: import("vue").Ref<boolean>;
        inputOrTextarea: import("vue").ComputedRef<HTMLInputElement | HTMLTextAreaElement>;
        wrapperRef: import("vue").ShallowRef<HTMLElement>;
        handleInput: (event: Event) => void;
        handleChange: (event: Event) => void;
        handleFocus: (event: FocusEvent) => void;
        handleBlur: (event: FocusEvent) => void;
        handleCompositionStart: (event: CompositionEvent) => void;
        handleCompositionUpdate: (event: CompositionEvent) => void;
        handleCompositionEnd: (event: CompositionEvent) => void;
        handlePasswordVisible: () => void;
        clear: () => void;
        select: () => void;
        focus: () => void;
        blur: () => void;
        isFocused: import("vue").Ref<boolean>;
        getSuffixVisible: () => boolean | import("vue").Slot;
        getPwdVisible: () => boolean;
        handleMouseLeave: (e: MouseEvent) => void;
        handleMouseEnter: (e: MouseEvent) => void;
        handleKeydown: (e: KeyboardEvent) => void;
    }> & {} & {} & import("vue").ComponentCustomProperties>;
    regionRef: import("vue").Ref<HTMLElement>;
    popperRef: 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("..").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("..").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("../..").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: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $parent: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}>>;
        $emit: (event: string, ...args: any[]) => void;
        $el: any;
        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
            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("..").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("../..").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-u