hongluan-ui/es/components/time-picker/src/common/picker.vue.d.ts

Hongluan Component Library for Vue 3

import { nextTick } from 'vue';
import type { Dayjs } from 'dayjs';
import type { ComponentPublicInstance } from 'vue';
import type { Options } from '@popperjs/core';
import type { DateModelType, DayOrDays, PickerOptions, SingleOrRange, TimePickerDefaultProps, UserInput } from './props';
declare const _default: import("vue").DefineComponent<{
    ariaLabel: StringConstructor;
    emptyValues: ArrayConstructor;
    valueOnClear: {
        readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown>>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    disabledDate: {
        type: FunctionConstructor;
    };
    cellClassName: {
        type: FunctionConstructor;
    };
    shortcuts: {
        type: ArrayConstructor;
        default: () => any[];
    };
    arrowControl: BooleanConstructor;
    label: {
        type: StringConstructor;
        default: any;
    };
    tabindex: {
        type: (StringConstructor | NumberConstructor)[];
        default: number;
    };
    validateEvent: {
        type: BooleanConstructor;
        default: boolean;
    };
    fill: BooleanConstructor;
    unlinkPanels: BooleanConstructor;
    block: BooleanConstructor;
    thin: BooleanConstructor;
    teleported: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
    disabledHours: {
        readonly type: import("vue").PropType<import("../props/shared").GetDisabledHours>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    disabledMinutes: {
        readonly type: import("vue").PropType<import("../props/shared").GetDisabledMinutes>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    disabledSeconds: {
        readonly type: import("vue").PropType<import("../props/shared").GetDisabledSeconds>;
        readonly required: false;
        readonly validator: (val: unknown) => boolean;
        __epPropKey: true;
    };
    id: {
        type: import("vue").PropType<SingleOrRange<string>>;
    };
    name: {
        type: import("vue").PropType<SingleOrRange<string>>;
        default: string;
    };
    popperClass: {
        type: StringConstructor;
        default: string;
    };
    popperOffset: {
        type: NumberConstructor;
        default: number;
    };
    format: StringConstructor;
    valueFormat: StringConstructor;
    dateFormat: StringConstructor;
    timeFormat: StringConstructor;
    type: {
        type: StringConstructor;
        default: string;
    };
    clearable: {
        type: BooleanConstructor;
        default: boolean;
    };
    editable: {
        type: BooleanConstructor;
        default: boolean;
    };
    size: {
        type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
        validator: (val: string) => boolean;
    };
    readonly: BooleanConstructor;
    disabled: BooleanConstructor;
    placeholder: {
        type: StringConstructor;
        default: string;
    };
    modelValue: {
        type: import("vue").PropType<import("./props").ModelValueType>;
        default: string;
    };
    popperOptions: {
        type: import("vue").PropType<Partial<Options>>;
        default: () => {};
    };
    rangeSeparator: {
        type: StringConstructor;
        default: string;
    };
    startPlaceholder: StringConstructor;
    endPlaceholder: StringConstructor;
    defaultValue: {
        type: import("vue").PropType<SingleOrRange<Date>>;
    };
    defaultTime: {
        type: import("vue").PropType<SingleOrRange<Date>>;
    };
    isRange: BooleanConstructor;
}, {
    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
        ariaLabel: StringConstructor;
        emptyValues: ArrayConstructor;
        valueOnClear: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor, BooleanConstructor, FunctionConstructor], unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        disabledDate: {
            type: FunctionConstructor;
        };
        cellClassName: {
            type: FunctionConstructor;
        };
        shortcuts: {
            type: ArrayConstructor;
            default: () => any[];
        };
        arrowControl: BooleanConstructor;
        label: {
            type: StringConstructor;
            default: any;
        };
        tabindex: {
            type: (StringConstructor | NumberConstructor)[];
            default: number;
        };
        validateEvent: {
            type: BooleanConstructor;
            default: boolean;
        };
        fill: BooleanConstructor;
        unlinkPanels: BooleanConstructor;
        block: BooleanConstructor;
        thin: BooleanConstructor;
        teleported: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
        disabledHours: {
            readonly type: import("vue").PropType<import("../props/shared").GetDisabledHours>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        disabledMinutes: {
            readonly type: import("vue").PropType<import("../props/shared").GetDisabledMinutes>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        disabledSeconds: {
            readonly type: import("vue").PropType<import("../props/shared").GetDisabledSeconds>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        id: {
            type: import("vue").PropType<SingleOrRange<string>>;
        };
        name: {
            type: import("vue").PropType<SingleOrRange<string>>;
            default: string;
        };
        popperClass: {
            type: StringConstructor;
            default: string;
        };
        popperOffset: {
            type: NumberConstructor;
            default: number;
        };
        format: StringConstructor;
        valueFormat: StringConstructor;
        dateFormat: StringConstructor;
        timeFormat: StringConstructor;
        type: {
            type: StringConstructor;
            default: string;
        };
        clearable: {
            type: BooleanConstructor;
            default: boolean;
        };
        editable: {
            type: BooleanConstructor;
            default: boolean;
        };
        size: {
            type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
            validator: (val: string) => boolean;
        };
        readonly: BooleanConstructor;
        disabled: BooleanConstructor;
        placeholder: {
            type: StringConstructor;
            default: string;
        };
        modelValue: {
            type: import("vue").PropType<import("./props").ModelValueType>;
            default: string;
        };
        popperOptions: {
            type: import("vue").PropType<Partial<Options>>;
            default: () => {};
        };
        rangeSeparator: {
            type: StringConstructor;
            default: string;
        };
        startPlaceholder: StringConstructor;
        endPlaceholder: StringConstructor;
        defaultValue: {
            type: import("vue").PropType<SingleOrRange<Date>>;
        };
        defaultTime: {
            type: import("vue").PropType<SingleOrRange<Date>>;
        };
        isRange: BooleanConstructor;
    }>> & {
        onChange?: (...args: any[]) => any;
        "onUpdate:modelValue"?: (...args: any[]) => any;
        onBlur?: (...args: any[]) => any;
        onFocus?: (...args: any[]) => any;
        onClear?: (...args: any[]) => any;
        onKeydown?: (...args: any[]) => any;
        "onVisible-change"?: (...args: any[]) => any;
        "onCalendar-change"?: (...args: any[]) => any;
        "onPanel-change"?: (...args: any[]) => any;
    }>>;
    emit: (event: "update:modelValue" | "change" | "blur" | "focus" | "clear" | "keydown" | "visible-change" | "calendar-change" | "panel-change", ...args: any[]) => void;
    lang: import("vue").Ref<string>;
    namespace: import("vue").ComputedRef<string>;
    form: import("hongluan-ui/es/tokens").FormContext;
    formItem: import("hongluan-ui/es/tokens").FormItemContext;
    hlPopperOptions: Options;
    valueOnClear: import("vue").ComputedRef<any>;
    refPopper: 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<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<Options>>, unknown, unknown, () => Partial<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<Options>>, unknown, unknown, () => Partial<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<Options>>, unknown, unknown, () => Partial<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;
            }