import { type ExtractPropTypes, type PropType, type Ref } from 'vue';
import { type SELECTED_STATUS } from './const';
import type { DayItem } from './interface';
import type { Picker } from './pickerHandler';
declare const calendarProps: {
    readonly rangePosition: {
        readonly type: PropType<"left" | "right">;
    };
    readonly modelValue: PropType<number[]>;
    readonly activeDate: NumberConstructor;
    readonly selectedStatus: PropType<SELECTED_STATUS>;
    readonly disabledDate: {
        readonly type: PropType<(date: Date, format: string, flagDate?: Date) => boolean | undefined>;
    };
    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 CalendarProps = Partial<ExtractPropTypes<typeof calendarProps>>;
declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
    readonly rangePosition: {
        readonly type: PropType<"left" | "right">;
    };
    readonly modelValue: PropType<number[]>;
    readonly activeDate: NumberConstructor;
    readonly selectedStatus: PropType<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<Picker>;
    currentDate: {
        year: number;
        month: number;
        day: number;
        hour: number;
        minute: number;
        second: number;
    };
    MONTHS_NAMES: string[];
    inputDate: 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: DayItem) => {
        [x: string]: boolean;
        'is-start': boolean;
        'is-end': boolean;
    };
    monthToNext: () => void;
    monthToPre: () => void;
    isNotDisabled: (e: MouseEvent) => boolean;
    selectedDay: (info: DayItem) => void;
    currentTime: 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<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: Ref<boolean, boolean>;
        handlePasswordVisible: () => void;
        showPwdSwitchIcon: import("vue").ComputedRef<boolean>;
        handleInput: (event: string | Event) => void;
        handleCompositionStart: () => void;
        handleCompositionEnd: (event: Event) => void;
        inputRefEl: Ref<HTMLElement, HTMLElement>;
        focus: () => void;
        blur: () => void;
        focused: 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: 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: 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: Ref<any, any>;
            inputPlaceholder: import("vue").ComputedRef<string>;
            t: import("../config-provider/const").TranslatorType;
            attrs: {
                [x: string]: unknown;
            };
            timeSelectRef: 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: Ref<any, any>;
                    prefixCls: string;
                    rootRefEl: 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: Ref<HTMLElement, HTMLElement>;
                        containerRef: Ref<HTMLElement, HTMLElement>;
                        contentRef: 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: Ref<number, number>;
                        thumbMoveY: Ref<number, number>;
                        ratioX: Ref<number, number>;
                        ratioY: Ref<number, number>;
                        sizeHeight: Ref<string, string>;
                        sizeWidth: Ref<string, string>;
                        wrapperClassRef: import("vue").ComputedRef<string[]>;
                        containerClassRef: import("vue").ComputedRef<(string | object)[]>;
                        scrollX: Ref<boolean, boolean>;
                        scrollXRatio: Ref<number, number>;
                        scrollY: Ref<boolean, boolean>;
                        scrollYRatio: 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: Ref<HTMLElement, HTMLElement>;
                            thumbRef: Ref<any, any>;
                            visible: Ref<boolean, boolean>;
                            cursorDown: 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: Ref<boolean, boolean>;
                handlePasswordVisible: () => void;
                showPwdSwitchIcon: import("vue").ComputedRef<boolean>;
                handleInput: (event: string | Event) => void;
                handleCompositionStart: () => void;
                handleCompositionEnd: (event: Event) => void;
                inputRefEl: Ref<HTMLElement, HTMLElement>;
                focus: () => void;
                blur: () => void;
                focused: 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: 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: 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: Ref<any, any>;
            inputPlaceholder: import("vue").ComputedRef<string>;
            t: import("../config-provider/const").TranslatorType;
            attrs: {
                [x: string]: unknown;
            };
            timeSelectRef: 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: 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: 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: Ref<any, any>;
        inputPlaceholder: import("vue").ComputedRef<string>;
        t: import("../config-provider/const").TranslatorType;
        attrs: {
            [x: string]: unknown;
        };
        timeSelectRef: 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: Ref<any, any>;
                prefixCls: string;
                rootRefEl: 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: Ref<HTMLElement, HTMLElement>;
                    containerRef: Ref<HTMLElement, HTMLElement>;
                    contentRef: 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: Ref<number, number>;
                    thumbMoveY: Ref<number, number>;
                    ratioX: Ref<number, number>;
                    ratioY: Ref<number, number>;
                    sizeHeight: Ref<string, string>;
                    sizeWidth: Ref<string, string>;
                    wrapperClassRef: import("vue").ComputedRef<string[]>;
                    containerClassRef: import("vue").ComputedRef<(string | object)[]>;
                    scrollX: Ref<boolean, boolean>;
                    scrollXRatio: Ref<number, number>;
                    scrollY: Ref<boolean, boolean>;
                    scrollYRatio: 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: Ref<HTMLElement, HTMLElement>;
                        thumbRef: Ref<any, any>;
                        visible: Ref<boolean, boolean>;
                        cursorDown: 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: Ref<boolean, boolean>;
            handlePasswordVisible: () => void;
            showPwdSwitchIcon: import("vue").ComputedRef<boolean>;
            handleInput: (event: string | Event) => void;
            handleCompositionStart: () => void;
            handleCompositionEnd: (event: Event) => void;
            inputRefEl: Ref<HTMLElement, HTMLElement>;
            focus: () => void;
            blur: () => void;
            focused: 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>;
export default _default;