import { type ExtractPropTypes, type PropType } from 'vue';
declare const calendarsProps: {
    readonly visible: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly disabledDate: {
        readonly type: PropType<(date: Date) => boolean>;
        readonly default: () => boolean;
    };
    readonly control: BooleanConstructor;
    readonly shortcuts: ObjectConstructor;
    readonly maxRange: {
        type: StringConstructor;
    };
    readonly modelValue: {
        type: PropType<number | number[]>;
    };
    readonly format: StringConstructor;
    readonly type: {
        type: PropType<"date" | "datetime" | "datemultiple" | "daterange" | "datetimerange" | "datemonthrange" | "year" | "month" | "quarter">;
        default: string;
    };
    readonly minDate: {
        type: (NumberConstructor | DateConstructor)[];
    };
    readonly maxDate: {
        type: (NumberConstructor | DateConstructor)[];
    };
    readonly disabledTime: {
        type: PropType<(date: Date, rangePosition?: "left" | "right", value?: Date | Date[]) => boolean>;
        default: () => boolean;
    };
    readonly hourStep: NumberConstructor;
    readonly minuteStep: NumberConstructor;
    readonly secondStep: NumberConstructor;
    readonly defaultTime: PropType<string | string[]>;
};
export type CalendarsProps = Partial<ExtractPropTypes<typeof calendarsProps>>;
declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
    readonly visible: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly disabledDate: {
        readonly type: PropType<(date: Date) => boolean>;
        readonly default: () => boolean;
    };
    readonly control: BooleanConstructor;
    readonly shortcuts: ObjectConstructor;
    readonly maxRange: {
        type: StringConstructor;
    };
    readonly modelValue: {
        type: PropType<number | number[]>;
    };
    readonly format: StringConstructor;
    readonly type: {
        type: PropType<"date" | "datetime" | "datemultiple" | "daterange" | "datetimerange" | "datemonthrange" | "year" | "month" | "quarter">;
        default: string;
    };
    readonly minDate: {
        type: (NumberConstructor | DateConstructor)[];
    };
    readonly maxDate: {
        type: (NumberConstructor | DateConstructor)[];
    };
    readonly disabledTime: {
        type: PropType<(date: Date, rangePosition?: "left" | "right", value?: Date | Date[]) => boolean>;
        default: () => boolean;
    };
    readonly hourStep: NumberConstructor;
    readonly minuteStep: NumberConstructor;
    readonly secondStep: NumberConstructor;
    readonly defaultTime: PropType<string | string[]>;
}>, {
    RANGE_POSITION: {
        readonly LEFT: "left";
        readonly RIGHT: "right";
    };
    prefixCls: string;
    tempCurrentValue: import("vue").Ref<number[], number[]>;
    change: () => void;
    pickerRef: import("vue").ComputedRef<import("./pickerHandler").Picker>;
    leftActiveDate: import("vue").Ref<number, number>;
    rightActiveDate: import("vue").Ref<number, number>;
    changeCurrentDate: (timestamp: number, position: "left" | "right") => void;
    visibleFooter: import("vue").ComputedRef<boolean>;
    selectCurrentTime: () => void;
    confirmDisabled: import("vue").ComputedRef<boolean>;
    innerDisabledDate: (date: Date, format: string, flagDate?: Date) => boolean;
    rangeDisabledDate: (date: Date, format: string, flagDate?: Date) => boolean;
    selectedStatus: import("vue").Ref<import("./const").SELECTED_STATUS, import("./const").SELECTED_STATUS>;
    selectedDay: (position: "left" | "right") => void;
    updateTempCurrentValue: (val: number[]) => void;
    confirm: () => void;
    t: import("../config-provider/const").TranslatorType;
    currentText: import("vue").ComputedRef<string>;
    handleShortcut: (val: any) => void;
    defaultActiveDate: import("vue").Ref<number, number>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "tmpSelectedDateChange")[], "change" | "update:modelValue" | "tmpSelectedDateChange", import("vue").PublicProps, Readonly<ExtractPropTypes<{
    readonly visible: {
        readonly type: BooleanConstructor;
        readonly default: false;
    };
    readonly disabledDate: {
        readonly type: PropType<(date: Date) => boolean>;
        readonly default: () => boolean;
    };
    readonly control: BooleanConstructor;
    readonly shortcuts: ObjectConstructor;
    readonly maxRange: {
        type: StringConstructor;
    };
    readonly modelValue: {
        type: PropType<number | number[]>;
    };
    readonly format: StringConstructor;
    readonly type: {
        type: PropType<"date" | "datetime" | "datemultiple" | "daterange" | "datetimerange" | "datemonthrange" | "year" | "month" | "quarter">;
        default: string;
    };
    readonly minDate: {
        type: (NumberConstructor | DateConstructor)[];
    };
    readonly maxDate: {
        type: (NumberConstructor | DateConstructor)[];
    };
    readonly disabledTime: {
        type: PropType<(date: Date, rangePosition?: "left" | "right", value?: Date | Date[]) => boolean>;
        default: () => boolean;
    };
    readonly hourStep: NumberConstructor;
    readonly minuteStep: NumberConstructor;
    readonly secondStep: NumberConstructor;
    readonly defaultTime: PropType<string | string[]>;
}>> & Readonly<{
    onChange?: (...args: any[]) => any;
    "onUpdate:modelValue"?: (...args: any[]) => any;
    onTmpSelectedDateChange?: (...args: any[]) => any;
}>, {
    readonly type: "date" | "datetime" | "datemultiple" | "daterange" | "datetimerange" | "datemonthrange" | "year" | "month" | "quarter";
    readonly control: boolean;
    readonly disabledDate: (date: Date) => boolean;
    readonly disabledTime: (date: Date, rangePosition?: "left" | "right", value?: Date | Date[]) => boolean;
    readonly visible: boolean;
}, {}, {
    Calendar: import("vue").DefineComponent<ExtractPropTypes<{
        readonly rangePosition: {
            readonly type: PropType<"left" | "right">;
        };
        readonly modelValue: PropType<number[]>;
        readonly activeDate: NumberConstructor;
        readonly selectedStatus: PropType<import("./const").SELECTED_STATUS>;
        readonly disabledDate: {
            readonly type: PropType<(date: Date, format: string, flagDate?: Date) => boolean>;
        };
        readonly format: StringConstructor;
        readonly type: {
            type: PropType<"date" | "datetime" | "datemultiple" | "daterange" | "datetimerange" | "datemonthrange" | "year" | "month" | "quarter">;
            default: string;
        };
        readonly minDate: {
            type: (NumberConstructor | DateConstructor)[];
        };
        readonly maxDate: {
            type: (NumberConstructor | DateConstructor)[];
        };
        readonly disabledTime: {
            type: PropType<(date: Date, rangePosition?: "left" | "right", value?: Date | Date[]) => boolean>;
            default: () => boolean;
        };
        readonly hourStep: NumberConstructor;
        readonly minuteStep: NumberConstructor;
        readonly secondStep: NumberConstructor;
        readonly defaultTime: PropType<string | string[]>;
    }>, {
        prefixCls: string;
        pickerRef: import("vue").ComputedRef<import("./pickerHandler").Picker>;
        currentDate: {
            year: number;
            month: number;
            day: number;
            hour: number;
            minute: number;
            second: number;
        };
        MONTHS_NAMES: string[];
        inputDate: import("vue").Ref<string, string>;
        handleDateInput: (val: string) => void;
        handleDateInputBlur: () => void;
        years: import("vue").ComputedRef<any[]>;
        yearStart: import("vue").ComputedRef<number>;
        yearEnd: import("vue").ComputedRef<number>;
        selectYear: (year: number) => void;
        isYearSelect: import("vue").ComputedRef<boolean>;
        yearCls: (year: number) => (string | string[])[];
        isMonthSelect: import("vue").ComputedRef<boolean>;
        selectMonth: (month: number) => void;
        monthCls: (month: number) => {
            [x: string]: boolean;
            'is-start': boolean;
            'is-end': boolean;
        };
        weekNames: import("vue").ComputedRef<string[]>;
        isDaySelect: import("vue").ComputedRef<boolean>;
        days: import("vue").ComputedRef<any[]>;
        isQuarterSelect: import("vue").ComputedRef<boolean>;
        quarterList: {
            name: string;
            value: number;
        }[];
        selectQuarter: (item: import("./useCalendar").QuarterItem) => void;
        quarterCls: (item: import("./useCalendar").QuarterItem) => {
            [x: string]: boolean;
        };
        dayCls: (item: import("./interface").DayItem) => {
            [x: string]: boolean;
            'is-start': boolean;
            'is-end': boolean;
        };
        monthToNext: () => void;
        monthToPre: () => void;
        isNotDisabled: (e: MouseEvent) => boolean;
        selectedDay: (info: import("./interface").DayItem) => void;
        currentTime: import("vue").Ref<string, string>;
        changeTime: (time: string) => void;
        innerDisabledTime: import("vue").ComputedRef<boolean>;
        yearToPre: () => void;
        yearToNext: () => void;
        t: import("../config-provider/const").TranslatorType;
        visibleLeftSingleArrow: import("vue").ComputedRef<boolean>;
        visibleRightSingleArrow: import("vue").ComputedRef<boolean>;
    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "selectedDay" | "update:activeDate")[], "change" | "selectedDay" | "update:activeDate", import("vue").PublicProps, Readonly<ExtractPropTypes<{
        readonly rangePosition: {
            readonly type: PropType<"left" | "right">;
        };
        readonly modelValue: PropType<number[]>;
        readonly activeDate: NumberConstructor;
        readonly selectedStatus: PropType<import("./const").SELECTED_STATUS>;
        readonly disabledDate: {
            readonly type: PropType<(date: Date, format: string, flagDate?: Date) => boolean>;
        };
        readonly format: StringConstructor;
        readonly type: {
            type: PropType<"date" | "datetime" | "datemultiple" | "daterange" | "datetimerange" | "datemonthrange" | "year" | "month" | "quarter">;
            default: string;
        };
        readonly minDate: {
            type: (NumberConstructor | DateConstructor)[];
        };
        readonly maxDate: {
            type: (NumberConstructor | DateConstructor)[];
        };
        readonly disabledTime: {
            type: PropType<(date: Date, rangePosition?: "left" | "right", value?: Date | Date[]) => boolean>;
            default: () => boolean;
        };
        readonly hourStep: NumberConstructor;
        readonly minuteStep: NumberConstructor;
        readonly secondStep: NumberConstructor;
        readonly defaultTime: PropType<string | string[]>;
    }>> & Readonly<{
        onChange?: (...args: any[]) => any;
        onSelectedDay?: (...args: any[]) => any;
        "onUpdate:activeDate"?: (...args: any[]) => any;
    }>, {
        readonly type: "date" | "datetime" | "datemultiple" | "daterange" | "datetimerange" | "datemonthrange" | "year" | "month" | "quarter";
        readonly disabledTime: (date: Date, rangePosition?: "left" | "right", value?: Date | Date[]) => boolean;
    }, {}, {
        LeftOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
        RightOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
        DoubleLeftOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
        DoubleRightOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
        InputInner: import("vue").DefineComponent<ExtractPropTypes<{
            readonly innerIsFocus: BooleanConstructor;
            readonly innerIsError: BooleanConstructor;
            readonly canEdit: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly modelValue: {
                readonly type: PropType<import("../input/interface").InputValue>;
            };
            readonly type: {
                readonly type: StringConstructor;
                readonly default: "text";
            };
            readonly placeholder: {
                readonly type: StringConstructor;
            };
            readonly readonly: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly disabled: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly clearable: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly maxlength: {
                readonly type: NumberConstructor;
            };
            readonly showPassword: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly inputStyle: {
                readonly type: PropType<import("vue").StyleValue>;
                readonly default: () => import("vue").StyleValue;
            };
            readonly autocomplete: {
                readonly type: StringConstructor;
                readonly default: "off";
            };
        }>, {
            passwordVisible: import("vue").Ref<boolean, boolean>;
            handlePasswordVisible: () => void;
            showPwdSwitchIcon: import("vue").ComputedRef<boolean>;
            handleInput: (event: string | Event) => void;
            handleCompositionStart: () => void;
            handleCompositionEnd: (event: Event) => void;
            inputRefEl: import("vue").Ref<HTMLElement, HTMLElement>;
            focus: () => void;
            blur: () => void;
            focused: import("vue").Ref<boolean, boolean>;
            handleFocus: (event: Event) => void;
            handleBlur: (event: Event) => void;
            showClear: import("vue").ComputedRef<boolean>;
            clear: () => void;
            handleChange: import("lodash-es").DebouncedFunc<(event: Event) => void>;
            onMouseLeave: (e: MouseEvent) => void;
            onMouseEnter: (e: MouseEvent) => void;
            handleMousedown: (e: MouseEvent) => void;
            handleKeydown: (e: KeyboardEvent) => void;
            prefixCls: string;
            suffixVisible: import("vue").ComputedRef<boolean>;
            currentValue: import("vue").WritableComputedRef<import("../input/interface").InputValue, import("../input/interface").InputValue>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "change" | "update:modelValue" | "blur" | "focus" | "input" | "keydown" | "mouseenter" | "mouseleave")[], "clear" | "change" | "update:modelValue" | "blur" | "focus" | "input" | "keydown" | "mouseenter" | "mouseleave", import("vue").PublicProps, Readonly<ExtractPropTypes<{
            readonly innerIsFocus: BooleanConstructor;
            readonly innerIsError: BooleanConstructor;
            readonly canEdit: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly modelValue: {
                readonly type: PropType<import("../input/interface").InputValue>;
            };
            readonly type: {
                readonly type: StringConstructor;
                readonly default: "text";
            };
            readonly placeholder: {
                readonly type: StringConstructor;
            };
            readonly readonly: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly disabled: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly clearable: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly maxlength: {
                readonly type: NumberConstructor;
            };
            readonly showPassword: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly inputStyle: {
                readonly type: PropType<import("vue").StyleValue>;
                readonly default: () => import("vue").StyleValue;
            };
            readonly autocomplete: {
                readonly type: StringConstructor;
                readonly default: "off";
            };
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onBlur?: (...args: any[]) => any;
            onChange?: (...args: any[]) => any;
            onInput?: (...args: any[]) => any;
            onKeydown?: (...args: any[]) => any;
            onMouseenter?: (...args: any[]) => any;
            onMouseleave?: (...args: any[]) => any;
            "onUpdate:modelValue"?: (...args: any[]) => any;
            onClear?: (...args: any[]) => any;
        }>, {
            readonly type: string;
            readonly disabled: boolean;
            readonly clearable: boolean;
            readonly canEdit: boolean;
            readonly innerIsFocus: boolean;
            readonly innerIsError: boolean;
            readonly readonly: boolean;
            readonly showPassword: boolean;
            readonly inputStyle: import("vue").StyleValue;
            readonly autocomplete: string;
        }, {}, {
            EyeOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
            EyeInvisibleOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
            CloseCircleFilled: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
        TimePicker: {
            new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
                readonly modelValue: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly open: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly appendToContainer: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly getContainer: {
                    readonly type: PropType<import("../_util/interface").GetContainer>;
                };
                readonly placeholder: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly isRange: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly disabled: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly clearable: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly format: {
                    readonly type: StringConstructor;
                    readonly default: "HH:mm:ss";
                };
                readonly hourStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly minuteStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly secondStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly disabledHours: PropType<(h: number) => boolean>;
                readonly disabledMinutes: PropType<(h: number, m: number) => boolean>;
                readonly disabledSeconds: PropType<(h: number, m: number, s: number) => boolean>;
                readonly control: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly showSuffix: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly inputClass: {
                    readonly type: PropType<string | object | []>;
                };
            }>> & Readonly<{
                onFocus?: (...args: any[]) => any;
                onBlur?: (...args: any[]) => any;
                onChange?: (...args: any[]) => any;
                "onUpdate:modelValue"?: (...args: any[]) => any;
                "onUpdate:open"?: (...args: any[]) => any;
            }>, {
                prefixCls: string;
                isError: import("vue").Ref<boolean, boolean>;
                innerDisabled: import("vue").ComputedRef<boolean>;
                classes: import("vue").ComputedRef<(string | object)[]>;
                displayValue: import("vue").ComputedRef<any>;
                isOpened: import("vue").WritableComputedRef<boolean, boolean>;
                currentValue: import("vue").WritableComputedRef<string, string>;
                tempValue: import("vue").Ref<any, any>;
                handleInput: (val: string) => void;
                handleBlur: (event: Event) => void;
                clear: () => void;
                changeTime: (val: string) => void;
                showControl: import("vue").ComputedRef<boolean>;
                showNowShortcut: import("vue").ComputedRef<boolean>;
                setCurrentTime: () => void;
                confirmChangeTime: () => void;
                activeTime: import("vue").Ref<any, any>;
                inputPlaceholder: import("vue").ComputedRef<string>;
                t: import("../config-provider/const").TranslatorType;
                attrs: {
                    [x: string]: unknown;
                };
                timeSelectRef: import("vue").Ref<any, any>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "blur" | "focus" | "update:open")[], import("vue").PublicProps, {
                readonly disabled: boolean;
                readonly modelValue: string;
                readonly open: boolean;
                readonly clearable: boolean;
                readonly placeholder: string;
                readonly appendToContainer: boolean;
                readonly control: boolean;
                readonly format: string;
                readonly hourStep: number;
                readonly minuteStep: number;
                readonly secondStep: number;
                readonly isRange: boolean;
                readonly showSuffix: boolean;
            }, true, {}, {}, {
                TimeSelect: import("vue").DefineComponent<ExtractPropTypes<{
                    readonly visible: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly modelValue: {
                        readonly type: StringConstructor;
                        readonly default: "";
                    };
                    readonly format: {
                        readonly type: StringConstructor;
                        readonly default: "HH:mm:ss";
                    };
                    readonly hourStep: {
                        readonly type: NumberConstructor;
                        readonly default: 1;
                    };
                    readonly minuteStep: {
                        readonly type: NumberConstructor;
                        readonly default: 1;
                    };
                    readonly secondStep: {
                        readonly type: NumberConstructor;
                        readonly default: 1;
                    };
                    readonly disabledHours: {
                        readonly type: PropType<(h: number) => boolean>;
                    };
                    readonly disabledMinutes: {
                        readonly type: PropType<(h: number, m: number) => boolean>;
                    };
                    readonly disabledSeconds: {
                        readonly type: PropType<(h: number, m: number, s: number) => boolean>;
                    };
                    readonly visibleCount: {
                        readonly type: NumberConstructor;
                        readonly default: 8;
                    };
                }>, {
                    prefixCls: string;
                    canSelectHours: import("vue").ComputedRef<import("../time-picker/interface").TimeOption[]>;
                    canSelectMinutes: import("vue").ComputedRef<import("../time-picker/interface").TimeOption[]>;
                    canSelectSeconds: import("vue").ComputedRef<import("../time-picker/interface").TimeOption[]>;
                    changeSelectedHour: (option: import("../time-picker/interface").TimeOption) => void;
                    changeSelectedMinute: (option: import("../time-picker/interface").TimeOption) => void;
                    changeSelectedSeconds: (option: import("../time-picker/interface").TimeOption) => void;
                    focusKey: {
                        1: number;
                        2: number;
                        4: number;
                    };
                    selectedTime: {
                        hour: string;
                        minute: string;
                        seconds: string;
                    };
                    resetTime: () => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                    readonly visible: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly modelValue: {
                        readonly type: StringConstructor;
                        readonly default: "";
                    };
                    readonly format: {
                        readonly type: StringConstructor;
                        readonly default: "HH:mm:ss";
                    };
                    readonly hourStep: {
                        readonly type: NumberConstructor;
                        readonly default: 1;
                    };
                    readonly minuteStep: {
                        readonly type: NumberConstructor;
                        readonly default: 1;
                    };
                    readonly secondStep: {
                        readonly type: NumberConstructor;
                        readonly default: 1;
                    };
                    readonly disabledHours: {
                        readonly type: PropType<(h: number) => boolean>;
                    };
                    readonly disabledMinutes: {
                        readonly type: PropType<(h: number, m: number) => boolean>;
                    };
                    readonly disabledSeconds: {
                        readonly type: PropType<(h: number, m: number, s: number) => boolean>;
                    };
                    readonly visibleCount: {
                        readonly type: NumberConstructor;
                        readonly default: 8;
                    };
                }>> & Readonly<{
                    onChange?: (...args: any[]) => any;
                    "onUpdate:modelValue"?: (...args: any[]) => any;
                }>, {
                    readonly modelValue: string;
                    readonly format: string;
                    readonly hourStep: number;
                    readonly minuteStep: number;
                    readonly secondStep: number;
                    readonly visible: boolean;
                    readonly visibleCount: number;
                }, {}, {
                    PickerItem: import("vue").DefineComponent<ExtractPropTypes<{
                        readonly visible: BooleanConstructor;
                        readonly value: {
                            readonly type: StringConstructor;
                            readonly default: "";
                        };
                        readonly focus: {
                            readonly type: NumberConstructor;
                            readonly default: -1;
                        };
                        readonly times: {
                            readonly type: PropType<import("../time-picker/interface").TimeOption[]>;
                            readonly default: () => import("../time-picker/interface").TimeOption[];
                        };
                        readonly visibleCount: {
                            readonly type: NumberConstructor;
                            readonly default: 8;
                        };
                    }>, {
                        visibleHeight: import("vue").ComputedRef<number>;
                        style: import("vue").ComputedRef<{
                            'padding-bottom': string;
                        }>;
                        scrollbarRef: import("vue").Ref<any, any>;
                        prefixCls: string;
                        rootRefEl: import("vue").Ref<HTMLElement, HTMLElement>;
                        selectedIndex: import("vue").ComputedRef<number>;
                        selectedTime: (e: MouseEvent) => void;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                        readonly visible: BooleanConstructor;
                        readonly value: {
                            readonly type: StringConstructor;
                            readonly default: "";
                        };
                        readonly focus: {
                            readonly type: NumberConstructor;
                            readonly default: -1;
                        };
                        readonly times: {
                            readonly type: PropType<import("../time-picker/interface").TimeOption[]>;
                            readonly default: () => import("../time-picker/interface").TimeOption[];
                        };
                        readonly visibleCount: {
                            readonly type: NumberConstructor;
                            readonly default: 8;
                        };
                    }>> & Readonly<{
                        onChange?: (...args: any[]) => any;
                    }>, {
                        readonly value: string;
                        readonly focus: number;
                        readonly visible: boolean;
                        readonly times: import("../time-picker/interface").TimeOption[];
                        readonly visibleCount: number;
                    }, {}, {
                        FScrollbar: import("vue").DefineComponent<ExtractPropTypes<{
                            readonly shadow: {
                                type: PropType<import("../scrollbar/const").ShadowType>;
                                default: boolean;
                            };
                            readonly height: {
                                type: PropType<string | number>;
                            };
                            readonly maxHeight: {
                                type: PropType<string | number>;
                            };
                            readonly native: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            readonly always: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            readonly minSize: {
                                type: NumberConstructor;
                                default: number;
                            };
                            readonly horizontalRatioStyle: {
                                type: PropType<import("vue").StyleValue>;
                            };
                            readonly verticalRatioStyle: {
                                type: PropType<import("vue").StyleValue>;
                            };
                            readonly shadowStyle: {
                                type: PropType<import("vue").StyleValue>;
                            };
                            readonly containerClass: PropType<string | object | []>;
                            readonly containerStyle: PropType<import("vue").StyleValue>;
                            readonly contentStyle: PropType<import("vue").StyleValue>;
                            readonly thumbStyle: PropType<import("vue").StyleValue>;
                            readonly noresize: BooleanConstructor;
                        }>, {
                            scrollbarRef: import("vue").Ref<HTMLElement, HTMLElement>;
                            containerRef: import("vue").Ref<HTMLElement, HTMLElement>;
                            contentRef: import("vue").Ref<HTMLElement, HTMLElement>;
                            style: import("vue").ComputedRef<import("vue").StyleValue[]>;
                            prefixCls: string;
                            setScrollTop: (val: number, duration: number) => void;
                            setScrollLeft: (val: number, duration: number) => void;
                            scrollToEnd: (direction: "right" | "bottom", duration: number) => void;
                            update: () => void;
                            handleScroll: (event: Event) => void;
                            thumbMoveX: import("vue").Ref<number, number>;
                            thumbMoveY: import("vue").Ref<number, number>;
                            ratioX: import("vue").Ref<number, number>;
                            ratioY: import("vue").Ref<number, number>;
                            sizeHeight: import("vue").Ref<string, string>;
                            sizeWidth: import("vue").Ref<string, string>;
                            wrapperClassRef: import("vue").ComputedRef<string[]>;
                            containerClassRef: import("vue").ComputedRef<(string | object)[]>;
                            scrollX: import("vue").Ref<boolean, boolean>;
                            scrollXRatio: import("vue").Ref<number, number>;
                            scrollY: import("vue").Ref<boolean, boolean>;
                            scrollYRatio: import("vue").Ref<number, number>;
                            shadowRef: import("vue").ComputedRef<{
                                x: boolean;
                                y: boolean;
                            }>;
                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                            readonly shadow: {
                                type: PropType<import("../scrollbar/const").ShadowType>;
                                default: boolean;
                            };
                            readonly height: {
                                type: PropType<string | number>;
                            };
                            readonly maxHeight: {
                                type: PropType<string | number>;
                            };
                            readonly native: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            readonly always: {
                                type: BooleanConstructor;
                                default: boolean;
                            };
                            readonly minSize: {
                                type: NumberConstructor;
                                default: number;
                            };
                            readonly horizontalRatioStyle: {
                                type: PropType<import("vue").StyleValue>;
                            };
                            readonly verticalRatioStyle: {
                                type: PropType<import("vue").StyleValue>;
                            };
                            readonly shadowStyle: {
                                type: PropType<import("vue").StyleValue>;
                            };
                            readonly containerClass: PropType<string | object | []>;
                            readonly containerStyle: PropType<import("vue").StyleValue>;
                            readonly contentStyle: PropType<import("vue").StyleValue>;
                            readonly thumbStyle: PropType<import("vue").StyleValue>;
                            readonly noresize: BooleanConstructor;
                        }>> & Readonly<{
                            onScroll?: (...args: any[]) => any;
                        }>, {
                            readonly shadow: import("../scrollbar/const").ShadowType;
                            readonly always: boolean;
                            readonly native: boolean;
                            readonly minSize: number;
                            readonly noresize: boolean;
                        }, {}, {
                            FBar: import("vue").DefineComponent<ExtractPropTypes<{
                                readonly vertical: BooleanConstructor;
                                readonly size: StringConstructor;
                                readonly move: NumberConstructor;
                                readonly ratio: NumberConstructor;
                                readonly always: BooleanConstructor;
                                readonly scrollbarRef: PropType<HTMLElement[]>;
                                readonly containerRef: PropType<HTMLElement>;
                                readonly thumbStyle: PropType<import("vue").StyleValue>;
                            }>, {
                                prefixCls: string;
                                barRef: import("vue").Ref<HTMLElement, HTMLElement>;
                                thumbRef: import("vue").Ref<any, any>;
                                visible: import("vue").Ref<boolean, boolean>;
                                cursorDown: import("vue").Ref<any, any>;
                                barMap: import("vue").ComputedRef<{
                                    readonly offset: "offsetHeight";
                                    readonly scroll: "scrollTop";
                                    readonly scrollSize: "scrollHeight";
                                    readonly size: "height";
                                    readonly key: "vertical";
                                    readonly axis: "Y";
                                    readonly client: "clientY";
                                    readonly direction: "top";
                                } | {
                                    readonly offset: "offsetWidth";
                                    readonly scroll: "scrollLeft";
                                    readonly scrollSize: "scrollWidth";
                                    readonly size: "width";
                                    readonly key: "horizontal";
                                    readonly axis: "X";
                                    readonly client: "clientX";
                                    readonly direction: "left";
                                }>;
                                thumbStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
                                clickTrackHandler: (e: MouseEvent) => void;
                                clickThumbHandler: (e: MouseEvent) => void;
                            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
                                readonly vertical: BooleanConstructor;
                                readonly size: StringConstructor;
                                readonly move: NumberConstructor;
                                readonly ratio: NumberConstructor;
                                readonly always: BooleanConstructor;
                                readonly scrollbarRef: PropType<HTMLElement[]>;
                                readonly containerRef: PropType<HTMLElement>;
                                readonly thumbStyle: PropType<import("vue").StyleValue>;
                            }>> & Readonly<{}>, {
                                readonly always: boolean;
                                readonly vertical: boolean;
                            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                        }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                InputInner: import("vue").DefineComponent<ExtractPropTypes<{
                    readonly innerIsFocus: BooleanConstructor;
                    readonly innerIsError: BooleanConstructor;
                    readonly canEdit: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly modelValue: {
                        readonly type: PropType<import("../input/interface").InputValue>;
                    };
                    readonly type: {
                        readonly type: StringConstructor;
                        readonly default: "text";
                    };
                    readonly placeholder: {
                        readonly type: StringConstructor;
                    };
                    readonly readonly: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly disabled: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly clearable: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly maxlength: {
                        readonly type: NumberConstructor;
                    };
                    readonly showPassword: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly inputStyle: {
                        readonly type: PropType<import("vue").StyleValue>;
                        readonly default: () => import("vue").StyleValue;
                    };
                    readonly autocomplete: {
                        readonly type: StringConstructor;
                        readonly default: "off";
                    };
                }>, {
                    passwordVisible: import("vue").Ref<boolean, boolean>;
                    handlePasswordVisible: () => void;
                    showPwdSwitchIcon: import("vue").ComputedRef<boolean>;
                    handleInput: (event: string | Event) => void;
                    handleCompositionStart: () => void;
                    handleCompositionEnd: (event: Event) => void;
                    inputRefEl: import("vue").Ref<HTMLElement, HTMLElement>;
                    focus: () => void;
                    blur: () => void;
                    focused: import("vue").Ref<boolean, boolean>;
                    handleFocus: (event: Event) => void;
                    handleBlur: (event: Event) => void;
                    showClear: import("vue").ComputedRef<boolean>;
                    clear: () => void;
                    handleChange: import("lodash-es").DebouncedFunc<(event: Event) => void>;
                    onMouseLeave: (e: MouseEvent) => void;
                    onMouseEnter: (e: MouseEvent) => void;
                    handleMousedown: (e: MouseEvent) => void;
                    handleKeydown: (e: KeyboardEvent) => void;
                    prefixCls: string;
                    suffixVisible: import("vue").ComputedRef<boolean>;
                    currentValue: import("vue").WritableComputedRef<import("../input/interface").InputValue, import("../input/interface").InputValue>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "change" | "update:modelValue" | "blur" | "focus" | "input" | "keydown" | "mouseenter" | "mouseleave")[], "clear" | "change" | "update:modelValue" | "blur" | "focus" | "input" | "keydown" | "mouseenter" | "mouseleave", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                    readonly innerIsFocus: BooleanConstructor;
                    readonly innerIsError: BooleanConstructor;
                    readonly canEdit: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly modelValue: {
                        readonly type: PropType<import("../input/interface").InputValue>;
                    };
                    readonly type: {
                        readonly type: StringConstructor;
                        readonly default: "text";
                    };
                    readonly placeholder: {
                        readonly type: StringConstructor;
                    };
                    readonly readonly: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly disabled: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly clearable: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly maxlength: {
                        readonly type: NumberConstructor;
                    };
                    readonly showPassword: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly inputStyle: {
                        readonly type: PropType<import("vue").StyleValue>;
                        readonly default: () => import("vue").StyleValue;
                    };
                    readonly autocomplete: {
                        readonly type: StringConstructor;
                        readonly default: "off";
                    };
                }>> & Readonly<{
                    onFocus?: (...args: any[]) => any;
                    onBlur?: (...args: any[]) => any;
                    onChange?: (...args: any[]) => any;
                    onInput?: (...args: any[]) => any;
                    onKeydown?: (...args: any[]) => any;
                    onMouseenter?: (...args: any[]) => any;
                    onMouseleave?: (...args: any[]) => any;
                    "onUpdate:modelValue"?: (...args: any[]) => any;
                    onClear?: (...args: any[]) => any;
                }>, {
                    readonly type: string;
                    readonly disabled: boolean;
                    readonly clearable: boolean;
                    readonly canEdit: boolean;
                    readonly innerIsFocus: boolean;
                    readonly innerIsError: boolean;
                    readonly readonly: boolean;
                    readonly showPassword: boolean;
                    readonly inputStyle: import("vue").StyleValue;
                    readonly autocomplete: string;
                }, {}, {
                    EyeOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
                    EyeInvisibleOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
                    CloseCircleFilled: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                Popper: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
                        readonly modelValue: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly trigger: {
                            readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                            readonly default: "hover";
                        };
                        readonly placement: {
                            readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            readonly default: "bottom";
                        };
                        readonly offset: {
                            readonly type: NumberConstructor;
                            readonly default: 6;
                        };
                        readonly disabled: {
                            readonly type: PropType<boolean | (() => boolean)>;
                            readonly default: false;
                        };
                        readonly arrow: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly appendToContainer: {
                            readonly type: BooleanConstructor;
                            readonly default: true;
                        };
                        readonly popperClass: PropType<string | object | []>;
                        readonly popperStyle: {
                            readonly type: PropType<import("vue").StyleValue>;
                            readonly default: () => {};
                        };
                        readonly showAfter: {
                            readonly type: NumberConstructor;
                            readonly default: 0;
                        };
                        readonly hideAfter: {
                            readonly type: NumberConstructor;
                            readonly default: 200;
                        };
                        readonly getContainer: {
                            readonly type: FunctionConstructor;
                        };
                        readonly lazy: {
                            readonly type: BooleanConstructor;
                            readonly default: true;
                        };
                        readonly onlyShowTrigger: {
                            readonly type: BooleanConstructor;
                        };
                        readonly passive: {
                            readonly type: BooleanConstructor;
                            readonly default: true;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: (...args: any[]) => any;
                        onClickOutside?: (...args: any[]) => any;
                    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "clickOutside")[], import("vue").PublicProps, {
                        readonly disabled: boolean | (() => boolean);
                        readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                        readonly modelValue: boolean;
                        readonly arrow: boolean;
                        readonly appendToContainer: boolean;
                        readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                        readonly offset: number;
                        readonly popperStyle: import("vue").StyleValue;
                        readonly showAfter: number;
                        readonly hideAfter: number;
                        readonly lazy: boolean;
                        readonly onlyShowTrigger: boolean;
                        readonly passive: boolean;
                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<ExtractPropTypes<{
                        readonly modelValue: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly trigger: {
                            readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                            readonly default: "hover";
                        };
                        readonly placement: {
                            readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                            readonly default: "bottom";
                        };
                        readonly offset: {
                            readonly type: NumberConstructor;
                            readonly default: 6;
                        };
                        readonly disabled: {
                            readonly type: PropType<boolean | (() => boolean)>;
                            readonly default: false;
                        };
                        readonly arrow: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly appendToContainer: {
                            readonly type: BooleanConstructor;
                            readonly default: true;
                        };
                        readonly popperClass: PropType<string | object | []>;
                        readonly popperStyle: {
                            readonly type: PropType<import("vue").StyleValue>;
                            readonly default: () => {};
                        };
                        readonly showAfter: {
                            readonly type: NumberConstructor;
                            readonly default: 0;
                        };
                        readonly hideAfter: {
                            readonly type: NumberConstructor;
                            readonly default: 200;
                        };
                        readonly getContainer: {
                            readonly type: FunctionConstructor;
                        };
                        readonly lazy: {
                            readonly type: BooleanConstructor;
                            readonly default: true;
                        };
                        readonly onlyShowTrigger: {
                            readonly type: BooleanConstructor;
                        };
                        readonly passive: {
                            readonly type: BooleanConstructor;
                            readonly default: true;
                        };
                    }>> & Readonly<{
                        "onUpdate:modelValue"?: (...args: any[]) => any;
                        onClickOutside?: (...args: any[]) => any;
                    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                        readonly disabled: boolean | (() => boolean);
                        readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                        readonly modelValue: boolean;
                        readonly arrow: boolean;
                        readonly appendToContainer: boolean;
                        readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                        readonly offset: number;
                        readonly popperStyle: import("vue").StyleValue;
                        readonly showAfter: number;
                        readonly hideAfter: number;
                        readonly lazy: boolean;
                        readonly onlyShowTrigger: boolean;
                        readonly passive: boolean;
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
                    readonly modelValue: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly trigger: {
                        readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                        readonly default: "hover";
                    };
                    readonly placement: {
                        readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        readonly default: "bottom";
                    };
                    readonly offset: {
                        readonly type: NumberConstructor;
                        readonly default: 6;
                    };
                    readonly disabled: {
                        readonly type: PropType<boolean | (() => boolean)>;
                        readonly default: false;
                    };
                    readonly arrow: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly appendToContainer: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly popperClass: PropType<string | object | []>;
                    readonly popperStyle: {
                        readonly type: PropType<import("vue").StyleValue>;
                        readonly default: () => {};
                    };
                    readonly showAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 0;
                    };
                    readonly hideAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 200;
                    };
                    readonly getContainer: {
                        readonly type: FunctionConstructor;
                    };
                    readonly lazy: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly onlyShowTrigger: {
                        readonly type: BooleanConstructor;
                    };
                    readonly passive: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: (...args: any[]) => any;
                    onClickOutside?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "clickOutside")[], "update:modelValue" | "clickOutside", {
                    readonly disabled: boolean | (() => boolean);
                    readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                    readonly modelValue: boolean;
                    readonly arrow: boolean;
                    readonly appendToContainer: boolean;
                    readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                    readonly offset: number;
                    readonly popperStyle: import("vue").StyleValue;
                    readonly showAfter: number;
                    readonly hideAfter: number;
                    readonly lazy: boolean;
                    readonly onlyShowTrigger: boolean;
                    readonly passive: boolean;
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
                ClockCircleOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
                FButton: {
                    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
                        readonly disabled: {
                            readonly type: PropType<boolean>;
                            readonly default: () => boolean;
                        };
                        readonly htmlType: {
                            readonly type: PropType<"button" | "submit" | "reset">;
                            readonly default: "button";
                        };
                        readonly size: {
                            readonly type: PropType<import("../button/interface").Size>;
                            readonly default: "middle";
                        };
                        readonly loading: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly long: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly throttle: {
                            readonly type: NumberConstructor;
                            readonly default: 300;
                        };
                        readonly type: {
                            readonly type: PropType<import("../button/interface").Type>;
                            readonly default: "default";
                        };
                        readonly iconPlacement: {
                            readonly type: PropType<"left" | "right">;
                            readonly default: "left";
                        };
                    }>> & Readonly<{
                        onClick?: (...args: any[]) => any;
                    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                        readonly type: import("../button/interface").Type;
                        readonly size: import("../button/interface").Size;
                        readonly disabled: boolean;
                        readonly htmlType: "button" | "submit" | "reset";
                        readonly loading: boolean;
                        readonly long: boolean;
                        readonly throttle: number;
                        readonly iconPlacement: "left" | "right";
                    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                        P: {};
                        B: {};
                        D: {};
                        C: {};
                        M: {};
                        Defaults: {};
                    }, Readonly<ExtractPropTypes<{
                        readonly disabled: {
                            readonly type: PropType<boolean>;
                            readonly default: () => boolean;
                        };
                        readonly htmlType: {
                            readonly type: PropType<"button" | "submit" | "reset">;
                            readonly default: "button";
                        };
                        readonly size: {
                            readonly type: PropType<import("../button/interface").Size>;
                            readonly default: "middle";
                        };
                        readonly loading: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly long: {
                            readonly type: BooleanConstructor;
                            readonly default: false;
                        };
                        readonly throttle: {
                            readonly type: NumberConstructor;
                            readonly default: 300;
                        };
                        readonly type: {
                            readonly type: PropType<import("../button/interface").Type>;
                            readonly default: "default";
                        };
                        readonly iconPlacement: {
                            readonly type: PropType<"left" | "right">;
                            readonly default: "left";
                        };
                    }>> & Readonly<{
                        onClick?: (...args: any[]) => any;
                    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                        readonly type: import("../button/interface").Type;
                        readonly size: import("../button/interface").Size;
                        readonly disabled: boolean;
                        readonly htmlType: "button" | "submit" | "reset";
                        readonly loading: boolean;
                        readonly long: boolean;
                        readonly throttle: number;
                        readonly iconPlacement: "left" | "right";
                    }>;
                    __isFragment?: never;
                    __isTeleport?: never;
                    __isSuspense?: never;
                } & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
                    readonly disabled: {
                        readonly type: PropType<boolean>;
                        readonly default: () => boolean;
                    };
                    readonly htmlType: {
                        readonly type: PropType<"button" | "submit" | "reset">;
                        readonly default: "button";
                    };
                    readonly size: {
                        readonly type: PropType<import("../button/interface").Size>;
                        readonly default: "middle";
                    };
                    readonly loading: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly long: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly throttle: {
                        readonly type: NumberConstructor;
                        readonly default: 300;
                    };
                    readonly type: {
                        readonly type: PropType<import("../button/interface").Type>;
                        readonly default: "default";
                    };
                    readonly iconPlacement: {
                        readonly type: PropType<"left" | "right">;
                        readonly default: "left";
                    };
                }>> & Readonly<{
                    onClick?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                    readonly type: import("../button/interface").Type;
                    readonly size: import("../button/interface").Size;
                    readonly disabled: boolean;
                    readonly htmlType: "button" | "submit" | "reset";
                    readonly loading: boolean;
                    readonly long: boolean;
                    readonly throttle: number;
                    readonly iconPlacement: "left" | "right";
                }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
            } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                P: {};
                B: {};
                D: {};
                C: {};
                M: {};
                Defaults: {};
            }, Readonly<ExtractPropTypes<{
                readonly modelValue: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly open: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly appendToContainer: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly getContainer: {
                    readonly type: PropType<import("../_util/interface").GetContainer>;
                };
                readonly placeholder: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly isRange: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly disabled: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly clearable: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly format: {
                    readonly type: StringConstructor;
                    readonly default: "HH:mm:ss";
                };
                readonly hourStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly minuteStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly secondStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly disabledHours: PropType<(h: number) => boolean>;
                readonly disabledMinutes: PropType<(h: number, m: number) => boolean>;
                readonly disabledSeconds: PropType<(h: number, m: number, s: number) => boolean>;
                readonly control: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly showSuffix: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly inputClass: {
                    readonly type: PropType<string | object | []>;
                };
            }>> & Readonly<{
                onFocus?: (...args: any[]) => any;
                onBlur?: (...args: any[]) => any;
                onChange?: (...args: any[]) => any;
                "onUpdate:modelValue"?: (...args: any[]) => any;
                "onUpdate:open"?: (...args: any[]) => any;
            }>, {
                prefixCls: string;
                isError: import("vue").Ref<boolean, boolean>;
                innerDisabled: import("vue").ComputedRef<boolean>;
                classes: import("vue").ComputedRef<(string | object)[]>;
                displayValue: import("vue").ComputedRef<any>;
                isOpened: import("vue").WritableComputedRef<boolean, boolean>;
                currentValue: import("vue").WritableComputedRef<string, string>;
                tempValue: import("vue").Ref<any, any>;
                handleInput: (val: string) => void;
                handleBlur: (event: Event) => void;
                clear: () => void;
                changeTime: (val: string) => void;
                showControl: import("vue").ComputedRef<boolean>;
                showNowShortcut: import("vue").ComputedRef<boolean>;
                setCurrentTime: () => void;
                confirmChangeTime: () => void;
                activeTime: import("vue").Ref<any, any>;
                inputPlaceholder: import("vue").ComputedRef<string>;
                t: import("../config-provider/const").TranslatorType;
                attrs: {
                    [x: string]: unknown;
                };
                timeSelectRef: import("vue").Ref<any, any>;
            }, {}, {}, {}, {
                readonly disabled: boolean;
                readonly modelValue: string;
                readonly open: boolean;
                readonly clearable: boolean;
                readonly placeholder: string;
                readonly appendToContainer: boolean;
                readonly control: boolean;
                readonly format: string;
                readonly hourStep: number;
                readonly minuteStep: number;
                readonly secondStep: number;
                readonly isRange: boolean;
                readonly showSuffix: boolean;
            }>;
            __isFragment?: never;
            __isTeleport?: never;
            __isSuspense?: never;
        } & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
            readonly modelValue: {
                readonly type: StringConstructor;
                readonly default: "";
            };
            readonly open: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly appendToContainer: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly getContainer: {
                readonly type: PropType<import("../_util/interface").GetContainer>;
            };
            readonly placeholder: {
                readonly type: StringConstructor;
                readonly default: "";
            };
            readonly isRange: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly disabled: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly clearable: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly format: {
                readonly type: StringConstructor;
                readonly default: "HH:mm:ss";
            };
            readonly hourStep: {
                readonly type: NumberConstructor;
                readonly default: 1;
            };
            readonly minuteStep: {
                readonly type: NumberConstructor;
                readonly default: 1;
            };
            readonly secondStep: {
                readonly type: NumberConstructor;
                readonly default: 1;
            };
            readonly disabledHours: PropType<(h: number) => boolean>;
            readonly disabledMinutes: PropType<(h: number, m: number) => boolean>;
            readonly disabledSeconds: PropType<(h: number, m: number, s: number) => boolean>;
            readonly control: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly showSuffix: {
                readonly type: BooleanConstructor;
                readonly default: true;
            };
            readonly inputClass: {
                readonly type: PropType<string | object | []>;
            };
        }>> & Readonly<{
            onFocus?: (...args: any[]) => any;
            onBlur?: (...args: any[]) => any;
            onChange?: (...args: any[]) => any;
            "onUpdate:modelValue"?: (...args: any[]) => any;
            "onUpdate:open"?: (...args: any[]) => any;
        }>, {
            prefixCls: string;
            isError: import("vue").Ref<boolean, boolean>;
            innerDisabled: import("vue").ComputedRef<boolean>;
            classes: import("vue").ComputedRef<(string | object)[]>;
            displayValue: import("vue").ComputedRef<any>;
            isOpened: import("vue").WritableComputedRef<boolean, boolean>;
            currentValue: import("vue").WritableComputedRef<string, string>;
            tempValue: import("vue").Ref<any, any>;
            handleInput: (val: string) => void;
            handleBlur: (event: Event) => void;
            clear: () => void;
            changeTime: (val: string) => void;
            showControl: import("vue").ComputedRef<boolean>;
            showNowShortcut: import("vue").ComputedRef<boolean>;
            setCurrentTime: () => void;
            confirmChangeTime: () => void;
            activeTime: import("vue").Ref<any, any>;
            inputPlaceholder: import("vue").ComputedRef<string>;
            t: import("../config-provider/const").TranslatorType;
            attrs: {
                [x: string]: unknown;
            };
            timeSelectRef: import("vue").Ref<any, any>;
        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue" | "blur" | "focus" | "update:open")[], "change" | "update:modelValue" | "blur" | "focus" | "update:open", {
            readonly disabled: boolean;
            readonly modelValue: string;
            readonly open: boolean;
            readonly clearable: boolean;
            readonly placeholder: string;
            readonly appendToContainer: boolean;
            readonly control: boolean;
            readonly format: string;
            readonly hourStep: number;
            readonly minuteStep: number;
            readonly secondStep: number;
            readonly isRange: boolean;
            readonly showSuffix: boolean;
        }, {}, string, {}, {
            TimeSelect: import("vue").DefineComponent<ExtractPropTypes<{
                readonly visible: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly modelValue: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly format: {
                    readonly type: StringConstructor;
                    readonly default: "HH:mm:ss";
                };
                readonly hourStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly minuteStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly secondStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly disabledHours: {
                    readonly type: PropType<(h: number) => boolean>;
                };
                readonly disabledMinutes: {
                    readonly type: PropType<(h: number, m: number) => boolean>;
                };
                readonly disabledSeconds: {
                    readonly type: PropType<(h: number, m: number, s: number) => boolean>;
                };
                readonly visibleCount: {
                    readonly type: NumberConstructor;
                    readonly default: 8;
                };
            }>, {
                prefixCls: string;
                canSelectHours: import("vue").ComputedRef<import("../time-picker/interface").TimeOption[]>;
                canSelectMinutes: import("vue").ComputedRef<import("../time-picker/interface").TimeOption[]>;
                canSelectSeconds: import("vue").ComputedRef<import("../time-picker/interface").TimeOption[]>;
                changeSelectedHour: (option: import("../time-picker/interface").TimeOption) => void;
                changeSelectedMinute: (option: import("../time-picker/interface").TimeOption) => void;
                changeSelectedSeconds: (option: import("../time-picker/interface").TimeOption) => void;
                focusKey: {
                    1: number;
                    2: number;
                    4: number;
                };
                selectedTime: {
                    hour: string;
                    minute: string;
                    seconds: string;
                };
                resetTime: () => void;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("change" | "update:modelValue")[], "change" | "update:modelValue", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                readonly visible: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly modelValue: {
                    readonly type: StringConstructor;
                    readonly default: "";
                };
                readonly format: {
                    readonly type: StringConstructor;
                    readonly default: "HH:mm:ss";
                };
                readonly hourStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly minuteStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly secondStep: {
                    readonly type: NumberConstructor;
                    readonly default: 1;
                };
                readonly disabledHours: {
                    readonly type: PropType<(h: number) => boolean>;
                };
                readonly disabledMinutes: {
                    readonly type: PropType<(h: number, m: number) => boolean>;
                };
                readonly disabledSeconds: {
                    readonly type: PropType<(h: number, m: number, s: number) => boolean>;
                };
                readonly visibleCount: {
                    readonly type: NumberConstructor;
                    readonly default: 8;
                };
            }>> & Readonly<{
                onChange?: (...args: any[]) => any;
                "onUpdate:modelValue"?: (...args: any[]) => any;
            }>, {
                readonly modelValue: string;
                readonly format: string;
                readonly hourStep: number;
                readonly minuteStep: number;
                readonly secondStep: number;
                readonly visible: boolean;
                readonly visibleCount: number;
            }, {}, {
                PickerItem: import("vue").DefineComponent<ExtractPropTypes<{
                    readonly visible: BooleanConstructor;
                    readonly value: {
                        readonly type: StringConstructor;
                        readonly default: "";
                    };
                    readonly focus: {
                        readonly type: NumberConstructor;
                        readonly default: -1;
                    };
                    readonly times: {
                        readonly type: PropType<import("../time-picker/interface").TimeOption[]>;
                        readonly default: () => import("../time-picker/interface").TimeOption[];
                    };
                    readonly visibleCount: {
                        readonly type: NumberConstructor;
                        readonly default: 8;
                    };
                }>, {
                    visibleHeight: import("vue").ComputedRef<number>;
                    style: import("vue").ComputedRef<{
                        'padding-bottom': string;
                    }>;
                    scrollbarRef: import("vue").Ref<any, any>;
                    prefixCls: string;
                    rootRefEl: import("vue").Ref<HTMLElement, HTMLElement>;
                    selectedIndex: import("vue").ComputedRef<number>;
                    selectedTime: (e: MouseEvent) => void;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "change"[], "change", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                    readonly visible: BooleanConstructor;
                    readonly value: {
                        readonly type: StringConstructor;
                        readonly default: "";
                    };
                    readonly focus: {
                        readonly type: NumberConstructor;
                        readonly default: -1;
                    };
                    readonly times: {
                        readonly type: PropType<import("../time-picker/interface").TimeOption[]>;
                        readonly default: () => import("../time-picker/interface").TimeOption[];
                    };
                    readonly visibleCount: {
                        readonly type: NumberConstructor;
                        readonly default: 8;
                    };
                }>> & Readonly<{
                    onChange?: (...args: any[]) => any;
                }>, {
                    readonly value: string;
                    readonly focus: number;
                    readonly visible: boolean;
                    readonly times: import("../time-picker/interface").TimeOption[];
                    readonly visibleCount: number;
                }, {}, {
                    FScrollbar: import("vue").DefineComponent<ExtractPropTypes<{
                        readonly shadow: {
                            type: PropType<import("../scrollbar/const").ShadowType>;
                            default: boolean;
                        };
                        readonly height: {
                            type: PropType<string | number>;
                        };
                        readonly maxHeight: {
                            type: PropType<string | number>;
                        };
                        readonly native: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        readonly always: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        readonly minSize: {
                            type: NumberConstructor;
                            default: number;
                        };
                        readonly horizontalRatioStyle: {
                            type: PropType<import("vue").StyleValue>;
                        };
                        readonly verticalRatioStyle: {
                            type: PropType<import("vue").StyleValue>;
                        };
                        readonly shadowStyle: {
                            type: PropType<import("vue").StyleValue>;
                        };
                        readonly containerClass: PropType<string | object | []>;
                        readonly containerStyle: PropType<import("vue").StyleValue>;
                        readonly contentStyle: PropType<import("vue").StyleValue>;
                        readonly thumbStyle: PropType<import("vue").StyleValue>;
                        readonly noresize: BooleanConstructor;
                    }>, {
                        scrollbarRef: import("vue").Ref<HTMLElement, HTMLElement>;
                        containerRef: import("vue").Ref<HTMLElement, HTMLElement>;
                        contentRef: import("vue").Ref<HTMLElement, HTMLElement>;
                        style: import("vue").ComputedRef<import("vue").StyleValue[]>;
                        prefixCls: string;
                        setScrollTop: (val: number, duration: number) => void;
                        setScrollLeft: (val: number, duration: number) => void;
                        scrollToEnd: (direction: "right" | "bottom", duration: number) => void;
                        update: () => void;
                        handleScroll: (event: Event) => void;
                        thumbMoveX: import("vue").Ref<number, number>;
                        thumbMoveY: import("vue").Ref<number, number>;
                        ratioX: import("vue").Ref<number, number>;
                        ratioY: import("vue").Ref<number, number>;
                        sizeHeight: import("vue").Ref<string, string>;
                        sizeWidth: import("vue").Ref<string, string>;
                        wrapperClassRef: import("vue").ComputedRef<string[]>;
                        containerClassRef: import("vue").ComputedRef<(string | object)[]>;
                        scrollX: import("vue").Ref<boolean, boolean>;
                        scrollXRatio: import("vue").Ref<number, number>;
                        scrollY: import("vue").Ref<boolean, boolean>;
                        scrollYRatio: import("vue").Ref<number, number>;
                        shadowRef: import("vue").ComputedRef<{
                            x: boolean;
                            y: boolean;
                        }>;
                    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "scroll"[], "scroll", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                        readonly shadow: {
                            type: PropType<import("../scrollbar/const").ShadowType>;
                            default: boolean;
                        };
                        readonly height: {
                            type: PropType<string | number>;
                        };
                        readonly maxHeight: {
                            type: PropType<string | number>;
                        };
                        readonly native: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        readonly always: {
                            type: BooleanConstructor;
                            default: boolean;
                        };
                        readonly minSize: {
                            type: NumberConstructor;
                            default: number;
                        };
                        readonly horizontalRatioStyle: {
                            type: PropType<import("vue").StyleValue>;
                        };
                        readonly verticalRatioStyle: {
                            type: PropType<import("vue").StyleValue>;
                        };
                        readonly shadowStyle: {
                            type: PropType<import("vue").StyleValue>;
                        };
                        readonly containerClass: PropType<string | object | []>;
                        readonly containerStyle: PropType<import("vue").StyleValue>;
                        readonly contentStyle: PropType<import("vue").StyleValue>;
                        readonly thumbStyle: PropType<import("vue").StyleValue>;
                        readonly noresize: BooleanConstructor;
                    }>> & Readonly<{
                        onScroll?: (...args: any[]) => any;
                    }>, {
                        readonly shadow: import("../scrollbar/const").ShadowType;
                        readonly always: boolean;
                        readonly native: boolean;
                        readonly minSize: number;
                        readonly noresize: boolean;
                    }, {}, {
                        FBar: import("vue").DefineComponent<ExtractPropTypes<{
                            readonly vertical: BooleanConstructor;
                            readonly size: StringConstructor;
                            readonly move: NumberConstructor;
                            readonly ratio: NumberConstructor;
                            readonly always: BooleanConstructor;
                            readonly scrollbarRef: PropType<HTMLElement[]>;
                            readonly containerRef: PropType<HTMLElement>;
                            readonly thumbStyle: PropType<import("vue").StyleValue>;
                        }>, {
                            prefixCls: string;
                            barRef: import("vue").Ref<HTMLElement, HTMLElement>;
                            thumbRef: import("vue").Ref<any, any>;
                            visible: import("vue").Ref<boolean, boolean>;
                            cursorDown: import("vue").Ref<any, any>;
                            barMap: import("vue").ComputedRef<{
                                readonly offset: "offsetHeight";
                                readonly scroll: "scrollTop";
                                readonly scrollSize: "scrollHeight";
                                readonly size: "height";
                                readonly key: "vertical";
                                readonly axis: "Y";
                                readonly client: "clientY";
                                readonly direction: "top";
                            } | {
                                readonly offset: "offsetWidth";
                                readonly scroll: "scrollLeft";
                                readonly scrollSize: "scrollWidth";
                                readonly size: "width";
                                readonly key: "horizontal";
                                readonly axis: "X";
                                readonly client: "clientX";
                                readonly direction: "left";
                            }>;
                            thumbStyle: import("vue").ComputedRef<import("vue").StyleValue[]>;
                            clickTrackHandler: (e: MouseEvent) => void;
                            clickThumbHandler: (e: MouseEvent) => void;
                        }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
                            readonly vertical: BooleanConstructor;
                            readonly size: StringConstructor;
                            readonly move: NumberConstructor;
                            readonly ratio: NumberConstructor;
                            readonly always: BooleanConstructor;
                            readonly scrollbarRef: PropType<HTMLElement[]>;
                            readonly containerRef: PropType<HTMLElement>;
                            readonly thumbStyle: PropType<import("vue").StyleValue>;
                        }>> & Readonly<{}>, {
                            readonly always: boolean;
                            readonly vertical: boolean;
                        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
                }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            InputInner: import("vue").DefineComponent<ExtractPropTypes<{
                readonly innerIsFocus: BooleanConstructor;
                readonly innerIsError: BooleanConstructor;
                readonly canEdit: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly modelValue: {
                    readonly type: PropType<import("../input/interface").InputValue>;
                };
                readonly type: {
                    readonly type: StringConstructor;
                    readonly default: "text";
                };
                readonly placeholder: {
                    readonly type: StringConstructor;
                };
                readonly readonly: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly disabled: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly clearable: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly maxlength: {
                    readonly type: NumberConstructor;
                };
                readonly showPassword: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly inputStyle: {
                    readonly type: PropType<import("vue").StyleValue>;
                    readonly default: () => import("vue").StyleValue;
                };
                readonly autocomplete: {
                    readonly type: StringConstructor;
                    readonly default: "off";
                };
            }>, {
                passwordVisible: import("vue").Ref<boolean, boolean>;
                handlePasswordVisible: () => void;
                showPwdSwitchIcon: import("vue").ComputedRef<boolean>;
                handleInput: (event: string | Event) => void;
                handleCompositionStart: () => void;
                handleCompositionEnd: (event: Event) => void;
                inputRefEl: import("vue").Ref<HTMLElement, HTMLElement>;
                focus: () => void;
                blur: () => void;
                focused: import("vue").Ref<boolean, boolean>;
                handleFocus: (event: Event) => void;
                handleBlur: (event: Event) => void;
                showClear: import("vue").ComputedRef<boolean>;
                clear: () => void;
                handleChange: import("lodash-es").DebouncedFunc<(event: Event) => void>;
                onMouseLeave: (e: MouseEvent) => void;
                onMouseEnter: (e: MouseEvent) => void;
                handleMousedown: (e: MouseEvent) => void;
                handleKeydown: (e: KeyboardEvent) => void;
                prefixCls: string;
                suffixVisible: import("vue").ComputedRef<boolean>;
                currentValue: import("vue").WritableComputedRef<import("../input/interface").InputValue, import("../input/interface").InputValue>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("clear" | "change" | "update:modelValue" | "blur" | "focus" | "input" | "keydown" | "mouseenter" | "mouseleave")[], "clear" | "change" | "update:modelValue" | "blur" | "focus" | "input" | "keydown" | "mouseenter" | "mouseleave", import("vue").PublicProps, Readonly<ExtractPropTypes<{
                readonly innerIsFocus: BooleanConstructor;
                readonly innerIsError: BooleanConstructor;
                readonly canEdit: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly modelValue: {
                    readonly type: PropType<import("../input/interface").InputValue>;
                };
                readonly type: {
                    readonly type: StringConstructor;
                    readonly default: "text";
                };
                readonly placeholder: {
                    readonly type: StringConstructor;
                };
                readonly readonly: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly disabled: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly clearable: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly maxlength: {
                    readonly type: NumberConstructor;
                };
                readonly showPassword: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly inputStyle: {
                    readonly type: PropType<import("vue").StyleValue>;
                    readonly default: () => import("vue").StyleValue;
                };
                readonly autocomplete: {
                    readonly type: StringConstructor;
                    readonly default: "off";
                };
            }>> & Readonly<{
                onFocus?: (...args: any[]) => any;
                onBlur?: (...args: any[]) => any;
                onChange?: (...args: any[]) => any;
                onInput?: (...args: any[]) => any;
                onKeydown?: (...args: any[]) => any;
                onMouseenter?: (...args: any[]) => any;
                onMouseleave?: (...args: any[]) => any;
                "onUpdate:modelValue"?: (...args: any[]) => any;
                onClear?: (...args: any[]) => any;
            }>, {
                readonly type: string;
                readonly disabled: boolean;
                readonly clearable: boolean;
                readonly canEdit: boolean;
                readonly innerIsFocus: boolean;
                readonly innerIsError: boolean;
                readonly readonly: boolean;
                readonly showPassword: boolean;
                readonly inputStyle: import("vue").StyleValue;
                readonly autocomplete: string;
            }, {}, {
                EyeOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
                EyeInvisibleOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
                CloseCircleFilled: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
            }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
            Popper: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
                    readonly modelValue: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly trigger: {
                        readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                        readonly default: "hover";
                    };
                    readonly placement: {
                        readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        readonly default: "bottom";
                    };
                    readonly offset: {
                        readonly type: NumberConstructor;
                        readonly default: 6;
                    };
                    readonly disabled: {
                        readonly type: PropType<boolean | (() => boolean)>;
                        readonly default: false;
                    };
                    readonly arrow: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly appendToContainer: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly popperClass: PropType<string | object | []>;
                    readonly popperStyle: {
                        readonly type: PropType<import("vue").StyleValue>;
                        readonly default: () => {};
                    };
                    readonly showAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 0;
                    };
                    readonly hideAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 200;
                    };
                    readonly getContainer: {
                        readonly type: FunctionConstructor;
                    };
                    readonly lazy: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly onlyShowTrigger: {
                        readonly type: BooleanConstructor;
                    };
                    readonly passive: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: (...args: any[]) => any;
                    onClickOutside?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "clickOutside")[], import("vue").PublicProps, {
                    readonly disabled: boolean | (() => boolean);
                    readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                    readonly modelValue: boolean;
                    readonly arrow: boolean;
                    readonly appendToContainer: boolean;
                    readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                    readonly offset: number;
                    readonly popperStyle: import("vue").StyleValue;
                    readonly showAfter: number;
                    readonly hideAfter: number;
                    readonly lazy: boolean;
                    readonly onlyShowTrigger: boolean;
                    readonly passive: boolean;
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<ExtractPropTypes<{
                    readonly modelValue: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly trigger: {
                        readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                        readonly default: "hover";
                    };
                    readonly placement: {
                        readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                        readonly default: "bottom";
                    };
                    readonly offset: {
                        readonly type: NumberConstructor;
                        readonly default: 6;
                    };
                    readonly disabled: {
                        readonly type: PropType<boolean | (() => boolean)>;
                        readonly default: false;
                    };
                    readonly arrow: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly appendToContainer: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly popperClass: PropType<string | object | []>;
                    readonly popperStyle: {
                        readonly type: PropType<import("vue").StyleValue>;
                        readonly default: () => {};
                    };
                    readonly showAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 0;
                    };
                    readonly hideAfter: {
                        readonly type: NumberConstructor;
                        readonly default: 200;
                    };
                    readonly getContainer: {
                        readonly type: FunctionConstructor;
                    };
                    readonly lazy: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                    readonly onlyShowTrigger: {
                        readonly type: BooleanConstructor;
                    };
                    readonly passive: {
                        readonly type: BooleanConstructor;
                        readonly default: true;
                    };
                }>> & Readonly<{
                    "onUpdate:modelValue"?: (...args: any[]) => any;
                    onClickOutside?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                    readonly disabled: boolean | (() => boolean);
                    readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                    readonly modelValue: boolean;
                    readonly arrow: boolean;
                    readonly appendToContainer: boolean;
                    readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                    readonly offset: number;
                    readonly popperStyle: import("vue").StyleValue;
                    readonly showAfter: number;
                    readonly hideAfter: number;
                    readonly lazy: boolean;
                    readonly onlyShowTrigger: boolean;
                    readonly passive: boolean;
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
                readonly modelValue: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly trigger: {
                    readonly type: PropType<"click" | "hover" | "contextmenu" | "focus">;
                    readonly default: "hover";
                };
                readonly placement: {
                    readonly type: PropType<"left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end">;
                    readonly default: "bottom";
                };
                readonly offset: {
                    readonly type: NumberConstructor;
                    readonly default: 6;
                };
                readonly disabled: {
                    readonly type: PropType<boolean | (() => boolean)>;
                    readonly default: false;
                };
                readonly arrow: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly appendToContainer: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly popperClass: PropType<string | object | []>;
                readonly popperStyle: {
                    readonly type: PropType<import("vue").StyleValue>;
                    readonly default: () => {};
                };
                readonly showAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 0;
                };
                readonly hideAfter: {
                    readonly type: NumberConstructor;
                    readonly default: 200;
                };
                readonly getContainer: {
                    readonly type: FunctionConstructor;
                };
                readonly lazy: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
                readonly onlyShowTrigger: {
                    readonly type: BooleanConstructor;
                };
                readonly passive: {
                    readonly type: BooleanConstructor;
                    readonly default: true;
                };
            }>> & Readonly<{
                "onUpdate:modelValue"?: (...args: any[]) => any;
                onClickOutside?: (...args: any[]) => any;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "clickOutside")[], "update:modelValue" | "clickOutside", {
                readonly disabled: boolean | (() => boolean);
                readonly trigger: "click" | "hover" | "contextmenu" | "focus";
                readonly modelValue: boolean;
                readonly arrow: boolean;
                readonly appendToContainer: boolean;
                readonly placement: "left" | "right" | "top" | "bottom" | "top-start" | "top-end" | "bottom-start" | "bottom-end" | "right-start" | "right-end" | "left-start" | "left-end";
                readonly offset: number;
                readonly popperStyle: import("vue").StyleValue;
                readonly showAfter: number;
                readonly hideAfter: number;
                readonly lazy: boolean;
                readonly onlyShowTrigger: boolean;
                readonly passive: boolean;
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
            ClockCircleOutlined: (props?: import("../icon/IconWrapper").IconProps) => import("vue/jsx-runtime").JSX.Element;
            FButton: {
                new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
                    readonly disabled: {
                        readonly type: PropType<boolean>;
                        readonly default: () => boolean;
                    };
                    readonly htmlType: {
                        readonly type: PropType<"button" | "submit" | "reset">;
                        readonly default: "button";
                    };
                    readonly size: {
                        readonly type: PropType<import("../button/interface").Size>;
                        readonly default: "middle";
                    };
                    readonly loading: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly long: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly throttle: {
                        readonly type: NumberConstructor;
                        readonly default: 300;
                    };
                    readonly type: {
                        readonly type: PropType<import("../button/interface").Type>;
                        readonly default: "default";
                    };
                    readonly iconPlacement: {
                        readonly type: PropType<"left" | "right">;
                        readonly default: "left";
                    };
                }>> & Readonly<{
                    onClick?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
                    readonly type: import("../button/interface").Type;
                    readonly size: import("../button/interface").Size;
                    readonly disabled: boolean;
                    readonly htmlType: "button" | "submit" | "reset";
                    readonly loading: boolean;
                    readonly long: boolean;
                    readonly throttle: number;
                    readonly iconPlacement: "left" | "right";
                }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
                    P: {};
                    B: {};
                    D: {};
                    C: {};
                    M: {};
                    Defaults: {};
                }, Readonly<ExtractPropTypes<{
                    readonly disabled: {
                        readonly type: PropType<boolean>;
                        readonly default: () => boolean;
                    };
                    readonly htmlType: {
                        readonly type: PropType<"button" | "submit" | "reset">;
                        readonly default: "button";
                    };
                    readonly size: {
                        readonly type: PropType<import("../button/interface").Size>;
                        readonly default: "middle";
                    };
                    readonly loading: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly long: {
                        readonly type: BooleanConstructor;
                        readonly default: false;
                    };
                    readonly throttle: {
                        readonly type: NumberConstructor;
                        readonly default: 300;
                    };
                    readonly type: {
                        readonly type: PropType<import("../button/interface").Type>;
                        readonly default: "default";
                    };
                    readonly iconPlacement: {
                        readonly type: PropType<"left" | "right">;
                        readonly default: "left";
                    };
                }>> & Readonly<{
                    onClick?: (...args: any[]) => any;
                }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
                    readonly type: import("../button/interface").Type;
                    readonly size: import("../button/interface").Size;
                    readonly disabled: boolean;
                    readonly htmlType: "button" | "submit" | "reset";
                    readonly loading: boolean;
                    readonly long: boolean;
                    readonly throttle: number;
                    readonly iconPlacement: "left" | "right";
                }>;
                __isFragment?: never;
                __isTeleport?: never;
                __isSuspense?: never;
            } & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
                readonly disabled: {
                    readonly type: PropType<boolean>;
                    readonly default: () => boolean;
                };
                readonly htmlType: {
                    readonly type: PropType<"button" | "submit" | "reset">;
                    readonly default: "button";
                };
                readonly size: {
                    readonly type: PropType<import("../button/interface").Size>;
                    readonly default: "middle";
                };
                readonly loading: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly long: {
                    readonly type: BooleanConstructor;
                    readonly default: false;
                };
                readonly throttle: {
                    readonly type: NumberConstructor;
                    readonly default: 300;
                };
                readonly type: {
                    readonly type: PropType<import("../button/interface").Type>;
                    readonly default: "default";
                };
                readonly iconPlacement: {
                    readonly type: PropType<"left" | "right">;
                    readonly default: "left";
                };
            }>> & Readonly<{
                onClick?: (...args: any[]) => any;
            }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
                readonly type: import("../button/interface").Type;
                readonly size: import("../button/interface").Size;
                readonly disabled: boolean;
                readonly htmlType: "button" | "submit" | "reset";
                readonly loading: boolean;
                readonly long: boolean;
                readonly throttle: number;
                readonly iconPlacement: "left" | "right";
            }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
        } & import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
    }, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
    FButton: {
        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<{
            readonly disabled: {
                readonly type: PropType<boolean>;
                readonly default: () => boolean;
            };
            readonly htmlType: {
                readonly type: PropType<"button" | "submit" | "reset">;
                readonly default: "button";
            };
            readonly size: {
                readonly type: PropType<import("../button/interface").Size>;
                readonly default: "middle";
            };
            readonly loading: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly long: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly throttle: {
                readonly type: NumberConstructor;
                readonly default: 300;
            };
            readonly type: {
                readonly type: PropType<import("../button/interface").Type>;
                readonly default: "default";
            };
            readonly iconPlacement: {
                readonly type: PropType<"left" | "right">;
                readonly default: "left";
            };
        }>> & Readonly<{
            onClick?: (...args: any[]) => any;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], import("vue").PublicProps, {
            readonly type: import("../button/interface").Type;
            readonly size: import("../button/interface").Size;
            readonly disabled: boolean;
            readonly htmlType: "button" | "submit" | "reset";
            readonly loading: boolean;
            readonly long: boolean;
            readonly throttle: number;
            readonly iconPlacement: "left" | "right";
        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
            P: {};
            B: {};
            D: {};
            C: {};
            M: {};
            Defaults: {};
        }, Readonly<ExtractPropTypes<{
            readonly disabled: {
                readonly type: PropType<boolean>;
                readonly default: () => boolean;
            };
            readonly htmlType: {
                readonly type: PropType<"button" | "submit" | "reset">;
                readonly default: "button";
            };
            readonly size: {
                readonly type: PropType<import("../button/interface").Size>;
                readonly default: "middle";
            };
            readonly loading: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly long: {
                readonly type: BooleanConstructor;
                readonly default: false;
            };
            readonly throttle: {
                readonly type: NumberConstructor;
                readonly default: 300;
            };
            readonly type: {
                readonly type: PropType<import("../button/interface").Type>;
                readonly default: "default";
            };
            readonly iconPlacement: {
                readonly type: PropType<"left" | "right">;
                readonly default: "left";
            };
        }>> & Readonly<{
            onClick?: (...args: any[]) => any;
        }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, {
            readonly type: import("../button/interface").Type;
            readonly size: import("../button/interface").Size;
            readonly disabled: boolean;
            readonly htmlType: "button" | "submit" | "reset";
            readonly loading: boolean;
            readonly long: boolean;
            readonly throttle: number;
            readonly iconPlacement: "left" | "right";
        }>;
        __isFragment?: never;
        __isTeleport?: never;
        __isSuspense?: never;
    } & import("vue").ComponentOptionsBase<Readonly<ExtractPropTypes<{
        readonly disabled: {
            readonly type: PropType<boolean>;
            readonly default: () => boolean;
        };
        readonly htmlType: {
            readonly type: PropType<"button" | "submit" | "reset">;
            readonly default: "button";
        };
        readonly size: {
            readonly type: PropType<import("../button/interface").Size>;
            readonly default: "middle";
        };
        readonly loading: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly long: {
            readonly type: BooleanConstructor;
            readonly default: false;
        };
        readonly throttle: {
            readonly type: NumberConstructor;
            readonly default: 300;
        };
        readonly type: {
            readonly type: PropType<import("../button/interface").Type>;
            readonly default: "default";
        };
        readonly iconPlacement: {
            readonly type: PropType<"left" | "right">;
            readonly default: "left";
        };
    }>> & Readonly<{
        onClick?: (...args: any[]) => any;
    }>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", {
        readonly type: import("../button/interface").Type;
        readonly size: import("../button/interface").Size;
        readonly disabled: boolean;
        readonly htmlType: "button" | "submit" | "reset";
        readonly loading: boolean;
        readonly long: boolean;
        readonly throttle: number;
        readonly iconPlacement: "left" | "right";
    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[]>;
}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
export default _default;