import { AllowedDates, CalendarType, CommonDates, Lang, RangePickerSelectInput, RangePickerSelectOutput } 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;
    };
    modelValue: {
        type: null;
        required: false;
        default: () => null;
    };
}, {
    RANGE_PICKER_INPUT_TYPE_TO_COMPONENT: {
        shamsi: import("vue").DefineComponent<{
            lang: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            type: {
                type: null;
                required: true;
            };
            modelValue: {
                type: null;
                required: true;
            };
        }, {
            props: {
                lang: Lang;
                commonDates: CommonDates;
                allowedDates: AllowedDates;
                type: CalendarType;
                modelValue: RangePickerSelectInput;
            };
            emit: (e: "update:modelValue", rangeInfo: RangePickerSelectOutput) => void;
            selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerInputLanguageStrings>;
            emitSelectedRange: (rangeInfo: RangePickerSelectOutput) => void;
            convertRangeItemToString: (date: Date) => string;
            selectedRangeString: import("vue").ComputedRef<string>;
            RangePickerInput: import("vue").DefineComponent<{
                lang: {
                    type: null;
                    required: true;
                };
                commonDates: {
                    type: null;
                    required: true;
                };
                allowedDates: {
                    type: null;
                    required: true;
                };
                type: {
                    type: null;
                    required: true;
                };
                selectedRangeString: {
                    type: StringConstructor;
                    required: true;
                };
                modelValue: {
                    type: null;
                    required: true;
                };
                strings: {
                    type: null;
                    required: true;
                };
            }, {
                emit: (e: "update:modelValue", rangePickerSelectOutput: RangePickerSelectOutput) => void;
                props: {
                    lang: Lang;
                    commonDates: CommonDates;
                    allowedDates: AllowedDates;
                    type: CalendarType;
                    selectedRangeString: string;
                    modelValue: RangePickerSelectInput;
                    strings: import("./shared/types").RangePickerInputLanguageStrings;
                };
                lang: import("vue").Ref<Lang>;
                setSelectedRangeAndEmit: (rangeInfo: RangePickerSelectOutput) => void;
                direction: import("vue").Ref<import('../shared/types').Direction>;
                RangePicker: 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: import('../shared/types').UnifyDateItem;
                                toDate: import('../shared/types').UnifyDateItem;
                                setFromDate: import('../shared/types').SetUnifyDateItem;
                                setToDate: import('../shared/types').SetUnifyDateItem;
                                commonDates: CommonDates;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            localCommonDates: import("vue").ComputedRef<{
                                from: import('../shared/types').TupleDate;
                                to: import('../shared/types').TupleDate;
                                label: string;
                            }[]>;
                            allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                };
                                refProps: import("vue").ToRefs<{
                                    date: import("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                }>;
                                currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    direction: import("vue").Ref<import('../shared/types').Direction>;
                                    currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                    isAnimationInverted: import("vue").Ref<boolean>;
                                    incrementStartingMonth: () => void;
                                    decreaseStartingMonth: () => void;
                                    isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        direction: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                        strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                    setToDate: import('../shared/types').SetDateItem;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentDate: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                                toDate: import('../shared/types').UnifyDateItem;
                                setFromDate: import('../shared/types').SetUnifyDateItem;
                                setToDate: import('../shared/types').SetUnifyDateItem;
                                commonDates: CommonDates;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            localCommonDates: import("vue").ComputedRef<{
                                from: import('../shared/types').TupleDate;
                                to: import('../shared/types').TupleDate;
                                label: string;
                            }[]>;
                            allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                };
                                refProps: import("vue").ToRefs<{
                                    date: import("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                }>;
                                currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    direction: import("vue").Ref<import('../shared/types').Direction>;
                                    currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                    isAnimationInverted: import("vue").Ref<boolean>;
                                    incrementStartingMonth: () => void;
                                    decreaseStartingMonth: () => void;
                                    isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        direction: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                        strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                    setToDate: import('../shared/types').SetDateItem;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentDate: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/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: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                    toDate: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                    setFromDate: import('../shared/types').SetUnifyDateItem;
                    setToDate: import('../shared/types').SetUnifyDateItem;
                    selectRange: import("../RangePicker/shared/types").SelectRange;
                    lang: import("vue").Ref<Lang>;
                    allowedDates: import("vue").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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import("vue").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;
                }>;
                PickerInput: import("vue").DefineComponent<{
                    text: {
                        type: StringConstructor;
                        required: true;
                    };
                    value: {
                        type: StringConstructor;
                        required: true;
                    };
                    direction: {
                        type: null;
                        required: true;
                    };
                }, {
                    props: {
                        text: string;
                        value: string;
                        direction: import('../shared/types').Direction;
                    };
                    inputRef: import("vue").Ref<HTMLElement | null>;
                    isOpen: import("vue").Ref<boolean>;
                    domRect: import("vue").Ref<{
                        height: number;
                        width: number;
                        x: number;
                        y: number;
                        readonly bottom: number;
                        readonly left: number;
                        readonly right: number;
                        readonly top: number;
                        toJSON: () => any;
                    } | null>;
                    toggleIsOpen: () => void;
                    handleBodySelect: () => void;
                    PickerInputBox: import("vue").DefineComponent<{
                        value: {
                            type: StringConstructor;
                            required: true;
                        };
                        text: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        props: {
                            value: string;
                            text: string;
                        };
                        emit: (e: "click") => void;
                        ArrowDownIcon: any;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        value?: unknown;
                        text?: unknown;
                    } & {
                        text: string;
                        value: string;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                    PickerInputPopOver: import("vue").DefineComponent<{
                        domRect: {
                            type: null;
                            required: true;
                        };
                        direction: {
                            type: null;
                            required: true;
                        };
                    }, {
                        props: {
                            domRect: DOMRect | null;
                            direction: import('../shared/types').Direction;
                        };
                        el: import("vue").Ref<HTMLElement | null>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        domRect?: unknown;
                        direction?: unknown;
                    } & {
                        direction: any;
                        domRect: any;
                    } & {}>, {}>;
                    PickerInputTransition: any;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    text?: unknown;
                    value?: unknown;
                    direction?: unknown;
                } & {
                    text: string;
                    value: string;
                    direction: any;
                } & {}>, {}>;
            }, 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;
                selectedRangeString?: unknown;
                modelValue?: unknown;
                strings?: unknown;
            } & {
                type: any;
                lang: any;
                commonDates: any;
                allowedDates: any;
                modelValue: any;
                strings: any;
                selectedRangeString: string;
            } & {}> & {
                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
            }, {}>;
        }, 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;
            modelValue?: unknown;
        } & {
            type: any;
            lang: any;
            commonDates: any;
            allowedDates: any;
            modelValue: any;
        } & {}> & {
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        }, {}>;
        miladi: import("vue").DefineComponent<{
            lang: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            modelValue: {
                type: null;
                required: true;
            };
            type: {
                type: null;
                required: true;
            };
        }, {
            props: {
                lang: Lang;
                commonDates: CommonDates;
                allowedDates: AllowedDates;
                modelValue: RangePickerSelectInput;
                type: CalendarType;
            };
            emit: (e: "update:modelValue", rangeInfo: RangePickerSelectOutput) => void;
            selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerInputLanguageStrings>;
            emitSelectedRange: (rangeInfo: RangePickerSelectOutput) => void;
            convertRangeItemToString: (date: Date) => string;
            selectedRangeString: import("vue").ComputedRef<string>;
            RangePickerInput: import("vue").DefineComponent<{
                lang: {
                    type: null;
                    required: true;
                };
                commonDates: {
                    type: null;
                    required: true;
                };
                allowedDates: {
                    type: null;
                    required: true;
                };
                type: {
                    type: null;
                    required: true;
                };
                selectedRangeString: {
                    type: StringConstructor;
                    required: true;
                };
                modelValue: {
                    type: null;
                    required: true;
                };
                strings: {
                    type: null;
                    required: true;
                };
            }, {
                emit: (e: "update:modelValue", rangePickerSelectOutput: RangePickerSelectOutput) => void;
                props: {
                    lang: Lang;
                    commonDates: CommonDates;
                    allowedDates: AllowedDates;
                    type: CalendarType;
                    selectedRangeString: string;
                    modelValue: RangePickerSelectInput;
                    strings: import("./shared/types").RangePickerInputLanguageStrings;
                };
                lang: import("vue").Ref<Lang>;
                setSelectedRangeAndEmit: (rangeInfo: RangePickerSelectOutput) => void;
                direction: import("vue").Ref<import('../shared/types').Direction>;
                RangePicker: 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: import('../shared/types').UnifyDateItem;
                                toDate: import('../shared/types').UnifyDateItem;
                                setFromDate: import('../shared/types').SetUnifyDateItem;
                                setToDate: import('../shared/types').SetUnifyDateItem;
                                commonDates: CommonDates;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            localCommonDates: import("vue").ComputedRef<{
                                from: import('../shared/types').TupleDate;
                                to: import('../shared/types').TupleDate;
                                label: string;
                            }[]>;
                            allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                };
                                refProps: import("vue").ToRefs<{
                                    date: import("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                }>;
                                currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    direction: import("vue").Ref<import('../shared/types').Direction>;
                                    currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                    isAnimationInverted: import("vue").Ref<boolean>;
                                    incrementStartingMonth: () => void;
                                    decreaseStartingMonth: () => void;
                                    isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        direction: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                        strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                    setToDate: import('../shared/types').SetDateItem;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentDate: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                                toDate: import('../shared/types').UnifyDateItem;
                                setFromDate: import('../shared/types').SetUnifyDateItem;
                                setToDate: import('../shared/types').SetUnifyDateItem;
                                commonDates: CommonDates;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            localCommonDates: import("vue").ComputedRef<{
                                from: import('../shared/types').TupleDate;
                                to: import('../shared/types').TupleDate;
                                label: string;
                            }[]>;
                            allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                };
                                refProps: import("vue").ToRefs<{
                                    date: import("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                    fromDate: import('../shared/types').DateItem;
                                    toDate: import('../shared/types').DateItem;
                                    currentDate: import('../shared/types').TupleDate;
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    direction: import('../shared/types').Direction;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setToDate: import('../shared/types').SetDateItem;
                                    allowedDates: AllowedDates;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                }>;
                                currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                    commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                    strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    direction: import("vue").Ref<import('../shared/types').Direction>;
                                    currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                    isAnimationInverted: import("vue").Ref<boolean>;
                                    incrementStartingMonth: () => void;
                                    decreaseStartingMonth: () => void;
                                    isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        direction: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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: import("vue").Ref<boolean>;
                                                disabled: import("vue").Ref<boolean>;
                                                plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                        strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                        fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                        toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    selectRange: import("../RangePicker/shared/types").SelectRange;
                                    setToDate: import('../shared/types').SetDateItem;
                                    setFromDate: import('../shared/types').SetDateItem;
                                    setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                    currentDate: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/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: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                    toDate: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                    setFromDate: import('../shared/types').SetUnifyDateItem;
                    setToDate: import('../shared/types').SetUnifyDateItem;
                    selectRange: import("../RangePicker/shared/types").SelectRange;
                    lang: import("vue").Ref<Lang>;
                    allowedDates: import("vue").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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import("vue").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;
                }>;
                PickerInput: import("vue").DefineComponent<{
                    text: {
                        type: StringConstructor;
                        required: true;
                    };
                    value: {
                        type: StringConstructor;
                        required: true;
                    };
                    direction: {
                        type: null;
                        required: true;
                    };
                }, {
                    props: {
                        text: string;
                        value: string;
                        direction: import('../shared/types').Direction;
                    };
                    inputRef: import("vue").Ref<HTMLElement | null>;
                    isOpen: import("vue").Ref<boolean>;
                    domRect: import("vue").Ref<{
                        height: number;
                        width: number;
                        x: number;
                        y: number;
                        readonly bottom: number;
                        readonly left: number;
                        readonly right: number;
                        readonly top: number;
                        toJSON: () => any;
                    } | null>;
                    toggleIsOpen: () => void;
                    handleBodySelect: () => void;
                    PickerInputBox: import("vue").DefineComponent<{
                        value: {
                            type: StringConstructor;
                            required: true;
                        };
                        text: {
                            type: StringConstructor;
                            required: true;
                        };
                    }, {
                        props: {
                            value: string;
                            text: string;
                        };
                        emit: (e: "click") => void;
                        ArrowDownIcon: any;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        value?: unknown;
                        text?: unknown;
                    } & {
                        text: string;
                        value: string;
                    } & {}> & {
                        onClick?: ((...args: any[]) => any) | undefined;
                    }, {}>;
                    PickerInputPopOver: import("vue").DefineComponent<{
                        domRect: {
                            type: null;
                            required: true;
                        };
                        direction: {
                            type: null;
                            required: true;
                        };
                    }, {
                        props: {
                            domRect: DOMRect | null;
                            direction: import('../shared/types').Direction;
                        };
                        el: import("vue").Ref<HTMLElement | null>;
                    }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                        domRect?: unknown;
                        direction?: unknown;
                    } & {
                        direction: any;
                        domRect: any;
                    } & {}>, {}>;
                    PickerInputTransition: any;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    text?: unknown;
                    value?: unknown;
                    direction?: unknown;
                } & {
                    text: string;
                    value: string;
                    direction: any;
                } & {}>, {}>;
            }, 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;
                selectedRangeString?: unknown;
                modelValue?: unknown;
                strings?: unknown;
            } & {
                type: any;
                lang: any;
                commonDates: any;
                allowedDates: any;
                modelValue: any;
                strings: any;
                selectedRangeString: string;
            } & {}> & {
                "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
            }, {}>;
        }, 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;
            modelValue?: unknown;
            type?: unknown;
        } & {
            type: any;
            lang: any;
            commonDates: any;
            allowedDates: any;
            modelValue: any;
        } & {}> & {
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        }, {}>;
    };
    props: {
        lang: Lang;
        commonDates: CommonDates;
        allowedDates: AllowedDates;
        type: CalendarType;
        modelValue: RangePickerSelectInput;
    };
    emit: (e: 'update:modelValue', rangeInfo: RangePickerSelectOutput) => void;
    CalendarComponent: import("vue").ComputedRef<import("vue").DefineComponent<{
        lang: {
            type: null;
            required: true;
        };
        commonDates: {
            type: null;
            required: true;
        };
        allowedDates: {
            type: null;
            required: true;
        };
        type: {
            type: null;
            required: true;
        };
        modelValue: {
            type: null;
            required: true;
        };
    }, {
        props: {
            lang: Lang;
            commonDates: CommonDates;
            allowedDates: AllowedDates;
            type: CalendarType;
            modelValue: RangePickerSelectInput;
        };
        emit: (e: "update:modelValue", rangeInfo: RangePickerSelectOutput) => void;
        selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerInputLanguageStrings>;
        emitSelectedRange: (rangeInfo: RangePickerSelectOutput) => void;
        convertRangeItemToString: (date: Date) => string;
        selectedRangeString: import("vue").ComputedRef<string>;
        RangePickerInput: import("vue").DefineComponent<{
            lang: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            type: {
                type: null;
                required: true;
            };
            selectedRangeString: {
                type: StringConstructor;
                required: true;
            };
            modelValue: {
                type: null;
                required: true;
            };
            strings: {
                type: null;
                required: true;
            };
        }, {
            emit: (e: "update:modelValue", rangePickerSelectOutput: RangePickerSelectOutput) => void;
            props: {
                lang: Lang;
                commonDates: CommonDates;
                allowedDates: AllowedDates;
                type: CalendarType;
                selectedRangeString: string;
                modelValue: RangePickerSelectInput;
                strings: import("./shared/types").RangePickerInputLanguageStrings;
            };
            lang: import("vue").Ref<Lang>;
            setSelectedRangeAndEmit: (rangeInfo: RangePickerSelectOutput) => void;
            direction: import("vue").Ref<import('../shared/types').Direction>;
            RangePicker: 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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                toDate: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                setFromDate: import('../shared/types').SetUnifyDateItem;
                setToDate: import('../shared/types').SetUnifyDateItem;
                selectRange: import("../RangePicker/shared/types").SelectRange;
                lang: import("vue").Ref<Lang>;
                allowedDates: import("vue").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: import('../shared/types').UnifyDateItem;
                        toDate: import('../shared/types').UnifyDateItem;
                        setFromDate: import('../shared/types').SetUnifyDateItem;
                        setToDate: import('../shared/types').SetUnifyDateItem;
                        commonDates: CommonDates;
                        allowedDates: AllowedDates;
                        selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                    localCommonDates: import("vue").ComputedRef<{
                        from: import('../shared/types').TupleDate;
                        to: import('../shared/types').TupleDate;
                        label: string;
                    }[]>;
                    allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        };
                        refProps: import("vue").ToRefs<{
                            date: import("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        }>;
                        currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                        setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                        RangePickerCommonDates: import("vue").DefineComponent<{}, {
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            direction: import("vue").Ref<import('../shared/types').Direction>;
                            currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                            isAnimationInverted: import("vue").Ref<boolean>;
                            incrementStartingMonth: () => void;
                            decreaseStartingMonth: () => void;
                            isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                direction: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                            toDate: import("vue").Ref<import('../shared/types').DateItem>;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                            setToDate: import('../shared/types').SetDateItem;
                            setFromDate: import('../shared/types').SetDateItem;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentDate: import("vue").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: import("vue").Ref<boolean>;
                                disabled: import("vue").Ref<boolean>;
                                plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                        toDate: import('../shared/types').UnifyDateItem;
                        setFromDate: import('../shared/types').SetUnifyDateItem;
                        setToDate: import('../shared/types').SetUnifyDateItem;
                        commonDates: CommonDates;
                        allowedDates: AllowedDates;
                        selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                    localCommonDates: import("vue").ComputedRef<{
                        from: import('../shared/types').TupleDate;
                        to: import('../shared/types').TupleDate;
                        label: string;
                    }[]>;
                    allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        };
                        refProps: import("vue").ToRefs<{
                            date: import("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        }>;
                        currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                        setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                        RangePickerCommonDates: import("vue").DefineComponent<{}, {
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            direction: import("vue").Ref<import('../shared/types').Direction>;
                            currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                            isAnimationInverted: import("vue").Ref<boolean>;
                            incrementStartingMonth: () => void;
                            decreaseStartingMonth: () => void;
                            isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                direction: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                            toDate: import("vue").Ref<import('../shared/types').DateItem>;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                            setToDate: import('../shared/types').SetDateItem;
                            setFromDate: import('../shared/types').SetDateItem;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentDate: import("vue").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: import("vue").Ref<boolean>;
                                disabled: import("vue").Ref<boolean>;
                                plain: import("vue").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("../RangePicker/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: import("vue").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;
            }>;
            PickerInput: import("vue").DefineComponent<{
                text: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: StringConstructor;
                    required: true;
                };
                direction: {
                    type: null;
                    required: true;
                };
            }, {
                props: {
                    text: string;
                    value: string;
                    direction: import('../shared/types').Direction;
                };
                inputRef: import("vue").Ref<HTMLElement | null>;
                isOpen: import("vue").Ref<boolean>;
                domRect: import("vue").Ref<{
                    height: number;
                    width: number;
                    x: number;
                    y: number;
                    readonly bottom: number;
                    readonly left: number;
                    readonly right: number;
                    readonly top: number;
                    toJSON: () => any;
                } | null>;
                toggleIsOpen: () => void;
                handleBodySelect: () => void;
                PickerInputBox: import("vue").DefineComponent<{
                    value: {
                        type: StringConstructor;
                        required: true;
                    };
                    text: {
                        type: StringConstructor;
                        required: true;
                    };
                }, {
                    props: {
                        value: string;
                        text: string;
                    };
                    emit: (e: "click") => void;
                    ArrowDownIcon: any;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    value?: unknown;
                    text?: unknown;
                } & {
                    text: string;
                    value: string;
                } & {}> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                }, {}>;
                PickerInputPopOver: import("vue").DefineComponent<{
                    domRect: {
                        type: null;
                        required: true;
                    };
                    direction: {
                        type: null;
                        required: true;
                    };
                }, {
                    props: {
                        domRect: DOMRect | null;
                        direction: import('../shared/types').Direction;
                    };
                    el: import("vue").Ref<HTMLElement | null>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    domRect?: unknown;
                    direction?: unknown;
                } & {
                    direction: any;
                    domRect: any;
                } & {}>, {}>;
                PickerInputTransition: any;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                text?: unknown;
                value?: unknown;
                direction?: unknown;
            } & {
                text: string;
                value: string;
                direction: any;
            } & {}>, {}>;
        }, 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;
            selectedRangeString?: unknown;
            modelValue?: unknown;
            strings?: unknown;
        } & {
            type: any;
            lang: any;
            commonDates: any;
            allowedDates: any;
            modelValue: any;
            strings: any;
            selectedRangeString: string;
        } & {}> & {
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        }, {}>;
    }, 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;
        modelValue?: unknown;
    } & {
        type: any;
        lang: any;
        commonDates: any;
        allowedDates: any;
        modelValue: any;
    } & {}> & {
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }, {}> | import("vue").DefineComponent<{
        lang: {
            type: null;
            required: true;
        };
        commonDates: {
            type: null;
            required: true;
        };
        allowedDates: {
            type: null;
            required: true;
        };
        modelValue: {
            type: null;
            required: true;
        };
        type: {
            type: null;
            required: true;
        };
    }, {
        props: {
            lang: Lang;
            commonDates: CommonDates;
            allowedDates: AllowedDates;
            modelValue: RangePickerSelectInput;
            type: CalendarType;
        };
        emit: (e: "update:modelValue", rangeInfo: RangePickerSelectOutput) => void;
        selectedLanguageStrings: import("vue").ComputedRef<import("./shared/types").RangePickerInputLanguageStrings>;
        emitSelectedRange: (rangeInfo: RangePickerSelectOutput) => void;
        convertRangeItemToString: (date: Date) => string;
        selectedRangeString: import("vue").ComputedRef<string>;
        RangePickerInput: import("vue").DefineComponent<{
            lang: {
                type: null;
                required: true;
            };
            commonDates: {
                type: null;
                required: true;
            };
            allowedDates: {
                type: null;
                required: true;
            };
            type: {
                type: null;
                required: true;
            };
            selectedRangeString: {
                type: StringConstructor;
                required: true;
            };
            modelValue: {
                type: null;
                required: true;
            };
            strings: {
                type: null;
                required: true;
            };
        }, {
            emit: (e: "update:modelValue", rangePickerSelectOutput: RangePickerSelectOutput) => void;
            props: {
                lang: Lang;
                commonDates: CommonDates;
                allowedDates: AllowedDates;
                type: CalendarType;
                selectedRangeString: string;
                modelValue: RangePickerSelectInput;
                strings: import("./shared/types").RangePickerInputLanguageStrings;
            };
            lang: import("vue").Ref<Lang>;
            setSelectedRangeAndEmit: (rangeInfo: RangePickerSelectOutput) => void;
            direction: import("vue").Ref<import('../shared/types').Direction>;
            RangePicker: 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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                            toDate: import('../shared/types').UnifyDateItem;
                            setFromDate: import('../shared/types').SetUnifyDateItem;
                            setToDate: import('../shared/types').SetUnifyDateItem;
                            commonDates: CommonDates;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                        localCommonDates: import("vue").ComputedRef<{
                            from: import('../shared/types').TupleDate;
                            to: import('../shared/types').TupleDate;
                            label: string;
                        }[]>;
                        allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            };
                            refProps: import("vue").ToRefs<{
                                date: import("../RangePicker/shared/types").RangePickerDate;
                                strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                                fromDate: import('../shared/types').DateItem;
                                toDate: import('../shared/types').DateItem;
                                currentDate: import('../shared/types').TupleDate;
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                direction: import('../shared/types').Direction;
                                setFromDate: import('../shared/types').SetDateItem;
                                setToDate: import('../shared/types').SetDateItem;
                                allowedDates: AllowedDates;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                            }>;
                            currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            RangePickerCommonDates: import("vue").DefineComponent<{}, {
                                commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                                strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                direction: import("vue").Ref<import('../shared/types').Direction>;
                                currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                                isAnimationInverted: import("vue").Ref<boolean>;
                                incrementStartingMonth: () => void;
                                decreaseStartingMonth: () => void;
                                isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    direction: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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: import("vue").Ref<boolean>;
                                            disabled: import("vue").Ref<boolean>;
                                            plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                    strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                    fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                    toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").Ref<import('../shared/types').DateItem>;
                                selectRange: import("../RangePicker/shared/types").SelectRange;
                                setToDate: import('../shared/types').SetDateItem;
                                setFromDate: import('../shared/types').SetDateItem;
                                setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                                currentDate: import("vue").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: import("vue").Ref<boolean>;
                                    disabled: import("vue").Ref<boolean>;
                                    plain: import("vue").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("../RangePicker/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: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                toDate: import("vue").Ref<import('../shared/types').UnifyDateItem>;
                setFromDate: import('../shared/types').SetUnifyDateItem;
                setToDate: import('../shared/types').SetUnifyDateItem;
                selectRange: import("../RangePicker/shared/types").SelectRange;
                lang: import("vue").Ref<Lang>;
                allowedDates: import("vue").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: import('../shared/types').UnifyDateItem;
                        toDate: import('../shared/types').UnifyDateItem;
                        setFromDate: import('../shared/types').SetUnifyDateItem;
                        setToDate: import('../shared/types').SetUnifyDateItem;
                        commonDates: CommonDates;
                        allowedDates: AllowedDates;
                        selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                    localCommonDates: import("vue").ComputedRef<{
                        from: import('../shared/types').TupleDate;
                        to: import('../shared/types').TupleDate;
                        label: string;
                    }[]>;
                    allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        };
                        refProps: import("vue").ToRefs<{
                            date: import("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        }>;
                        currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                        setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                        RangePickerCommonDates: import("vue").DefineComponent<{}, {
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            direction: import("vue").Ref<import('../shared/types').Direction>;
                            currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                            isAnimationInverted: import("vue").Ref<boolean>;
                            incrementStartingMonth: () => void;
                            decreaseStartingMonth: () => void;
                            isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                direction: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                            toDate: import("vue").Ref<import('../shared/types').DateItem>;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                            setToDate: import('../shared/types').SetDateItem;
                            setFromDate: import('../shared/types').SetDateItem;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentDate: import("vue").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: import("vue").Ref<boolean>;
                                disabled: import("vue").Ref<boolean>;
                                plain: import("vue").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("../RangePicker/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: import('../shared/types').UnifyDateItem;
                        toDate: import('../shared/types').UnifyDateItem;
                        setFromDate: import('../shared/types').SetUnifyDateItem;
                        setToDate: import('../shared/types').SetUnifyDateItem;
                        commonDates: CommonDates;
                        allowedDates: AllowedDates;
                        selectRange: import("../RangePicker/shared/types").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("../RangePicker/shared/types").RangePickerLanguageStrings>;
                    localCommonDates: import("vue").ComputedRef<{
                        from: import('../shared/types').TupleDate;
                        to: import('../shared/types').TupleDate;
                        label: string;
                    }[]>;
                    allowedDates: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        };
                        refProps: import("vue").ToRefs<{
                            date: import("../RangePicker/shared/types").RangePickerDate;
                            strings: import("../RangePicker/shared/types").RangePickerLanguageStrings;
                            fromDate: import('../shared/types').DateItem;
                            toDate: import('../shared/types').DateItem;
                            currentDate: import('../shared/types').TupleDate;
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            direction: import('../shared/types').Direction;
                            setFromDate: import('../shared/types').SetDateItem;
                            setToDate: import('../shared/types').SetDateItem;
                            allowedDates: AllowedDates;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                        }>;
                        currentFirstSliderDate: import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>;
                        setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                        RangePickerCommonDates: import("vue").DefineComponent<{}, {
                            commonDates: import("../RangePicker/shared/types").LocalCommonDates;
                            strings: import("vue").Ref<import("../RangePicker/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: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                            direction: import("vue").Ref<import('../shared/types').Direction>;
                            currentFirstSliderDate: Readonly<import("vue").Ref<import("../RangePicker/shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentSecondDate: import("vue").ComputedRef<import('../shared/types').DateInfo>;
                            isAnimationInverted: import("vue").Ref<boolean>;
                            incrementStartingMonth: () => void;
                            decreaseStartingMonth: () => void;
                            isMobile: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                direction: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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: import("vue").Ref<boolean>;
                                        disabled: import("vue").Ref<boolean>;
                                        plain: import("vue").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("../RangePicker/shared/types").RangePickerDate;
                                strings: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                                fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                                toDate: import("vue").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: import("vue").Ref<import("../RangePicker/shared/types").RangePickerLanguageStrings>;
                            fromDate: import("vue").Ref<import('../shared/types').DateItem>;
                            toDate: import("vue").Ref<import('../shared/types').DateItem>;
                            selectRange: import("../RangePicker/shared/types").SelectRange;
                            setToDate: import('../shared/types').SetDateItem;
                            setFromDate: import('../shared/types').SetDateItem;
                            setCurrentFirstSliderDate: import("../RangePicker/shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
                            currentDate: import("vue").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: import("vue").Ref<boolean>;
                                disabled: import("vue").Ref<boolean>;
                                plain: import("vue").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("../RangePicker/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: import("vue").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;
            }>;
            PickerInput: import("vue").DefineComponent<{
                text: {
                    type: StringConstructor;
                    required: true;
                };
                value: {
                    type: StringConstructor;
                    required: true;
                };
                direction: {
                    type: null;
                    required: true;
                };
            }, {
                props: {
                    text: string;
                    value: string;
                    direction: import('../shared/types').Direction;
                };
                inputRef: import("vue").Ref<HTMLElement | null>;
                isOpen: import("vue").Ref<boolean>;
                domRect: import("vue").Ref<{
                    height: number;
                    width: number;
                    x: number;
                    y: number;
                    readonly bottom: number;
                    readonly left: number;
                    readonly right: number;
                    readonly top: number;
                    toJSON: () => any;
                } | null>;
                toggleIsOpen: () => void;
                handleBodySelect: () => void;
                PickerInputBox: import("vue").DefineComponent<{
                    value: {
                        type: StringConstructor;
                        required: true;
                    };
                    text: {
                        type: StringConstructor;
                        required: true;
                    };
                }, {
                    props: {
                        value: string;
                        text: string;
                    };
                    emit: (e: "click") => void;
                    ArrowDownIcon: any;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "click"[], "click", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    value?: unknown;
                    text?: unknown;
                } & {
                    text: string;
                    value: string;
                } & {}> & {
                    onClick?: ((...args: any[]) => any) | undefined;
                }, {}>;
                PickerInputPopOver: import("vue").DefineComponent<{
                    domRect: {
                        type: null;
                        required: true;
                    };
                    direction: {
                        type: null;
                        required: true;
                    };
                }, {
                    props: {
                        domRect: DOMRect | null;
                        direction: import('../shared/types').Direction;
                    };
                    el: import("vue").Ref<HTMLElement | null>;
                }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                    domRect?: unknown;
                    direction?: unknown;
                } & {
                    direction: any;
                    domRect: any;
                } & {}>, {}>;
                PickerInputTransition: any;
            }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
                text?: unknown;
                value?: unknown;
                direction?: unknown;
            } & {
                text: string;
                value: string;
                direction: any;
            } & {}>, {}>;
        }, 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;
            selectedRangeString?: unknown;
            modelValue?: unknown;
            strings?: unknown;
        } & {
            type: any;
            lang: any;
            commonDates: any;
            allowedDates: any;
            modelValue: any;
            strings: any;
            selectedRangeString: string;
        } & {}> & {
            "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
        }, {}>;
    }, 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;
        modelValue?: unknown;
        type?: unknown;
    } & {
        type: any;
        lang: any;
        commonDates: any;
        allowedDates: any;
        modelValue: any;
    } & {}> & {
        "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
    }, {}>>;
    lang: import("vue").Ref<Lang>;
    direction: import("vue").Ref<import('../shared/types').Direction>;
    emitSelectedRange: (rangeInfo: RangePickerSelectOutput) => void;
}, 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;
    modelValue?: unknown;
} & {
    type: any;
    lang: any;
    commonDates: any;
    allowedDates: any;
    modelValue: any;
} & {}> & {
    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
}, {
    type: any;
    lang: any;
    commonDates: any;
    allowedDates: any;
    modelValue: any;
}>;
export default _sfc_main;