hongluan-ui/lib/components/date-picker/src/date-picker-com/panel-date-pick.vue.d.ts

Hongluan Component Library for Vue 3

import { nextTick } from 'vue';
import dayjs from 'dayjs';
import type { SetupContext } from 'vue';
import type { ConfigType, Dayjs } from 'dayjs';
import type { DateTableEmits, YearsPickerEmits, MonthsPickerEmits } from '../props/basic-date-table';
declare type Shortcut = {
    value: (() => Dayjs) | Dayjs;
    onClick?: (ctx: Omit<SetupContext, 'expose'>) => void;
};
declare const _default: import("vue").DefineComponent<{
    parsedValue: {
        type: import("vue").PropType<dayjs.Dayjs | dayjs.Dayjs[]>;
    };
    visible: {
        type: BooleanConstructor;
    };
    format: {
        type: StringConstructor;
        default: string;
    };
    type: {
        type: import("vue").PropType<"year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange">;
        required: boolean;
    };
    dateFormat: StringConstructor;
    timeFormat: StringConstructor;
}, {
    timeWithinRange: (_: ConfigType, __: any, ___: string) => boolean;
    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
        parsedValue: {
            type: import("vue").PropType<dayjs.Dayjs | dayjs.Dayjs[]>;
        };
        visible: {
            type: BooleanConstructor;
        };
        format: {
            type: StringConstructor;
            default: string;
        };
        type: {
            type: import("vue").PropType<"year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange">;
            required: boolean;
        };
        dateFormat: StringConstructor;
        timeFormat: StringConstructor;
    }>> & {
        onPick?: (...args: any[]) => any;
        "onPanel-change"?: (...args: any[]) => any;
        "onSet-picker-option"?: (...args: any[]) => any;
    }>>;
    contextEmit: (event: "panel-change" | "pick" | "set-picker-option", ...args: any[]) => void;
    attrs: {
        [x: string]: unknown;
    };
    slots: Readonly<{
        [name: string]: import("vue").Slot;
    }>;
    t: import("hongluan-ui/es/hooks").Translator;
    lang: import("vue").Ref<string>;
    namespace: import("vue").ComputedRef<string>;
    pickerBase: any;
    popper: import("hongluan-ui/es/tokens").TooltipInjectionContext;
    shortcuts: any;
    disabledDate: any;
    cellClassName: any;
    defaultTime: any;
    defaultValue: import("vue").Ref<any>;
    currentViewRef: import("vue").Ref<{
        focus: () => void;
    }>;
    innerDate: import("vue").Ref<{
        clone: () => dayjs.Dayjs;
        isValid: () => boolean;
        year: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        month: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        date: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        day: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        hour: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        minute: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        second: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        millisecond: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        set: (unit: dayjs.UnitType, value: number) => dayjs.Dayjs;
        get: (unit: dayjs.UnitType) => number;
        add: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
        subtract: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
        startOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
        endOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
        format: (template?: string) => string;
        diff: (date?: string | number | Date | dayjs.Dayjs, unit?: "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "D" | "M" | "y" | "weeks" | "day" | "hour" | "minute" | "second" | "millisecond" | "hours" | "minutes" | "seconds" | "s" | "milliseconds" | "days" | "d" | "h" | "m" | "ms" | "w" | "quarter" | "quarters" | "Q", float?: boolean) => number;
        valueOf: () => number;
        unix: () => number;
        daysInMonth: () => number;
        toDate: () => Date;
        toJSON: () => string;
        toISOString: () => string;
        toString: () => string;
        utcOffset: () => number;
        isBefore: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
        isSame: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
        isAfter: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
        locale: {
            (): string;
            (preset: string | ILocale, object?: Partial<ILocale>): dayjs.Dayjs;
        };
        localeData: () => dayjs.InstanceLocaleDataReturn;
        week: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        weekYear: () => number;
        dayOfYear: {
            (): number;
            (value: number): dayjs.Dayjs;
        };
        isSameOrAfter: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
        isSameOrBefore: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
    }>;
    isChangeToNow: import("vue").Ref<boolean>;
    isShortcut: boolean;
    defaultTimeD: import("vue").ComputedRef<dayjs.Dayjs>;
    month: import("vue").ComputedRef<number>;
    year: import("vue").ComputedRef<number>;
    selectableRange: import("vue").Ref<any[]>;
    userInputDate: import("vue").Ref<string>;
    userInputTime: import("vue").Ref<string>;
    checkDateWithinRange: (date: ConfigType) => boolean;
    formatEmit: (emitDayjs: Dayjs) => dayjs.Dayjs;
    emit: (value: Dayjs | Dayjs[], ...args: any[]) => void;
    handleDatePick: (value: DateTableEmits, keepOpen?: boolean) => Promise<void>;
    moveByMonth: (forward: boolean) => void;
    moveByYear: (forward: boolean) => void;
    currentView: import("vue").Ref<string>;
    yearLabel: import("vue").ComputedRef<string>;
    handleShortcutClick: (shortcut: Shortcut) => void;
    selectionMode: import("vue").ComputedRef<"year" | "years" | "month" | "months" | "date" | "dates" | "week" | "datetime" | "datetimerange" | "daterange" | "monthrange" | "yearrange">;
    isMultipleType: import("vue").ComputedRef<boolean>;
    keyboardMode: import("vue").ComputedRef<string>;
    hasShortcuts: import("vue").ComputedRef<boolean>;
    handleMonthPick: (month: number | MonthsPickerEmits, keepOpen?: boolean) => Promise<void>;
    handleYearPick: (year: number | YearsPickerEmits, keepOpen?: boolean) => Promise<void>;
    showPicker: (view: 'month' | 'year') => Promise<void>;
    showTime: import("vue").ComputedRef<boolean>;
    footerVisible: import("vue").ComputedRef<boolean>;
    disabledConfirm: import("vue").ComputedRef<any>;
    onConfirm: () => void;
    disabledNow: import("vue").ComputedRef<any>;
    changeToNow: () => void;
    timeFormat: import("vue").ComputedRef<string>;
    dateFormat: import("vue").ComputedRef<string>;
    visibleTime: import("vue").ComputedRef<string>;
    visibleDate: import("vue").ComputedRef<string>;
    timePickerVisible: import("vue").Ref<boolean>;
    onTimePickerInputFocus: () => void;
    handleTimePickClose: () => void;
    getUnits: (date: Dayjs) => {
        hour: number;
        minute: number;
        second: number;
        year: number;
        month: number;
        date: number;
    };
    handleTimePick: (value: Dayjs, visible: boolean, first: boolean) => void;
    handleVisibleTimeChange: (value: string) => void;
    handleVisibleDateChange: (value: string) => void;
    isValidValue: (date: unknown) => boolean;
    formatToString: (value: Dayjs | Dayjs[]) => string | string[];
    parseUserInput: (value: Dayjs) => dayjs.Dayjs;
    getDefaultValue: () => dayjs.Dayjs;
    handleFocusPicker: () => Promise<void>;
    handleKeydownTable: (event: KeyboardEvent) => void;
    handleKeyControl: (code: string) => void;
    handlePanelChange: (mode: 'month' | 'year') => void;
    vClickOutside: import("vue").ObjectDirective<any, any>;
    TimePickPanel: import("vue").DefineComponent<{
        readonly datetimeRole: StringConstructor;
        readonly parsedValue: {
            readonly type: import("vue").PropType<dayjs.Dayjs>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly visible: BooleanConstructor;
        readonly actualVisible: {
            readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
            readonly required: false;
            readonly validator: (val: unknown) => boolean;
            __epPropKey: true;
        };
        readonly format: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
    }, {
        props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
            readonly datetimeRole: StringConstructor;
            readonly parsedValue: {
                readonly type: import("vue").PropType<dayjs.Dayjs>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly visible: BooleanConstructor;
            readonly actualVisible: {
                readonly type: import("vue").PropType<import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly format: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "", boolean>;
        }>> & {
            onPick?: (...args: any[]) => any;
            "onSelect-range"?: (...args: any[]) => any;
            "onSet-picker-option"?: (...args: any[]) => any;
        }>>;
        emit: (event: "pick" | "select-range" | "set-picker-option", ...args: any[]) => void;
        pickerBase: any;
        arrowControl: any;
        disabledHours: any;
        disabledMinutes: any;
        disabledSeconds: any;
        defaultValue: any;
        getAvailableHours: import("../../../time-picker/src/types").GetDisabledHoursState;
        getAvailableMinutes: import("../../../time-picker/src/types").GetDisabledMinutesState;
        getAvailableSeconds: import("../../../time-picker/src/types").GetDisabledSecondsState;
        namespace: import("vue").ComputedRef<string>;
        t: import("hongluan-ui/es/hooks").Translator;
        lang: import("vue").Ref<string>;
        selectionRange: import("vue").Ref<number[]>;
        oldValue: import("vue").Ref<string | {
            clone: () => dayjs.Dayjs;
            isValid: () => boolean;
            year: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            month: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            date: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            day: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            hour: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            minute: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            second: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            millisecond: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            set: (unit: dayjs.UnitType, value: number) => dayjs.Dayjs;
            get: (unit: dayjs.UnitType) => number;
            add: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
            subtract: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
            startOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
            endOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
            format: (template?: string) => string;
            diff: (date?: string | number | Date | dayjs.Dayjs, unit?: "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "D" | "M" | "y" | "weeks" | "day" | "hour" | "minute" | "second" | "millisecond" | "hours" | "minutes" | "seconds" | "s" | "milliseconds" | "days" | "d" | "h" | "m" | "ms" | "w" | "quarter" | "quarters" | "Q", float?: boolean) => number;
            valueOf: () => number;
            unix: () => number;
            daysInMonth: () => number;
            toDate: () => Date;
            toJSON: () => string;
            toISOString: () => string;
            toString: () => string;
            utcOffset: () => number;
            isBefore: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            isSame: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            isAfter: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            locale: {
                (): string;
                (preset: string | ILocale, object?: Partial<ILocale>): dayjs.Dayjs;
            };
            localeData: () => dayjs.InstanceLocaleDataReturn;
            week: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            weekYear: () => number;
            dayOfYear: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            isSameOrAfter: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            isSameOrBefore: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
        } | {
            clone: () => dayjs.Dayjs;
            isValid: () => boolean;
            year: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            month: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            date: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            day: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            hour: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            minute: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            second: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            millisecond: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            set: (unit: dayjs.UnitType, value: number) => dayjs.Dayjs;
            get: (unit: dayjs.UnitType) => number;
            add: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
            subtract: (value: number, unit?: dayjs.ManipulateType) => dayjs.Dayjs;
            startOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
            endOf: (unit: dayjs.OpUnitType) => dayjs.Dayjs;
            format: (template?: string) => string;
            diff: (date?: string | number | Date | dayjs.Dayjs, unit?: "year" | "years" | "month" | "months" | "date" | "dates" | "week" | "D" | "M" | "y" | "weeks" | "day" | "hour" | "minute" | "second" | "millisecond" | "hours" | "minutes" | "seconds" | "s" | "milliseconds" | "days" | "d" | "h" | "m" | "ms" | "w" | "quarter" | "quarters" | "Q", float?: boolean) => number;
            valueOf: () => number;
            unix: () => number;
            daysInMonth: () => number;
            toDate: () => Date;
            toJSON: () => string;
            toISOString: () => string;
            toString: () => string;
            utcOffset: () => number;
            isBefore: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            isSame: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            isAfter: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            locale: {
                (): string;
                (preset: string | ILocale, object?: Partial<ILocale>): dayjs.Dayjs;
            };
            localeData: () => dayjs.InstanceLocaleDataReturn;
            week: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            weekYear: () => number;
            dayOfYear: {
                (): number;
                (value: number): dayjs.Dayjs;
            };
            isSameOrAfter: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
            isSameOrBefore: (date: string | number | Date | dayjs.Dayjs, unit?: dayjs.OpUnitType) => boolean;
        }[]>;
        transitionName: import("vue").ComputedRef<"" | "dropdown">;
        showSeconds: import("vue").ComputedRef<boolean>;
        amPmMode: import("vue").ComputedRef<"" | "A" | "a">;
        isValidValue: (_date: dayjs.Dayjs) => boolean;
        handleCancel: () => void;
        handleConfirm: (visible?: boolean, first?: boolean) => void;
        handleChange: (_date: dayjs.Dayjs) => void;
        setSelectionRange: (start: number, end: number) => void;
        changeSelectionRange: (step: number) => void;
        handleKeydown: (event: KeyboardEvent) => void;
        timePickerOptions: Record<string, (...args: any[]) => void>;
        onSetOption: ([key, val]: [string, (...args: any[]) => void]) => void;
        getAvailableTime: (date: dayjs.Dayjs, role: string, first: boolean, compareDate?: dayjs.Dayjs) => dayjs.Dayjs;
        getRangeAvailableTime: (date: dayjs.Dayjs) => dayjs.Dayjs;
        parseUserInput: (value: dayjs.Dayjs) => dayjs.Dayjs;
        formatToString: (value: dayjs.Dayjs) => string;
        getDefaultValue: () => dayjs.Dayjs;
        HlButton: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
            type: {
                type: import("vue").PropType<"success" | "info" | "warning" | "danger" | "link" | "primary">;
                validator: (val: string) => boolean;
            };
            size: {
                type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
                validator: (val: string) => boolean;
            };
            iconPosition: {
                type: import("vue").PropType<"left" | "right">;
                default: string;
            };
            nativeType: {
                type: import("vue").PropType<"button" | "reset" | "submit">;
                default: string;
                validator: (val: "button" | "reset" | "submit") => boolean;
            };
            loading: BooleanConstructor;
            disabled: BooleanConstructor;
            autofocus: BooleanConstructor;
            round: BooleanConstructor;
            equal: BooleanConstructor;
            effect: StringConstructor;
            noFill: BooleanConstructor;
            outline: BooleanConstructor;
            block: BooleanConstructor;
            rational: BooleanConstructor;
            dashed: BooleanConstructor;
            hover: (BooleanConstructor | StringConstructor)[];
            tag: {
                type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
                default: string;
            };
        }, {
            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                type: {
                    type: import("vue").PropType<"success" | "info" | "warning" | "danger" | "link" | "primary">;
                    validator: (val: string) => boolean;
                };
                size: {
                    type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
                    validator: (val: string) => boolean;
                };
                iconPosition: {
                    type: import("vue").PropType<"left" | "right">;
                    default: string;
                };
                nativeType: {
                    type: import("vue").PropType<"button" | "reset" | "submit">;
                    default: string;
                    validator: (val: "button" | "reset" | "submit") => boolean;
                };
                loading: BooleanConstructor;
                disabled: BooleanConstructor;
                autofocus: BooleanConstructor;
                round: BooleanConstructor;
                equal: BooleanConstructor;
                effect: StringConstructor;
                noFill: BooleanConstructor;
                outline: BooleanConstructor;
                block: BooleanConstructor;
                rational: BooleanConstructor;
                dashed: BooleanConstructor;
                hover: (BooleanConstructor | StringConstructor)[];
                tag: {
                    type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
                    default: string;
                };
            }>> & {
                onClick?: (evt: MouseEvent) => any;
            }>>;
            emit: (event: "click", evt: MouseEvent) => void;
            namespace: import("vue").ComputedRef<string>;
            _ref: import("vue").Ref<HTMLButtonElement>;
            _props: import("vue").ComputedRef<{
                ariaDisabled: boolean;
                disabled: boolean;
                autofocus: boolean;
                type: "button" | "reset" | "submit";
            } | {
                ariaDisabled?: undefined;
                disabled?: undefined;
                autofocus?: undefined;
                type?: undefined;
            }>;
            buttonDisabled: import("vue").ComputedRef<boolean>;
            buttonSize: import("vue").ComputedRef<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
            handleClick: (evt: MouseEvent) => void;
            Spinner: import("hongluan-ui/es/utils").SFCWithInstall<import("vue").DefineComponent<{
                status: {
                    type: StringConstructor;
                    default: string;
                };
                animation: {
                    type: StringConstructor;
                    default: string;
                };
                duration: {
                    type: StringConstructor;
                    default: string;
                };
                color: {
                    type: StringConstructor;
                };
                size: StringConstructor;
            }, {
                namespace: import("vue").ComputedRef<string>;
                style: any;
                definedSize: import("vue").Ref<boolean>;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
                status: {
                    type: StringConstructor;
                    default: string;
                };
                animation: {
                    type: StringConstructor;
                    default: string;
                };
                duration: {
                    type: StringConstructor;
                    default: string;
                };
                color: {
                    type: StringConstructor;
                };
                size: StringConstructor;
            }>>, {
                animation: string;
                status: string;
                duration: string;
            }>> & Record<string, any>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
            click: (evt: MouseEvent) => boolean;
        }, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
            type: {
                type: import("vue").PropType<"success" | "info" | "warning" | "danger" | "link" | "primary">;
                validator: (val: string) => boolean;
            };
            size: {
                type: import("vue").PropType<"xxxs" | "xxs" | "xs" | "sm" | "md" | "lg" | "xl" | "xxl" | "xxxl">;
                validator: (val: string) => boolean;
            };
            iconPosition: {
                type: import("vue").PropType<"left" | "right">;
                default: string;
            };
            nativeType: {
                type: import("vue").PropType<"button" | "reset" | "submit">;
                default: string;
                validator: (val: "button" | "reset" | "submit") => boolean;
            };
            loading: BooleanConstructor;
            disabled: BooleanConstructor;
            autofocus: BooleanConstructor;
            round: BooleanConstructor;
            equal: BooleanConstructor;
            effect: StringConstructor;
            noFill: BooleanConstructor;
            outline: BooleanConstructor;
            block: BooleanConstructor;
            rational: BooleanConstructor;
            dashed: BooleanConstructor;
            hover: (BooleanConstructor | StringConstructor)[];
            tag: {
                type: import("vue").PropType<string | import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions>>;
                default: string;
            };
        }>> & {
            onClick?: (evt: MouseEvent) => any;
        }, {
            block: boolean;
            disabled: boolean;
            round: boolean;
            dashed: boolean;
            nativeType: "button" | "reset" | "submit";
            autofocus: boolean;
            outline: boolean;
            tag: string;
            loading: boolean;
            iconPosition: "left" | "right";
            equal: boolean;
            noFill: boolean;
            rational: boolean;
        }>> & Record<string, any>;
        TimeSpinner: import("vue").DefineComponent<{
            readonly disabledHours: {
                readonly type: import("vue").PropType<import("../../../time-picker/src/props/shared").GetDisabledHours>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly disabledMinutes: {
                readonly type: import("vue").PropType<import("../../../time-picker/src/props/shared").GetDisabledMinutes>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly disabledSeconds: {
                readonly type: import("vue").PropType<import("../../../time-picker/src/props/shared").GetDisabledSeconds>;
                readonly required: false;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly role: {
                readonly type: import("vue").PropType<string>;
                readonly required: true;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly spinnerDate: {
                readonly type: import("vue").PropType<dayjs.Dayjs>;
                readonly required: true;
                readonly validator: (val: unknown) => boolean;
                __epPropKey: true;
            };
            readonly showSeconds: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
            readonly arrowControl: BooleanConstructor;
            readonly amPmMode: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<"" | "A" | "a">, unknown, unknown, "", boolean>;
        }, {
            props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
                readonly disabledHours: {
                    readonly type: import("vue").PropType<import("../../../time-picker/src/props/shared").GetDisabledHours>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly disabledMinutes: {
                    readonly type: import("vue").PropType<import("../../../time-picker/src/props/shared").GetDisabledMinutes>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly disabledSeconds: {
                    readonly type: import("vue").PropType<import("../../../time-picker/src/props/shared").GetDisabledSeconds>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly role: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: true;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly spinnerDate: {
                    readonly type: import("vue").PropType<dayjs.Dayjs>;
                    readonly required: true;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly showSeconds: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
                readonly arrowControl: BooleanConstructor;
                readonly amPmMode: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<"" | "A" | "a">, unknown, unknown, "", boolean>;
            }>> & {
                onChange?: (...args: any[]) => any;
                "onSelect-range"?: (...args: any[]) => any;
                "onSet-option"?: (...args: any[]) => any;
            }>>;
            emit: (event: "change" | "select-range" | "set-option", ...args: any[]) => void;
            getHoursList: (role: string, compare?: dayjs.Dayjs) => boolean[];
            getMinutesList: (hour: number, role: string, compare?: dayjs.Dayjs) => boolean[];
            getSecondsList: (hour: number, minute: number, role: string, compare?: dayjs.Dayjs) => boolean[];
            isScrolling: boolean;
            currentScrollbar: import("vue").Ref<"hours" | "minutes" | "seconds">;
            listHoursRef: import("vue").Ref<{
                $: import("vue").ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    height: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    always: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    maxHeight: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    minSize: number;
                    native: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    wrapStyle: "";
                    wrapClass: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    viewClass: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    viewStyle: "";
                    tag: string;
                    distance: number;
                    noresize: boolean;
                }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly ariaOrientation: {
                        readonly type: import("vue").PropType<string>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly height: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly maxHeight: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly native: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly wrapStyle: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("vue").StyleValue>, unknown, unknown, "", boolean>;
                    readonly wrapClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewStyle: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
                    readonly noresize: BooleanConstructor;
                    readonly tag: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly always: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly minSize: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
                    readonly distance: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: (...args: any[]) => any;
                    "onAt-end"?: (...args: any[]) => any;
                } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "height" | "always" | "maxHeight" | "minSize" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "tag" | "distance" | "noresize">;
                $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: "scroll" | "at-end", ...args: any[]) => void;
                $el: any;
                $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly ariaOrientation: {
                        readonly type: import("vue").PropType<string>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly height: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly maxHeight: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly native: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly wrapStyle: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("vue").StyleValue>, unknown, unknown, "", boolean>;
                    readonly wrapClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewStyle: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
                    readonly noresize: BooleanConstructor;
                    readonly tag: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly always: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly minSize: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
                    readonly distance: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: (...args: any[]) => any;
                    "onAt-end"?: (...args: any[]) => any;
                }, {
                    namespace: import("vue").ComputedRef<string>;
                    scrollbarRef: import("vue").Ref<HTMLDivElement>;
                    wrapRef: import("vue").Ref<HTMLDivElement>;
                    resizeRef: import("vue").Ref<HTMLElement>;
                    barRef: import("vue").Ref<any>;
                    style: import("vue").ComputedRef<import("vue").StyleValue>;
                    update: () => void;
                    handleScroll: () => void;
                    setScrollTop: (value: number) => void;
                    setScrollLeft: (value: number) => void;
                    scrollTo: {
                        (xCord: number, yCord?: number): void;
                        (options: ScrollToOptions): void;
                    };
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("scroll" | "at-end")[], string, {
                    height: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    always: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    maxHeight: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    minSize: number;
                    native: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    wrapStyle: "";
                    wrapClass: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    viewClass: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    viewStyle: "";
                    tag: string;
                    distance: number;
                    noresize: 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 nextTick;
                $watch(source: string | Function, cb: Function, options?: import("vue").WatchOptions<boolean>): import("vue").WatchStopHandle;
            } & Readonly<import("vue").ExtractPropTypes<{
                readonly ariaLabel: StringConstructor;
                readonly ariaOrientation: {
                    readonly type: import("vue").PropType<string>;
                    readonly required: false;
                    readonly validator: (val: unknown) => boolean;
                    __epPropKey: true;
                };
                readonly height: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                readonly maxHeight: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                readonly native: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly wrapStyle: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("vue").StyleValue>, unknown, unknown, "", boolean>;
                readonly wrapClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                readonly viewClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                readonly viewStyle: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
                readonly noresize: BooleanConstructor;
                readonly tag: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                readonly always: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                readonly minSize: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
                readonly distance: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                readonly id: StringConstructor;
                readonly role: StringConstructor;
            }>> & {
                onScroll?: (...args: any[]) => any;
                "onAt-end"?: (...args: any[]) => any;
            } & import("vue").ShallowUnwrapRef<{
                namespace: import("vue").ComputedRef<string>;
                scrollbarRef: import("vue").Ref<HTMLDivElement>;
                wrapRef: import("vue").Ref<HTMLDivElement>;
                resizeRef: import("vue").Ref<HTMLElement>;
                barRef: import("vue").Ref<any>;
                style: import("vue").ComputedRef<import("vue").StyleValue>;
                update: () => void;
                handleScroll: () => void;
                setScrollTop: (value: number) => void;
                setScrollLeft: (value: number) => void;
                scrollTo: {
                    (xCord: number, yCord?: number): void;
                    (options: ScrollToOptions): void;
                };
            }> & {} & {} & import("vue").ComponentCustomProperties>;
            listMinutesRef: import("vue").Ref<{
                $: import("vue").ComponentInternalInstance;
                $data: {};
                $props: Partial<{
                    height: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    always: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    maxHeight: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
                    minSize: number;
                    native: import("hongluan-ui/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
                    wrapStyle: "";
                    wrapClass: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    viewClass: import("hongluan-ui/es/utils").EpPropMergeType<readonly [StringConstructor, ArrayConstructor], unknown, unknown>;
                    viewStyle: "";
                    tag: string;
                    distance: number;
                    noresize: boolean;
                }> & Omit<Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: StringConstructor;
                    readonly ariaOrientation: {
                        readonly type: import("vue").PropType<string>;
                        readonly required: false;
                        readonly validator: (val: unknown) => boolean;
                        __epPropKey: true;
                    };
                    readonly height: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly maxHeight: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
                    readonly native: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly wrapStyle: import("hongluan-ui/es/utils").EpPropFinalized<import("vue").PropType<import("vue").StyleValue>, unknown, unknown, "", boolean>;
                    readonly wrapClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewClass: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor], unknown, unknown, "", boolean>;
                    readonly viewStyle: import("hongluan-ui/es/utils").EpPropFinalized<readonly [StringConstructor, ArrayConstructor, ObjectConstructor], unknown, unknown, "", boolean>;
                    readonly noresize: BooleanConstructor;
                    readonly tag: import("hongluan-ui/es/utils").EpPropFinalized<StringConstructor, unknown, unknown, "div", boolean>;
                    readonly always: import("hongluan-ui/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, false, boolean>;
                    readonly minSize: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 20, boolean>;
                    readonly distance: import("hongluan-ui/es/utils").EpPropFinalized<NumberConstructor, unknown, unknown, 5, boolean>;
                    readonly id: StringConstructor;
                    readonly role: StringConstructor;
                }>> & {
                    onScroll?: (...args: any[]) => any;
                    "onAt-end"?: (...args: any[]) => any;
                } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, "height" | "always" | "maxHeight" | "minSize" | "native" | "wrapStyle" | "wrapClass" | "viewClass" | "viewStyle" | "tag" | "distance" | "noresize">;
                $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: "scroll" | "at-end", ...args: any[]) => void;
                $el: any;
                $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
                    readonly ariaLabel: String