@cafebazaar/emrooz/dist/lib/RangePicker/RangePickerShamsi/index.vue.d.ts

Emrooz is a multilingual calendar built for Vue3. It also supports both Shamsi (Persian / Jalali) and Gregorian (English) calendars.

import { AllowedDates, CommonDates, Direction, Lang, SetDateItem, SetUnifyDateItem, UnifyDateItem } from '../../shared/types';
import { SelectRange } from '../shared/types';
declare const _sfc_main: 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: Direction;
        fromDate: UnifyDateItem;
        toDate: UnifyDateItem;
        setFromDate: SetUnifyDateItem;
        setToDate: SetUnifyDateItem;
        commonDates: CommonDates;
        allowedDates: AllowedDates;
        selectRange: SelectRange;
    };
    fromShamsiDate: import("vue").ComputedRef<import('../../shared/types').TupleDate | null>;
    toShamsiDate: import("vue").ComputedRef<import('../../shared/types').TupleDate | null>;
    currentDate: import('../../shared/types').TupleDate;
    setLocalFromDate: SetDateItem;
    setLocalToDate: SetDateItem;
    selectedLanguageStrings: import("vue").ComputedRef<import("../shared/types").RangePickerLanguageStrings>;
    localCommonDates: import("vue").ComputedRef<{
        from: import('../../shared/types').TupleDate;
        to: import('../../shared/types').TupleDate;
        label: string;
    }[]>;
    allowedDates: 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("../shared/types").RangePickerDate;
            strings: import("../shared/types").RangePickerLanguageStrings;
            fromDate: import('../../shared/types').DateItem;
            toDate: import('../../shared/types').DateItem;
            currentDate: import('../../shared/types').TupleDate;
            commonDates: import("../shared/types").LocalCommonDates;
            direction: Direction;
            setFromDate: SetDateItem;
            setToDate: SetDateItem;
            allowedDates: AllowedDates;
            selectRange: SelectRange;
        };
        refProps: import("vue").ToRefs<{
            date: import("../shared/types").RangePickerDate;
            strings: import("../shared/types").RangePickerLanguageStrings;
            fromDate: import('../../shared/types').DateItem;
            toDate: import('../../shared/types').DateItem;
            currentDate: import('../../shared/types').TupleDate;
            commonDates: import("../shared/types").LocalCommonDates;
            direction: Direction;
            setFromDate: SetDateItem;
            setToDate: SetDateItem;
            allowedDates: AllowedDates;
            selectRange: SelectRange;
        }>;
        currentFirstSliderDate: import("vue").Ref<import("../shared/RangePicker/shared/types").CurrentFirstSliderDate>;
        setCurrentFirstSliderDate: import("../shared/RangePicker/shared/types").SetCurrentFirstSliderDate;
        RangePickerCommonDates: import("vue").DefineComponent<{}, {
            commonDates: import("../shared/types").LocalCommonDates;
            strings: import("vue").Ref<import("../shared/types").RangePickerLanguageStrings>;
            RangePickerCommonDatesItem: import("vue").DefineComponent<{
                from: {
                    type: null;
                    required: true;
                };
                to: {
                    type: null;
                    required: true;
                };
                label: {
                    type: StringConstructor;
                    required: true;
                };
            }, {
                setFromDate: SetDateItem;
                setToDate: 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("../shared/types").RangePickerDate;
            direction: import("vue").Ref<Direction>;
            currentFirstSliderDate: Readonly<import("vue").Ref<import("../shared/RangePicker/shared/types").CurrentFirstSliderDate>>;
            setCurrentFirstSliderDate: import("../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("../shared/types").RangePickerLanguageStrings>;
                direction: import("vue").Ref<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: 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: 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("../shared/types").RangePickerDate;
                strings: import("vue").Ref<import("../shared/types").RangePickerLanguageStrings>;
                fromDate: import("vue").Ref<import('../../shared/types').DateItem>;
                toDate: import("vue").Ref<import('../../shared/types').DateItem>;
                setFromDate: SetDateItem;
                setToDate: 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("../shared/types").RangePickerLanguageStrings>;
            fromDate: import("vue").Ref<import('../../shared/types').DateItem>;
            toDate: import("vue").Ref<import('../../shared/types').DateItem>;
            selectRange: SelectRange;
            setToDate: SetDateItem;
            setFromDate: SetDateItem;
            setCurrentFirstSliderDate: import("../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("../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;
} & {}>, {}>;
export default _sfc_main;