import { Ref } from 'vue';
import { AllowedDates, CalendarType, CommonDates, Lang, RangePickerSelectOutput, SetUnifyDateItem, UnifyDateItem, RangePickerSelectInput } from '../shared/types';
import { SelectRange } from './shared/types';
declare const _sfc_main: import("vue").DefineComponent<{
    lang: {
        type: null;
        required: false;
        default: string;
    };
    commonDates: {
        type: null;
        required: false;
        default: () => never[];
    };
    allowedDates: {
        type: null;
        required: false;
        default: () => null;
    };
    type: {
        type: null;
        required: false;
        default: string;
    };
    rangePickerClass: {
        type: null;
        required: false;
        default: string;
    };
    modelValue: {
        type: null;
        required: false;
        default: () => null;
    };
}, {
    props: {
        lang: Lang;
        commonDates: CommonDates;
        allowedDates: AllowedDates;
        type: CalendarType;
        rangePickerClass: any;
        modelValue: RangePickerSelectInput;
    };
    emit: (e: 'update:modelValue', rangePickerSelectOutput: RangePickerSelectOutput) => void;
    RANGE_PICKER_TYPE_TO_COMPONENT: {
        shamsi: import("vue").DefineComponent<{
            lang: {
                type: null;
                required: true;
            };
            direction: {
                type: null;
                required: true;
            };
            fromDate: {
                type: null;
                required: true;
            };
            toDate: {
                type: null;
                required: true;
            };
            setFromDate: {
                type: null;
                required: true;
            };
            setToDate: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            selectRange: {
                type: null;
                required: true;
            };
        }, {
            props: {
                lang: Lang;
                direction: import('../shared/types').Direction;
                fromDate: UnifyDateItem;
                toDate: UnifyDateItem;
                setFromDate: SetUnifyDateItem;
                setToDate: SetUnifyDateItem;
                commonDates: CommonDates;
                allowedDates: AllowedDates;
                selectRange: SelectRange;
            };
            fromShamsiDate: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
            toShamsiDate: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
            currentDate: import('../shared/types').TupleDate;
            setLocalFromDate: import('../shared/types').SetDateItem;
            setLocalToDate: import('../shared/types').SetDateItem;
            selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerLanguageStrings>;
            localCommonDates: import("vue").ComputedRef<{
                from: import('../shared/types').TupleDate;
                to: import('../shared/types').TupleDate;
                label: string;
            }[]>;
            allowedDates: Ref<AllowedDates>;
            RangePicker: import("vue").DefineComponent<{
                date: {
                    type: null;
                    required: true;
                };
                strings: {
                    type: null;
                    required: true;
                };
                fromDate: {
                    type: null;
                    required: true;
                };
                toDate: {
                    type: null;
                    required: true;
                };
                currentDate: {
                    type: null;
                    required: true;
                };
                commonDates: {
                    type: null;
                    required: true;
                };
                direction: {
                    type: null;
                    required: true;
                };
                setFromDate: {
                    type: null;
                    required: true;
                };
                setToDate: {
                    type: null;
                    required: true;
                };
                allowedDates: {
                    type: null;
                    required: true;
                };
                selectRange: {
                    type: null;
                    required: true;
                };
            }, {
                props: {
                    date: import("./shared/types").RangePickerDate;
                    strings: import("./shared/types").RangePickerLanguageStrings;
                    fromDate: import('../shared/types').DateItem;
                    toDate: import('../shared/types').DateItem;
                    currentDate: import('../shared/types').TupleDate;
                    commonDates: import("./shared/types").LocalCommonDates;
                    direction: import('../shared/types').Direction;
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    allowedDates: AllowedDates;
                    selectRange: SelectRange;
                };
                refProps: import("vue").ToRefs<{
                    date: import("./shared/types").RangePickerDate;
                    strings: import("./shared/types").RangePickerLanguageStrings;
                    fromDate: import('../shared/types').DateItem;
                    toDate: import('../shared/types').DateItem;
                    currentDate: import('../shared/types').TupleDate;
                    commonDates: import("./shared/types").LocalCommonDates;
                    direction: import('../shared/types').Direction;
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    allowedDates: AllowedDates;
                    selectRange: SelectRange;
                }>;
                currentFirstSliderDate: Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                RangePickerCommonDates: import("vue").DefineComponent<{}, {
                    commonDates: import("./shared/types").LocalCommonDates;
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    RangePickerCommonDatesItem: import("vue").DefineComponent<{
                        from: {
                            type: null;
                            required: true;
                        };
                        to: {
                            type: null;
                            required: true;
                        };
                        label: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        setFromDate: import('../shared/types').SetDateItem;
                        setToDate: import('../shared/types').SetDateItem;
                        fromDate: Ref<import('../shared/types').DateItem>;
                        toDate: Ref<import('../shared/types').DateItem>;
                        props: {
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        };
                        setRange: () => void;
                        isActive: import("vue").ComputedRef<boolean>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        from?: unknown;
                        to?: unknown;
                        label?: unknown;
                    } & {
                        label: string;
                        from: any;
                        to: any;
                    } & {}>, {}>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
                RangePickerSlider: import("vue").DefineComponent<{}, {
                    date: import("./shared/types").RangePickerDate;
                    direction: Ref<import('../shared/types').Direction>;
                    currentFirstSliderDate: Readonly<Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                    setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                    currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                    isAnimationInverted: Ref<boolean>;
                    incrementStartingMonth: () => void;
                    decreaseStartingMonth: () => void;
                    isMobile: Ref<boolean>;
                    mql: MediaQueryList;
                    detectMobile: (mqEvent: MediaQueryListEvent) => undefined;
                    SlideAnimation: import("vue").DefineComponent<{
                        isInverted: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        direction: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        props: {
                            isInverted: boolean;
                            direction: "ltr" | "rtl";
                        };
                        animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        isInverted?: unknown;
                        direction?: unknown;
                    } & {
                        direction: string;
                        isInverted: boolean;
                    } & {}>, {
                        isInverted: boolean;
                    }>;
                    RangePickerSliderControllers: import("vue").DefineComponent<{
                        firstMonth: {
                            type: NumberConstructor;
                            required: true;
                        };
                        firstYear: {
                            type: NumberConstructor;
                            required: true;
                        };
                        secondMonth: {
                            type: NumberConstructor;
                            required: true;
                        };
                        secondYear: {
                            type: NumberConstructor;
                            required: true;
                        };
                        isAnimationInverted: {
                            type: BooleanConstructor;
                            required: true;
                        };
                    }, {
                        strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                        direction: Ref<import('../shared/types').Direction>;
                        props: {
                            firstMonth: number;
                            firstYear: number;
                            secondMonth: number;
                            secondYear: number;
                            isAnimationInverted: boolean;
                        };
                        emit: {
                            (e: "next"): void;
                            (e: "prev"): void;
                        };
                        next: () => void;
                        prev: () => void;
                        SlideAnimation: import("vue").DefineComponent<{
                            isInverted: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            direction: {
                                type: StringConstructor;
                                required: true;
                            };
                        }, {
                            props: {
                                isInverted: boolean;
                                direction: "ltr" | "rtl";
                            };
                            animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            isInverted?: unknown;
                            direction?: unknown;
                        } & {
                            direction: string;
                            isInverted: boolean;
                        } & {}>, {
                            isInverted: boolean;
                        }>;
                        StartingArrowButton: import("vue").DefineComponent<{
                            direction: {
                                type: null;
                                required: true;
                            };
                        }, {
                            props: {
                                direction: import('../shared/types').Direction;
                            };
                            emit: (e: "click") => void;
                            ArrowStart: import("vue").ComputedRef<any>;
                            Button: import("vue").DefineComponent<{
                                icon: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                plain: {
                                    type: BooleanConstructor;
                                    required: false;
                                };
                            }, {
                                props: {
                                    icon: boolean;
                                    disabled: boolean;
                                    plain?: boolean | undefined;
                                };
                                emit: (e: "click") => void;
                                icon: Ref<boolean>;
                                disabled: Ref<boolean>;
                                plain: Ref<boolean | undefined>;
                                checkAndEmitClick: () => void;
                            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                                icon?: unknown;
                                disabled?: unknown;
                                plain?: unknown;
                            } & {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            } & {}> & {
                                onClick?: ((...args: any[]) => any) | undefined;
                            }, {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            }>;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            direction?: unknown;
                        } & {
                            direction: any;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {}>;
                        EndingArrowButton: import("vue").DefineComponent<{
                            direction: {
                                type: null;
                                required: true;
                            };
                        }, {
                            props: {
                                direction: import('../shared/types').Direction;
                            };
                            emit: (e: "click") => void;
                            ArrowEnd: import("vue").ComputedRef<any>;
                            Button: import("vue").DefineComponent<{
                                icon: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                plain: {
                                    type: BooleanConstructor;
                                    required: false;
                                };
                            }, {
                                props: {
                                    icon: boolean;
                                    disabled: boolean;
                                    plain?: boolean | undefined;
                                };
                                emit: (e: "click") => void;
                                icon: Ref<boolean>;
                                disabled: Ref<boolean>;
                                plain: Ref<boolean | undefined>;
                                checkAndEmitClick: () => void;
                            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                                icon?: unknown;
                                disabled?: unknown;
                                plain?: unknown;
                            } & {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            } & {}> & {
                                onClick?: ((...args: any[]) => any) | undefined;
                            }, {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            }>;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            direction?: unknown;
                        } & {
                            direction: any;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {}>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("next" | "prev")[], "next" | "prev", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        firstMonth?: unknown;
                        firstYear?: unknown;
                        secondMonth?: unknown;
                        secondYear?: unknown;
                        isAnimationInverted?: unknown;
                    } & {
                        firstMonth: number;
                        firstYear: number;
                        secondMonth: number;
                        secondYear: number;
                        isAnimationInverted: boolean;
                    } & {}> & {
                        onNext?: ((...args: any[]) => any) | undefined;
                        onPrev?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                    RangePickerSliderGridContainer: import("vue").DefineComponent<{
                        currentYear: {
                            type: NumberConstructor;
                            required: true;
                        };
                        currentMonth: {
                            type: NumberConstructor;
                            required: true;
                        };
                    }, {
                        date: import("./shared/types").RangePickerDate;
                        strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                        fromDate: Ref<import('../shared/types').DateItem>;
                        toDate: Ref<import('../shared/types').DateItem>;
                        setFromDate: import('../shared/types').SetDateItem;
                        setToDate: import('../shared/types').SetDateItem;
                        props: {
                            currentYear: number;
                            currentMonth: number;
                        };
                        selectDate: (day: number) => void;
                        firstDayOfMonth: import("vue").ComputedRef<number>;
                        lastDayOfMonth: import("vue").ComputedRef<number>;
                        monthDays: import("vue").ComputedRef<number>;
                        RangePickerSliderGrid: import("vue").DefineComponent<unknown, object, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<unknown>, {}>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        currentYear?: unknown;
                        currentMonth?: unknown;
                    } & {
                        currentMonth: number;
                        currentYear: number;
                    } & {}>, {}>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
                RangePickerFooter: import("vue").DefineComponent<{}, {
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    fromDate: Ref<import('../shared/types').DateItem>;
                    toDate: Ref<import('../shared/types').DateItem>;
                    selectRange: SelectRange;
                    setToDate: import('../shared/types').SetDateItem;
                    setFromDate: import('../shared/types').SetDateItem;
                    setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                    currentDate: Ref<import('../shared/types').TupleDate>;
                    isRangeSelected: import("vue").ComputedRef<boolean>;
                    datePreviewString: import("vue").ComputedRef<string>;
                    removeRange: () => void;
                    resetSlider: () => void;
                    Button: import("vue").DefineComponent<{
                        icon: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        plain: {
                            type: BooleanConstructor;
                            required: false;
                        };
                    }, {
                        props: {
                            icon: boolean;
                            disabled: boolean;
                            plain?: boolean | undefined;
                        };
                        emit: (e: "click") => void;
                        icon: Ref<boolean>;
                        disabled: Ref<boolean>;
                        plain: Ref<boolean | undefined>;
                        checkAndEmitClick: () => void;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        icon?: unknown;
                        disabled?: unknown;
                        plain?: unknown;
                    } & {
                        disabled: boolean;
                        icon: boolean;
                        plain: boolean;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {
                        disabled: boolean;
                        icon: boolean;
                        plain: boolean;
                    }>;
                    VerticalSlideAnimation: any;
                    RangePickerFooterClose: any;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                date?: unknown;
                strings?: unknown;
                fromDate?: unknown;
                toDate?: unknown;
                currentDate?: unknown;
                commonDates?: unknown;
                direction?: unknown;
                setFromDate?: unknown;
                setToDate?: unknown;
                allowedDates?: unknown;
                selectRange?: unknown;
            } & {
                date: any;
                commonDates: any;
                allowedDates: any;
                strings: any;
                fromDate: any;
                toDate: any;
                currentDate: any;
                direction: any;
                setFromDate: any;
                setToDate: any;
                selectRange: any;
            } & {}>, {}>;
            date: import("./shared/types").RangePickerDate;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
            lang?: unknown;
            direction?: unknown;
            fromDate?: unknown;
            toDate?: unknown;
            setFromDate?: unknown;
            setToDate?: unknown;
            commonDates?: unknown;
            allowedDates?: unknown;
            selectRange?: unknown;
        } & {
            lang: any;
            commonDates: any;
            allowedDates: any;
            fromDate: any;
            toDate: any;
            direction: any;
            setFromDate: any;
            setToDate: any;
            selectRange: any;
        } & {}>, {}>;
        miladi: import("vue").DefineComponent<{
            lang: {
                type: null;
                required: true;
            };
            direction: {
                type: null;
                required: true;
            };
            fromDate: {
                type: null;
                required: true;
            };
            toDate: {
                type: null;
                required: true;
            };
            setFromDate: {
                type: null;
                required: true;
            };
            setToDate: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            selectRange: {
                type: null;
                required: true;
            };
        }, {
            props: {
                lang: Lang;
                direction: import('../shared/types').Direction;
                fromDate: UnifyDateItem;
                toDate: UnifyDateItem;
                setFromDate: SetUnifyDateItem;
                setToDate: SetUnifyDateItem;
                commonDates: CommonDates;
                allowedDates: AllowedDates;
                selectRange: SelectRange;
            };
            fromDateTuple: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
            toDateTuple: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
            currentDate: import('../shared/types').TupleDate;
            setLocalFromDate: import('../shared/types').SetDateItem;
            setLocalToDate: import('../shared/types').SetDateItem;
            selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerLanguageStrings>;
            localCommonDates: import("vue").ComputedRef<{
                from: import('../shared/types').TupleDate;
                to: import('../shared/types').TupleDate;
                label: string;
            }[]>;
            allowedDates: Ref<AllowedDates>;
            RangePicker: import("vue").DefineComponent<{
                date: {
                    type: null;
                    required: true;
                };
                strings: {
                    type: null;
                    required: true;
                };
                fromDate: {
                    type: null;
                    required: true;
                };
                toDate: {
                    type: null;
                    required: true;
                };
                currentDate: {
                    type: null;
                    required: true;
                };
                commonDates: {
                    type: null;
                    required: true;
                };
                direction: {
                    type: null;
                    required: true;
                };
                setFromDate: {
                    type: null;
                    required: true;
                };
                setToDate: {
                    type: null;
                    required: true;
                };
                allowedDates: {
                    type: null;
                    required: true;
                };
                selectRange: {
                    type: null;
                    required: true;
                };
            }, {
                props: {
                    date: import("./shared/types").RangePickerDate;
                    strings: import("./shared/types").RangePickerLanguageStrings;
                    fromDate: import('../shared/types').DateItem;
                    toDate: import('../shared/types').DateItem;
                    currentDate: import('../shared/types').TupleDate;
                    commonDates: import("./shared/types").LocalCommonDates;
                    direction: import('../shared/types').Direction;
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    allowedDates: AllowedDates;
                    selectRange: SelectRange;
                };
                refProps: import("vue").ToRefs<{
                    date: import("./shared/types").RangePickerDate;
                    strings: import("./shared/types").RangePickerLanguageStrings;
                    fromDate: import('../shared/types').DateItem;
                    toDate: import('../shared/types').DateItem;
                    currentDate: import('../shared/types').TupleDate;
                    commonDates: import("./shared/types").LocalCommonDates;
                    direction: import('../shared/types').Direction;
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    allowedDates: AllowedDates;
                    selectRange: SelectRange;
                }>;
                currentFirstSliderDate: Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                RangePickerCommonDates: import("vue").DefineComponent<{}, {
                    commonDates: import("./shared/types").LocalCommonDates;
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    RangePickerCommonDatesItem: import("vue").DefineComponent<{
                        from: {
                            type: null;
                            required: true;
                        };
                        to: {
                            type: null;
                            required: true;
                        };
                        label: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        setFromDate: import('../shared/types').SetDateItem;
                        setToDate: import('../shared/types').SetDateItem;
                        fromDate: Ref<import('../shared/types').DateItem>;
                        toDate: Ref<import('../shared/types').DateItem>;
                        props: {
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        };
                        setRange: () => void;
                        isActive: import("vue").ComputedRef<boolean>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        from?: unknown;
                        to?: unknown;
                        label?: unknown;
                    } & {
                        label: string;
                        from: any;
                        to: any;
                    } & {}>, {}>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
                RangePickerSlider: import("vue").DefineComponent<{}, {
                    date: import("./shared/types").RangePickerDate;
                    direction: Ref<import('../shared/types').Direction>;
                    currentFirstSliderDate: Readonly<Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                    setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                    currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                    isAnimationInverted: Ref<boolean>;
                    incrementStartingMonth: () => void;
                    decreaseStartingMonth: () => void;
                    isMobile: Ref<boolean>;
                    mql: MediaQueryList;
                    detectMobile: (mqEvent: MediaQueryListEvent) => undefined;
                    SlideAnimation: import("vue").DefineComponent<{
                        isInverted: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        direction: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        props: {
                            isInverted: boolean;
                            direction: "ltr" | "rtl";
                        };
                        animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        isInverted?: unknown;
                        direction?: unknown;
                    } & {
                        direction: string;
                        isInverted: boolean;
                    } & {}>, {
                        isInverted: boolean;
                    }>;
                    RangePickerSliderControllers: import("vue").DefineComponent<{
                        firstMonth: {
                            type: NumberConstructor;
                            required: true;
                        };
                        firstYear: {
                            type: NumberConstructor;
                            required: true;
                        };
                        secondMonth: {
                            type: NumberConstructor;
                            required: true;
                        };
                        secondYear: {
                            type: NumberConstructor;
                            required: true;
                        };
                        isAnimationInverted: {
                            type: BooleanConstructor;
                            required: true;
                        };
                    }, {
                        strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                        direction: Ref<import('../shared/types').Direction>;
                        props: {
                            firstMonth: number;
                            firstYear: number;
                            secondMonth: number;
                            secondYear: number;
                            isAnimationInverted: boolean;
                        };
                        emit: {
                            (e: "next"): void;
                            (e: "prev"): void;
                        };
                        next: () => void;
                        prev: () => void;
                        SlideAnimation: import("vue").DefineComponent<{
                            isInverted: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            direction: {
                                type: StringConstructor;
                                required: true;
                            };
                        }, {
                            props: {
                                isInverted: boolean;
                                direction: "ltr" | "rtl";
                            };
                            animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            isInverted?: unknown;
                            direction?: unknown;
                        } & {
                            direction: string;
                            isInverted: boolean;
                        } & {}>, {
                            isInverted: boolean;
                        }>;
                        StartingArrowButton: import("vue").DefineComponent<{
                            direction: {
                                type: null;
                                required: true;
                            };
                        }, {
                            props: {
                                direction: import('../shared/types').Direction;
                            };
                            emit: (e: "click") => void;
                            ArrowStart: import("vue").ComputedRef<any>;
                            Button: import("vue").DefineComponent<{
                                icon: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                plain: {
                                    type: BooleanConstructor;
                                    required: false;
                                };
                            }, {
                                props: {
                                    icon: boolean;
                                    disabled: boolean;
                                    plain?: boolean | undefined;
                                };
                                emit: (e: "click") => void;
                                icon: Ref<boolean>;
                                disabled: Ref<boolean>;
                                plain: Ref<boolean | undefined>;
                                checkAndEmitClick: () => void;
                            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                                icon?: unknown;
                                disabled?: unknown;
                                plain?: unknown;
                            } & {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            } & {}> & {
                                onClick?: ((...args: any[]) => any) | undefined;
                            }, {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            }>;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            direction?: unknown;
                        } & {
                            direction: any;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {}>;
                        EndingArrowButton: import("vue").DefineComponent<{
                            direction: {
                                type: null;
                                required: true;
                            };
                        }, {
                            props: {
                                direction: import('../shared/types').Direction;
                            };
                            emit: (e: "click") => void;
                            ArrowEnd: import("vue").ComputedRef<any>;
                            Button: import("vue").DefineComponent<{
                                icon: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                disabled: {
                                    type: BooleanConstructor;
                                    required: false;
                                    default: boolean;
                                };
                                plain: {
                                    type: BooleanConstructor;
                                    required: false;
                                };
                            }, {
                                props: {
                                    icon: boolean;
                                    disabled: boolean;
                                    plain?: boolean | undefined;
                                };
                                emit: (e: "click") => void;
                                icon: Ref<boolean>;
                                disabled: Ref<boolean>;
                                plain: Ref<boolean | undefined>;
                                checkAndEmitClick: () => void;
                            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                                icon?: unknown;
                                disabled?: unknown;
                                plain?: unknown;
                            } & {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            } & {}> & {
                                onClick?: ((...args: any[]) => any) | undefined;
                            }, {
                                disabled: boolean;
                                icon: boolean;
                                plain: boolean;
                            }>;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            direction?: unknown;
                        } & {
                            direction: any;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {}>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("next" | "prev")[], "next" | "prev", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        firstMonth?: unknown;
                        firstYear?: unknown;
                        secondMonth?: unknown;
                        secondYear?: unknown;
                        isAnimationInverted?: unknown;
                    } & {
                        firstMonth: number;
                        firstYear: number;
                        secondMonth: number;
                        secondYear: number;
                        isAnimationInverted: boolean;
                    } & {}> & {
                        onNext?: ((...args: any[]) => any) | undefined;
                        onPrev?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                    RangePickerSliderGridContainer: import("vue").DefineComponent<{
                        currentYear: {
                            type: NumberConstructor;
                            required: true;
                        };
                        currentMonth: {
                            type: NumberConstructor;
                            required: true;
                        };
                    }, {
                        date: import("./shared/types").RangePickerDate;
                        strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                        fromDate: Ref<import('../shared/types').DateItem>;
                        toDate: Ref<import('../shared/types').DateItem>;
                        setFromDate: import('../shared/types').SetDateItem;
                        setToDate: import('../shared/types').SetDateItem;
                        props: {
                            currentYear: number;
                            currentMonth: number;
                        };
                        selectDate: (day: number) => void;
                        firstDayOfMonth: import("vue").ComputedRef<number>;
                        lastDayOfMonth: import("vue").ComputedRef<number>;
                        monthDays: import("vue").ComputedRef<number>;
                        RangePickerSliderGrid: import("vue").DefineComponent<unknown, object, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<unknown>, {}>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        currentYear?: unknown;
                        currentMonth?: unknown;
                    } & {
                        currentMonth: number;
                        currentYear: number;
                    } & {}>, {}>;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
                RangePickerFooter: import("vue").DefineComponent<{}, {
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    fromDate: Ref<import('../shared/types').DateItem>;
                    toDate: Ref<import('../shared/types').DateItem>;
                    selectRange: SelectRange;
                    setToDate: import('../shared/types').SetDateItem;
                    setFromDate: import('../shared/types').SetDateItem;
                    setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                    currentDate: Ref<import('../shared/types').TupleDate>;
                    isRangeSelected: import("vue").ComputedRef<boolean>;
                    datePreviewString: import("vue").ComputedRef<string>;
                    removeRange: () => void;
                    resetSlider: () => void;
                    Button: import("vue").DefineComponent<{
                        icon: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        disabled: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        plain: {
                            type: BooleanConstructor;
                            required: false;
                        };
                    }, {
                        props: {
                            icon: boolean;
                            disabled: boolean;
                            plain?: boolean | undefined;
                        };
                        emit: (e: "click") => void;
                        icon: Ref<boolean>;
                        disabled: Ref<boolean>;
                        plain: Ref<boolean | undefined>;
                        checkAndEmitClick: () => void;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        icon?: unknown;
                        disabled?: unknown;
                        plain?: unknown;
                    } & {
                        disabled: boolean;
                        icon: boolean;
                        plain: boolean;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {
                        disabled: boolean;
                        icon: boolean;
                        plain: boolean;
                    }>;
                    VerticalSlideAnimation: any;
                    RangePickerFooterClose: any;
                }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                date?: unknown;
                strings?: unknown;
                fromDate?: unknown;
                toDate?: unknown;
                currentDate?: unknown;
                commonDates?: unknown;
                direction?: unknown;
                setFromDate?: unknown;
                setToDate?: unknown;
                allowedDates?: unknown;
                selectRange?: unknown;
            } & {
                date: any;
                commonDates: any;
                allowedDates: any;
                strings: any;
                fromDate: any;
                toDate: any;
                currentDate: any;
                direction: any;
                setFromDate: any;
                setToDate: any;
                selectRange: any;
            } & {}>, {}>;
            date: import("./shared/types").RangePickerDate;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
            lang?: unknown;
            direction?: unknown;
            fromDate?: unknown;
            toDate?: unknown;
            setFromDate?: unknown;
            setToDate?: unknown;
            commonDates?: unknown;
            allowedDates?: unknown;
            selectRange?: unknown;
        } & {
            lang: any;
            commonDates: any;
            allowedDates: any;
            fromDate: any;
            toDate: any;
            direction: any;
            setFromDate: any;
            setToDate: any;
            selectRange: any;
        } & {}>, {}>;
    };
    fromDate: Ref<UnifyDateItem>;
    toDate: Ref<UnifyDateItem>;
    setFromDate: SetUnifyDateItem;
    setToDate: SetUnifyDateItem;
    selectRange: SelectRange;
    lang: Ref<Lang>;
    allowedDates: Ref<AllowedDates>;
    CalendarComponent: import("vue").ComputedRef<import("vue").DefineComponent<{
        lang: {
            type: null;
            required: true;
        };
        direction: {
            type: null;
            required: true;
        };
        fromDate: {
            type: null;
            required: true;
        };
        toDate: {
            type: null;
            required: true;
        };
        setFromDate: {
            type: null;
            required: true;
        };
        setToDate: {
            type: null;
            required: true;
        };
        commonDates: {
            type: null;
            required: true;
        };
        allowedDates: {
            type: null;
            required: true;
        };
        selectRange: {
            type: null;
            required: true;
        };
    }, {
        props: {
            lang: Lang;
            direction: import('../shared/types').Direction;
            fromDate: UnifyDateItem;
            toDate: UnifyDateItem;
            setFromDate: SetUnifyDateItem;
            setToDate: SetUnifyDateItem;
            commonDates: CommonDates;
            allowedDates: AllowedDates;
            selectRange: SelectRange;
        };
        fromShamsiDate: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
        toShamsiDate: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
        currentDate: import('../shared/types').TupleDate;
        setLocalFromDate: import('../shared/types').SetDateItem;
        setLocalToDate: import('../shared/types').SetDateItem;
        selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerLanguageStrings>;
        localCommonDates: import("vue").ComputedRef<{
            from: import('../shared/types').TupleDate;
            to: import('../shared/types').TupleDate;
            label: string;
        }[]>;
        allowedDates: Ref<AllowedDates>;
        RangePicker: import("vue").DefineComponent<{
            date: {
                type: null;
                required: true;
            };
            strings: {
                type: null;
                required: true;
            };
            fromDate: {
                type: null;
                required: true;
            };
            toDate: {
                type: null;
                required: true;
            };
            currentDate: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            direction: {
                type: null;
                required: true;
            };
            setFromDate: {
                type: null;
                required: true;
            };
            setToDate: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            selectRange: {
                type: null;
                required: true;
            };
        }, {
            props: {
                date: import("./shared/types").RangePickerDate;
                strings: import("./shared/types").RangePickerLanguageStrings;
                fromDate: import('../shared/types').DateItem;
                toDate: import('../shared/types').DateItem;
                currentDate: import('../shared/types').TupleDate;
                commonDates: import("./shared/types").LocalCommonDates;
                direction: import('../shared/types').Direction;
                setFromDate: import('../shared/types').SetDateItem;
                setToDate: import('../shared/types').SetDateItem;
                allowedDates: AllowedDates;
                selectRange: SelectRange;
            };
            refProps: import("vue").ToRefs<{
                date: import("./shared/types").RangePickerDate;
                strings: import("./shared/types").RangePickerLanguageStrings;
                fromDate: import('../shared/types').DateItem;
                toDate: import('../shared/types').DateItem;
                currentDate: import('../shared/types').TupleDate;
                commonDates: import("./shared/types").LocalCommonDates;
                direction: import('../shared/types').Direction;
                setFromDate: import('../shared/types').SetDateItem;
                setToDate: import('../shared/types').SetDateItem;
                allowedDates: AllowedDates;
                selectRange: SelectRange;
            }>;
            currentFirstSliderDate: Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>;
            setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                commonDates: import("./shared/types").LocalCommonDates;
                strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                RangePickerCommonDatesItem: import("vue").DefineComponent<{
                    from: {
                        type: null;
                        required: true;
                    };
                    to: {
                        type: null;
                        required: true;
                    };
                    label: {
                        type: StringConstructor;
                        required: true;
                    };
                }, {
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    fromDate: Ref<import('../shared/types').DateItem>;
                    toDate: Ref<import('../shared/types').DateItem>;
                    props: {
                        from: import('../shared/types').TupleDate;
                        to: import('../shared/types').TupleDate;
                        label: string;
                    };
                    setRange: () => void;
                    isActive: import("vue").ComputedRef<boolean>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    from?: unknown;
                    to?: unknown;
                    label?: unknown;
                } & {
                    label: string;
                    from: any;
                    to: any;
                } & {}>, {}>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
            RangePickerSlider: import("vue").DefineComponent<{}, {
                date: import("./shared/types").RangePickerDate;
                direction: Ref<import('../shared/types').Direction>;
                currentFirstSliderDate: Readonly<Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                isAnimationInverted: Ref<boolean>;
                incrementStartingMonth: () => void;
                decreaseStartingMonth: () => void;
                isMobile: Ref<boolean>;
                mql: MediaQueryList;
                detectMobile: (mqEvent: MediaQueryListEvent) => undefined;
                SlideAnimation: import("vue").DefineComponent<{
                    isInverted: {
                        type: BooleanConstructor;
                        required: false;
                        default: boolean;
                    };
                    direction: {
                        type: StringConstructor;
                        required: true;
                    };
                }, {
                    props: {
                        isInverted: boolean;
                        direction: "ltr" | "rtl";
                    };
                    animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    isInverted?: unknown;
                    direction?: unknown;
                } & {
                    direction: string;
                    isInverted: boolean;
                } & {}>, {
                    isInverted: boolean;
                }>;
                RangePickerSliderControllers: import("vue").DefineComponent<{
                    firstMonth: {
                        type: NumberConstructor;
                        required: true;
                    };
                    firstYear: {
                        type: NumberConstructor;
                        required: true;
                    };
                    secondMonth: {
                        type: NumberConstructor;
                        required: true;
                    };
                    secondYear: {
                        type: NumberConstructor;
                        required: true;
                    };
                    isAnimationInverted: {
                        type: BooleanConstructor;
                        required: true;
                    };
                }, {
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    direction: Ref<import('../shared/types').Direction>;
                    props: {
                        firstMonth: number;
                        firstYear: number;
                        secondMonth: number;
                        secondYear: number;
                        isAnimationInverted: boolean;
                    };
                    emit: {
                        (e: "next"): void;
                        (e: "prev"): void;
                    };
                    next: () => void;
                    prev: () => void;
                    SlideAnimation: import("vue").DefineComponent<{
                        isInverted: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        direction: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        props: {
                            isInverted: boolean;
                            direction: "ltr" | "rtl";
                        };
                        animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        isInverted?: unknown;
                        direction?: unknown;
                    } & {
                        direction: string;
                        isInverted: boolean;
                    } & {}>, {
                        isInverted: boolean;
                    }>;
                    StartingArrowButton: import("vue").DefineComponent<{
                        direction: {
                            type: null;
                            required: true;
                        };
                    }, {
                        props: {
                            direction: import('../shared/types').Direction;
                        };
                        emit: (e: "click") => void;
                        ArrowStart: import("vue").ComputedRef<any>;
                        Button: import("vue").DefineComponent<{
                            icon: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            plain: {
                                type: BooleanConstructor;
                                required: false;
                            };
                        }, {
                            props: {
                                icon: boolean;
                                disabled: boolean;
                                plain?: boolean | undefined;
                            };
                            emit: (e: "click") => void;
                            icon: Ref<boolean>;
                            disabled: Ref<boolean>;
                            plain: Ref<boolean | undefined>;
                            checkAndEmitClick: () => void;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            icon?: unknown;
                            disabled?: unknown;
                            plain?: unknown;
                        } & {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        }>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        direction?: unknown;
                    } & {
                        direction: any;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                    EndingArrowButton: import("vue").DefineComponent<{
                        direction: {
                            type: null;
                            required: true;
                        };
                    }, {
                        props: {
                            direction: import('../shared/types').Direction;
                        };
                        emit: (e: "click") => void;
                        ArrowEnd: import("vue").ComputedRef<any>;
                        Button: import("vue").DefineComponent<{
                            icon: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            plain: {
                                type: BooleanConstructor;
                                required: false;
                            };
                        }, {
                            props: {
                                icon: boolean;
                                disabled: boolean;
                                plain?: boolean | undefined;
                            };
                            emit: (e: "click") => void;
                            icon: Ref<boolean>;
                            disabled: Ref<boolean>;
                            plain: Ref<boolean | undefined>;
                            checkAndEmitClick: () => void;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            icon?: unknown;
                            disabled?: unknown;
                            plain?: unknown;
                        } & {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        }>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        direction?: unknown;
                    } & {
                        direction: any;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("next" | "prev")[], "next" | "prev", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    firstMonth?: unknown;
                    firstYear?: unknown;
                    secondMonth?: unknown;
                    secondYear?: unknown;
                    isAnimationInverted?: unknown;
                } & {
                    firstMonth: number;
                    firstYear: number;
                    secondMonth: number;
                    secondYear: number;
                    isAnimationInverted: boolean;
                } & {}> & {
                    onNext?: ((...args: any[]) => any) | undefined;
                    onPrev?: ((...args: any[]) => any) | undefined;
                }, {}>;
                RangePickerSliderGridContainer: import("vue").DefineComponent<{
                    currentYear: {
                        type: NumberConstructor;
                        required: true;
                    };
                    currentMonth: {
                        type: NumberConstructor;
                        required: true;
                    };
                }, {
                    date: import("./shared/types").RangePickerDate;
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    fromDate: Ref<import('../shared/types').DateItem>;
                    toDate: Ref<import('../shared/types').DateItem>;
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    props: {
                        currentYear: number;
                        currentMonth: number;
                    };
                    selectDate: (day: number) => void;
                    firstDayOfMonth: import("vue").ComputedRef<number>;
                    lastDayOfMonth: import("vue").ComputedRef<number>;
                    monthDays: import("vue").ComputedRef<number>;
                    RangePickerSliderGrid: import("vue").DefineComponent<unknown, object, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<unknown>, {}>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    currentYear?: unknown;
                    currentMonth?: unknown;
                } & {
                    currentMonth: number;
                    currentYear: number;
                } & {}>, {}>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
            RangePickerFooter: import("vue").DefineComponent<{}, {
                strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                fromDate: Ref<import('../shared/types').DateItem>;
                toDate: Ref<import('../shared/types').DateItem>;
                selectRange: SelectRange;
                setToDate: import('../shared/types').SetDateItem;
                setFromDate: import('../shared/types').SetDateItem;
                setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                currentDate: Ref<import('../shared/types').TupleDate>;
                isRangeSelected: import("vue").ComputedRef<boolean>;
                datePreviewString: import("vue").ComputedRef<string>;
                removeRange: () => void;
                resetSlider: () => void;
                Button: import("vue").DefineComponent<{
                    icon: {
                        type: BooleanConstructor;
                        required: false;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        required: false;
                        default: boolean;
                    };
                    plain: {
                        type: BooleanConstructor;
                        required: false;
                    };
                }, {
                    props: {
                        icon: boolean;
                        disabled: boolean;
                        plain?: boolean | undefined;
                    };
                    emit: (e: "click") => void;
                    icon: Ref<boolean>;
                    disabled: Ref<boolean>;
                    plain: Ref<boolean | undefined>;
                    checkAndEmitClick: () => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    icon?: unknown;
                    disabled?: unknown;
                    plain?: unknown;
                } & {
                    disabled: boolean;
                    icon: boolean;
                    plain: boolean;
                } & {}> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                }, {
                    disabled: boolean;
                    icon: boolean;
                    plain: boolean;
                }>;
                VerticalSlideAnimation: any;
                RangePickerFooterClose: any;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
            date?: unknown;
            strings?: unknown;
            fromDate?: unknown;
            toDate?: unknown;
            currentDate?: unknown;
            commonDates?: unknown;
            direction?: unknown;
            setFromDate?: unknown;
            setToDate?: unknown;
            allowedDates?: unknown;
            selectRange?: unknown;
        } & {
            date: any;
            commonDates: any;
            allowedDates: any;
            strings: any;
            fromDate: any;
            toDate: any;
            currentDate: any;
            direction: any;
            setFromDate: any;
            setToDate: any;
            selectRange: any;
        } & {}>, {}>;
        date: import("./shared/types").RangePickerDate;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        lang?: unknown;
        direction?: unknown;
        fromDate?: unknown;
        toDate?: unknown;
        setFromDate?: unknown;
        setToDate?: unknown;
        commonDates?: unknown;
        allowedDates?: unknown;
        selectRange?: unknown;
    } & {
        lang: any;
        commonDates: any;
        allowedDates: any;
        fromDate: any;
        toDate: any;
        direction: any;
        setFromDate: any;
        setToDate: any;
        selectRange: any;
    } & {}>, {}> | import("vue").DefineComponent<{
        lang: {
            type: null;
            required: true;
        };
        direction: {
            type: null;
            required: true;
        };
        fromDate: {
            type: null;
            required: true;
        };
        toDate: {
            type: null;
            required: true;
        };
        setFromDate: {
            type: null;
            required: true;
        };
        setToDate: {
            type: null;
            required: true;
        };
        commonDates: {
            type: null;
            required: true;
        };
        allowedDates: {
            type: null;
            required: true;
        };
        selectRange: {
            type: null;
            required: true;
        };
    }, {
        props: {
            lang: Lang;
            direction: import('../shared/types').Direction;
            fromDate: UnifyDateItem;
            toDate: UnifyDateItem;
            setFromDate: SetUnifyDateItem;
            setToDate: SetUnifyDateItem;
            commonDates: CommonDates;
            allowedDates: AllowedDates;
            selectRange: SelectRange;
        };
        fromDateTuple: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
        toDateTuple: import("vue").ComputedRef<import('../shared/types').TupleDate | null>;
        currentDate: import('../shared/types').TupleDate;
        setLocalFromDate: import('../shared/types').SetDateItem;
        setLocalToDate: import('../shared/types').SetDateItem;
        selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerLanguageStrings>;
        localCommonDates: import("vue").ComputedRef<{
            from: import('../shared/types').TupleDate;
            to: import('../shared/types').TupleDate;
            label: string;
        }[]>;
        allowedDates: Ref<AllowedDates>;
        RangePicker: import("vue").DefineComponent<{
            date: {
                type: null;
                required: true;
            };
            strings: {
                type: null;
                required: true;
            };
            fromDate: {
                type: null;
                required: true;
            };
            toDate: {
                type: null;
                required: true;
            };
            currentDate: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            direction: {
                type: null;
                required: true;
            };
            setFromDate: {
                type: null;
                required: true;
            };
            setToDate: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            selectRange: {
                type: null;
                required: true;
            };
        }, {
            props: {
                date: import("./shared/types").RangePickerDate;
                strings: import("./shared/types").RangePickerLanguageStrings;
                fromDate: import('../shared/types').DateItem;
                toDate: import('../shared/types').DateItem;
                currentDate: import('../shared/types').TupleDate;
                commonDates: import("./shared/types").LocalCommonDates;
                direction: import('../shared/types').Direction;
                setFromDate: import('../shared/types').SetDateItem;
                setToDate: import('../shared/types').SetDateItem;
                allowedDates: AllowedDates;
                selectRange: SelectRange;
            };
            refProps: import("vue").ToRefs<{
                date: import("./shared/types").RangePickerDate;
                strings: import("./shared/types").RangePickerLanguageStrings;
                fromDate: import('../shared/types').DateItem;
                toDate: import('../shared/types').DateItem;
                currentDate: import('../shared/types').TupleDate;
                commonDates: import("./shared/types").LocalCommonDates;
                direction: import('../shared/types').Direction;
                setFromDate: import('../shared/types').SetDateItem;
                setToDate: import('../shared/types').SetDateItem;
                allowedDates: AllowedDates;
                selectRange: SelectRange;
            }>;
            currentFirstSliderDate: Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>;
            setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                commonDates: import("./shared/types").LocalCommonDates;
                strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                RangePickerCommonDatesItem: import("vue").DefineComponent<{
                    from: {
                        type: null;
                        required: true;
                    };
                    to: {
                        type: null;
                        required: true;
                    };
                    label: {
                        type: StringConstructor;
                        required: true;
                    };
                }, {
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    fromDate: Ref<import('../shared/types').DateItem>;
                    toDate: Ref<import('../shared/types').DateItem>;
                    props: {
                        from: import('../shared/types').TupleDate;
                        to: import('../shared/types').TupleDate;
                        label: string;
                    };
                    setRange: () => void;
                    isActive: import("vue").ComputedRef<boolean>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    from?: unknown;
                    to?: unknown;
                    label?: unknown;
                } & {
                    label: string;
                    from: any;
                    to: any;
                } & {}>, {}>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
            RangePickerSlider: import("vue").DefineComponent<{}, {
                date: import("./shared/types").RangePickerDate;
                direction: Ref<import('../shared/types').Direction>;
                currentFirstSliderDate: Readonly<Ref<import("./shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                isAnimationInverted: Ref<boolean>;
                incrementStartingMonth: () => void;
                decreaseStartingMonth: () => void;
                isMobile: Ref<boolean>;
                mql: MediaQueryList;
                detectMobile: (mqEvent: MediaQueryListEvent) => undefined;
                SlideAnimation: import("vue").DefineComponent<{
                    isInverted: {
                        type: BooleanConstructor;
                        required: false;
                        default: boolean;
                    };
                    direction: {
                        type: StringConstructor;
                        required: true;
                    };
                }, {
                    props: {
                        isInverted: boolean;
                        direction: "ltr" | "rtl";
                    };
                    animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    isInverted?: unknown;
                    direction?: unknown;
                } & {
                    direction: string;
                    isInverted: boolean;
                } & {}>, {
                    isInverted: boolean;
                }>;
                RangePickerSliderControllers: import("vue").DefineComponent<{
                    firstMonth: {
                        type: NumberConstructor;
                        required: true;
                    };
                    firstYear: {
                        type: NumberConstructor;
                        required: true;
                    };
                    secondMonth: {
                        type: NumberConstructor;
                        required: true;
                    };
                    secondYear: {
                        type: NumberConstructor;
                        required: true;
                    };
                    isAnimationInverted: {
                        type: BooleanConstructor;
                        required: true;
                    };
                }, {
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    direction: Ref<import('../shared/types').Direction>;
                    props: {
                        firstMonth: number;
                        firstYear: number;
                        secondMonth: number;
                        secondYear: number;
                        isAnimationInverted: boolean;
                    };
                    emit: {
                        (e: "next"): void;
                        (e: "prev"): void;
                    };
                    next: () => void;
                    prev: () => void;
                    SlideAnimation: import("vue").DefineComponent<{
                        isInverted: {
                            type: BooleanConstructor;
                            required: false;
                            default: boolean;
                        };
                        direction: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        props: {
                            isInverted: boolean;
                            direction: "ltr" | "rtl";
                        };
                        animationName: import("vue").ComputedRef<"EMSlide-prev" | "EMSlide">;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        isInverted?: unknown;
                        direction?: unknown;
                    } & {
                        direction: string;
                        isInverted: boolean;
                    } & {}>, {
                        isInverted: boolean;
                    }>;
                    StartingArrowButton: import("vue").DefineComponent<{
                        direction: {
                            type: null;
                            required: true;
                        };
                    }, {
                        props: {
                            direction: import('../shared/types').Direction;
                        };
                        emit: (e: "click") => void;
                        ArrowStart: import("vue").ComputedRef<any>;
                        Button: import("vue").DefineComponent<{
                            icon: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            plain: {
                                type: BooleanConstructor;
                                required: false;
                            };
                        }, {
                            props: {
                                icon: boolean;
                                disabled: boolean;
                                plain?: boolean | undefined;
                            };
                            emit: (e: "click") => void;
                            icon: Ref<boolean>;
                            disabled: Ref<boolean>;
                            plain: Ref<boolean | undefined>;
                            checkAndEmitClick: () => void;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            icon?: unknown;
                            disabled?: unknown;
                            plain?: unknown;
                        } & {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        }>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        direction?: unknown;
                    } & {
                        direction: any;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                    EndingArrowButton: import("vue").DefineComponent<{
                        direction: {
                            type: null;
                            required: true;
                        };
                    }, {
                        props: {
                            direction: import('../shared/types').Direction;
                        };
                        emit: (e: "click") => void;
                        ArrowEnd: import("vue").ComputedRef<any>;
                        Button: import("vue").DefineComponent<{
                            icon: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            disabled: {
                                type: BooleanConstructor;
                                required: false;
                                default: boolean;
                            };
                            plain: {
                                type: BooleanConstructor;
                                required: false;
                            };
                        }, {
                            props: {
                                icon: boolean;
                                disabled: boolean;
                                plain?: boolean | undefined;
                            };
                            emit: (e: "click") => void;
                            icon: Ref<boolean>;
                            disabled: Ref<boolean>;
                            plain: Ref<boolean | undefined>;
                            checkAndEmitClick: () => void;
                        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                            icon?: unknown;
                            disabled?: unknown;
                            plain?: unknown;
                        } & {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        } & {}> & {
                            onClick?: ((...args: any[]) => any) | undefined;
                        }, {
                            disabled: boolean;
                            icon: boolean;
                            plain: boolean;
                        }>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        direction?: unknown;
                    } & {
                        direction: any;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("next" | "prev")[], "next" | "prev", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    firstMonth?: unknown;
                    firstYear?: unknown;
                    secondMonth?: unknown;
                    secondYear?: unknown;
                    isAnimationInverted?: unknown;
                } & {
                    firstMonth: number;
                    firstYear: number;
                    secondMonth: number;
                    secondYear: number;
                    isAnimationInverted: boolean;
                } & {}> & {
                    onNext?: ((...args: any[]) => any) | undefined;
                    onPrev?: ((...args: any[]) => any) | undefined;
                }, {}>;
                RangePickerSliderGridContainer: import("vue").DefineComponent<{
                    currentYear: {
                        type: NumberConstructor;
                        required: true;
                    };
                    currentMonth: {
                        type: NumberConstructor;
                        required: true;
                    };
                }, {
                    date: import("./shared/types").RangePickerDate;
                    strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                    fromDate: Ref<import('../shared/types').DateItem>;
                    toDate: Ref<import('../shared/types').DateItem>;
                    setFromDate: import('../shared/types').SetDateItem;
                    setToDate: import('../shared/types').SetDateItem;
                    props: {
                        currentYear: number;
                        currentMonth: number;
                    };
                    selectDate: (day: number) => void;
                    firstDayOfMonth: import("vue").ComputedRef<number>;
                    lastDayOfMonth: import("vue").ComputedRef<number>;
                    monthDays: import("vue").ComputedRef<number>;
                    RangePickerSliderGrid: import("vue").DefineComponent<unknown, object, {}, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<unknown>, {}>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    currentYear?: unknown;
                    currentMonth?: unknown;
                } & {
                    currentMonth: number;
                    currentYear: number;
                } & {}>, {}>;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
            RangePickerFooter: import("vue").DefineComponent<{}, {
                strings: Ref<import("./shared/types").RangePickerLanguageStrings>;
                fromDate: Ref<import('../shared/types').DateItem>;
                toDate: Ref<import('../shared/types').DateItem>;
                selectRange: SelectRange;
                setToDate: import('../shared/types').SetDateItem;
                setFromDate: import('../shared/types').SetDateItem;
                setCurrentFirstSliderDate: import("./shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                currentDate: Ref<import('../shared/types').TupleDate>;
                isRangeSelected: import("vue").ComputedRef<boolean>;
                datePreviewString: import("vue").ComputedRef<string>;
                removeRange: () => void;
                resetSlider: () => void;
                Button: import("vue").DefineComponent<{
                    icon: {
                        type: BooleanConstructor;
                        required: false;
                        default: boolean;
                    };
                    disabled: {
                        type: BooleanConstructor;
                        required: false;
                        default: boolean;
                    };
                    plain: {
                        type: BooleanConstructor;
                        required: false;
                    };
                }, {
                    props: {
                        icon: boolean;
                        disabled: boolean;
                        plain?: boolean | undefined;
                    };
                    emit: (e: "click") => void;
                    icon: Ref<boolean>;
                    disabled: Ref<boolean>;
                    plain: Ref<boolean | undefined>;
                    checkAndEmitClick: () => void;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    icon?: unknown;
                    disabled?: unknown;
                    plain?: unknown;
                } & {
                    disabled: boolean;
                    icon: boolean;
                    plain: boolean;
                } & {}> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                }, {
                    disabled: boolean;
                    icon: boolean;
                    plain: boolean;
                }>;
                VerticalSlideAnimation: any;
                RangePickerFooterClose: any;
            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, import("vue").EmitsOptions, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{} & {} & {}>, {}>;
        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
            date?: unknown;
            strings?: unknown;
            fromDate?: unknown;
            toDate?: unknown;
            currentDate?: unknown;
            commonDates?: unknown;
            direction?: unknown;
            setFromDate?: unknown;
            setToDate?: unknown;
            allowedDates?: unknown;
            selectRange?: unknown;
        } & {
            date: any;
            commonDates: any;
            allowedDates: any;
            strings: any;
            fromDate: any;
            toDate: any;
            currentDate: any;
            direction: any;
            setFromDate: any;
            setToDate: any;
            selectRange: any;
        } & {}>, {}>;
        date: import("./shared/types").RangePickerDate;
    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
        lang?: unknown;
        direction?: unknown;
        fromDate?: unknown;
        toDate?: unknown;
        setFromDate?: unknown;
        setToDate?: unknown;
        commonDates?: unknown;
        allowedDates?: unknown;
        selectRange?: unknown;
    } & {
        lang: any;
        commonDates: any;
        allowedDates: any;
        fromDate: any;
        toDate: any;
        direction: any;
        setFromDate: any;
        setToDate: any;
        selectRange: any;
    } & {}>, {}>>;
    direction: Ref<import('../shared/types').Direction>;
}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
    lang?: unknown;
    commonDates?: unknown;
    allowedDates?: unknown;
    type?: unknown;
    rangePickerClass?: unknown;
    modelValue?: unknown;
} & {
    type: any;
    rangePickerClass: any;
    lang: any;
    commonDates: any;
    allowedDates: any;
    modelValue: any;
} & {}> & {
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
    type: any;
    rangePickerClass: any;
    lang: any;
    commonDates: any;
    allowedDates: any;
    modelValue: any;
}>;
export default _sfc_main;