persian-date-time-picker/index.d.ts

A lightweight, customizable Angular date/time picker with full Persian (Jalali/Shamsi) calendar support. Supports date ranges, time selection, and seamless integration with Angular Material.

import * as i0 from '@angular/core';
import { OnDestroy, OnInit, OnChanges, ElementRef, Injector, ChangeDetectorRef, EventEmitter, SimpleChanges, TemplateRef, AfterViewInit, QueryList, NgZone } from '@angular/core';
import { ControlValueAccessor, FormBuilder, FormGroup, AbstractControl, ValidationErrors } from '@angular/forms';
import * as _angular_cdk_overlay from '@angular/cdk/overlay';
import { CdkOverlayOrigin, ConnectedOverlayPositionChange, ConnectionPositionPair, HorizontalConnectionPos, VerticalConnectionPos, CdkConnectedOverlay } from '@angular/cdk/overlay';
import { BehaviorSubject, Subject } from 'rxjs';
import { AnimationTriggerMetadata } from '@angular/animations';

interface DateAdapter<T> {
    today(): T;
    parse(value: any, formatString: string): T | null;
    format(date: T, formatString: string): string;
    addDays(date: T, amount: number): T;
    addMonths(date: T, amount: number): T;
    addYears(date: T, amount: number): T;
    addHours(date: T, amount: number): T;
    getYear(date: T): number | null;
    getMonth(date: T): number | null;
    getDate(date: T): number | null;
    getDayOfWeek(date: T): number;
    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    getDateNames(): string[];
    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    getFirstDayOfWeek(): number;
    getNumDaysInMonth(date: T): number;
    clone(date: T): T;
    createDate(year: number, month: number, date: number): T;
    isSameDay(date1: T, date2: T): boolean;
    isSameMonth(date1: T, date2: T): boolean;
    isSameYear(date1: T, date2: T): boolean;
    isAfter(date1: T, date2: T): boolean;
    isBefore(date1: T, date2: T): boolean;
    isEqual(date1: T, date2: T): boolean;
    startOfMonth(date: T): T;
    endOfMonth(date: T): T;
    startOfWeek(date: T): T;
    isValidFormat(dateString: string, formatString: string): boolean;
    max(dates: T[]): T;
    setYear(date: T, year: number): T;
    startOfDay(date: T): T;
    getHours(date: T): number | null;
    getMinutes(date: T): number | null;
    getSeconds(date: T): number | null;
    setHours(date: T, hours: number): T;
    setMinutes(date: T, minutes: number): T;
    setSeconds(date: T, seconds: number): T;
    getDaysInMonth(date: T): number;
    addMinutes(date: T, amount: number): T;
}
declare class JalaliDateAdapter implements DateAdapter<Date> {
    today(): Date;
    parse(value: any, formatString: string): Date | null;
    format(date: Date, formatString: string): string;
    addDays(date: Date, amount: number): Date;
    addMonths(date: Date, amount: number): Date;
    addYears(date: Date, amount: number): Date;
    addHours(date: Date, amount: number): Date;
    getYear(date: Date): number | null;
    getMonth(date: Date): number | null;
    getDate(date: Date): number | null;
    getDayOfWeek(date: Date): number;
    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    getDateNames(): string[];
    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    getFirstDayOfWeek(): number;
    getNumDaysInMonth(date: Date): number;
    clone(date: Date): Date;
    createDate(year: number, month: number, date: number): Date;
    isSameDay(date1: Date, date2: Date): boolean;
    isSameMonth(date1: Date, date2: Date): boolean;
    isSameYear(date1: Date, date2: Date): boolean;
    isAfter(date1: Date, date2: Date): boolean;
    isBefore(date1: Date, date2: Date): boolean;
    isEqual(date1: Date, date2: Date): boolean;
    startOfMonth(date: Date): Date;
    endOfMonth(date: Date): Date;
    startOfWeek(date: Date): Date;
    isValidFormat(dateString: string, formatString: string): boolean;
    max(dates: Date[]): Date;
    setYear(date: Date, year: number): Date;
    startOfDay(date: Date): Date;
    getHours(date: Date): number | null;
    getMinutes(date: Date): number | null;
    getSeconds(date: Date): number | null;
    setHours(date: Date, hours: number): Date;
    setMinutes(date: Date, minutes: number): Date;
    setSeconds(date: Date, seconds: number): Date;
    getDaysInMonth(date: Date): number;
    addMinutes(date: Date, amount: number): Date;
    static ɵfac: i0.ɵɵFactoryDeclaration<JalaliDateAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<JalaliDateAdapter>;
}
declare class GregorianDateAdapter implements DateAdapter<Date> {
    today(): Date;
    parse(value: any, formatString: string): Date | null;
    format(date: Date, formatString: string): string;
    addDays(date: Date, amount: number): Date;
    addMonths(date: Date, amount: number): Date;
    addYears(date: Date, amount: number): Date;
    addHours(date: Date, amount: number): Date;
    getYear(date: Date): number;
    getMonth(date: Date): number;
    getDate(date: Date): number;
    getDayOfWeek(date: Date): number;
    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
    getDateNames(): string[];
    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
    getFirstDayOfWeek(): number;
    getNumDaysInMonth(date: Date): number;
    clone(date: Date): Date;
    createDate(year: number, month: number, date: number): Date;
    isSameDay(date1: Date, date2: Date): boolean;
    isSameMonth(date1: Date, date2: Date): boolean;
    isSameYear(date1: Date, date2: Date): boolean;
    isAfter(date1: Date, date2: Date): boolean;
    isBefore(date1: Date, date2: Date): boolean;
    isEqual(date1: Date, date2: Date): boolean;
    startOfMonth(date: Date): Date;
    endOfMonth(date: Date): Date;
    startOfWeek(date: Date): Date;
    isValidFormat(dateString: string, formatString: string): boolean;
    max(dates: Date[]): Date;
    setYear(date: Date, year: number): Date;
    startOfDay(date: Date): Date;
    getHours(date: Date): number | null;
    getMinutes(date: Date): number | null;
    getSeconds(date: Date): number | null;
    setHours(date: Date, hours: number): Date;
    setMinutes(date: Date, minutes: number): Date;
    setSeconds(date: Date, seconds: number): Date;
    getDaysInMonth(date: Date): number;
    addMinutes(date: Date, amount: number): Date;
    static ɵfac: i0.ɵɵFactoryDeclaration<GregorianDateAdapter, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GregorianDateAdapter>;
}

interface CustomLabels {
    label: string;
    value: Array<Date> | 'custom';
    arrow?: boolean;
}
interface YearRange {
    start: number;
    end: number;
}
interface DateRange {
    start: Date | null;
    end?: Date | null;
}
interface RangeInputLabels {
    start: string;
    end: string;
}
interface LanguageLocale {
    today: string;
    lastDay: string;
    lastWeek: string;
    lastMonth: string;
    custom: string;
    previousMonth: string;
    nextMonth: string;
    previousYear: string;
    nextYear: string;
    selectTime: string;
    selectDate: string;
    selectMonth: string;
    selectYear: string;
    selectDateRange: string;
    startDate: string;
    endDate: string;
    pm: string;
    am: string;
    ok: string;
    cancel: string;
    now: string;
}
declare class PersianLocale implements LanguageLocale {
    today: string;
    lastDay: string;
    lastWeek: string;
    lastMonth: string;
    custom: string;
    previousMonth: string;
    nextMonth: string;
    previousYear: string;
    nextYear: string;
    selectTime: string;
    selectDate: string;
    selectMonth: string;
    selectYear: string;
    selectDateRange: string;
    startDate: string;
    endDate: string;
    pm: string;
    am: string;
    ok: string;
    cancel: string;
    now: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersianLocale, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PersianLocale>;
}
declare class EnglishLocale implements LanguageLocale {
    today: string;
    lastDay: string;
    lastWeek: string;
    lastMonth: string;
    custom: string;
    previousMonth: string;
    nextMonth: string;
    previousYear: string;
    nextYear: string;
    selectTime: string;
    selectDate: string;
    selectMonth: string;
    selectYear: string;
    selectDateRange: string;
    startDate: string;
    endDate: string;
    pm: string;
    am: string;
    ok: string;
    cancel: string;
    now: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<EnglishLocale, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<EnglishLocale>;
}

type Placement = 'bottomLeft' | 'bottomRight' | 'topLeft' | 'topRight';
type RangePartType = 'start' | 'end' | '';
type CalendarType = 'jalali' | 'gregorian';
type DatePickerMode = 'day' | 'month' | 'year';
type TimeValueType = 'date' | 'string';
interface TimeConfig {
    hour: number;
    minute: number;
    second: number;
    period?: string;
}
type TimeFormat = '12' | '24';
type ScrollBehavior$1 = 'smooth' | 'auto';
type ValueFormat = 'jalali' | 'gregorian' | 'date';

interface ValidTimeResult {
    isValid: boolean;
    normalizedTime: string;
}
declare class PersianDateTimePickerService {
    persianLocale: PersianLocale;
    englishLocale: EnglishLocale;
    activeInput: BehaviorSubject<string>;
    languageLocale?: LanguageLocale;
    constructor(persianLocale: PersianLocale, englishLocale: EnglishLocale);
    getActiveInputValue(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PersianDateTimePickerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PersianDateTimePickerService>;
}
declare class DestroyService extends Subject<void> implements OnDestroy {
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DestroyService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DestroyService>;
}

declare class TimePickerComponent implements ControlValueAccessor, OnInit, OnDestroy, OnChanges {
    formBuilder: FormBuilder;
    elementRef: ElementRef;
    injector: Injector;
    changeDetectorRef: ChangeDetectorRef;
    persianDateTimePickerService: PersianDateTimePickerService;
    jalaliDateAdapter: JalaliDateAdapter;
    gregorianDateAdapter: GregorianDateAdapter;
    placeholder?: string;
    rtl: boolean;
    placement: 'left' | 'right';
    minTime?: string;
    maxTime?: string;
    lang: LanguageLocale;
    valueType: TimeValueType;
    cssClass: string;
    showIcon: boolean;
    dateAdapter: DateAdapter<Date>;
    inline: boolean;
    disableInputMask: boolean;
    disabled: boolean;
    disabledTimesFilter?: (date: Date) => boolean;
    allowEmpty: boolean;
    readOnly: boolean;
    readOnlyInput: boolean;
    timeChange: EventEmitter<string | Date>;
    openChange: EventEmitter<boolean>;
    timePickerInput: ElementRef<HTMLInputElement>;
    popupWrapper: ElementRef<HTMLDivElement>;
    timeFormat: TimeFormat;
    showSeconds: boolean;
    hours: number[];
    minutes: number[];
    seconds: number[];
    periods: string[];
    selectedTime: TimeConfig;
    isOpen: boolean;
    form?: FormGroup;
    origin?: CdkOverlayOrigin;
    overlayPositions: _angular_cdk_overlay.ConnectionPositionPair[];
    private timeoutId;
    constructor(formBuilder: FormBuilder, elementRef: ElementRef, injector: Injector, changeDetectorRef: ChangeDetectorRef, persianDateTimePickerService: PersianDateTimePickerService, jalaliDateAdapter: JalaliDateAdapter, gregorianDateAdapter: GregorianDateAdapter);
    private _displayFormat;
    get displayFormat(): string;
    set displayFormat(value: string);
    private _value;
    get value(): Date | string | null;
    set value(val: Date | string | null);
    private _selectedDate;
    get selectedDate(): Date | null;
    set selectedDate(date: Date | null);
    ngOnInit(): void;
    ngOnDestroy(): void;
    ngOnChanges(changes: SimpleChanges): void;
    initializeForm(): void;
    initializeLocale(): void;
    updateLocale(): void;
    setupInputSubscription(): void;
    updateHourRange(): void;
    formatTime(date?: Date): string;
    parseTimeString(value: string | Date): void;
    updateFromValue(value: Date | string | null): void;
    updateFromDate(date: Date | null): void;
    resetSelection(): void;
    writeValue(value: Date | string | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    handleKeydown(event: KeyboardEvent): void;
    handleTimeInput(): void;
    handleDocumentClick: (event: MouseEvent) => void;
    onFocusInput(): void;
    toggleTimePicker(event: Event): void;
    open(): void;
    close(): void;
    selectHour(hour: number): void;
    selectMinute(minute: number): void;
    selectSecond(second: number): void;
    selectPeriod(period: string): void;
    selectNow(): void;
    save(close?: boolean): void;
    validateAndUpdateTime(value: string): void;
    isHourDisabled(hour: number): boolean;
    isMinuteDisabled(minute: number): boolean;
    isSecondDisabled(second: number): boolean;
    isTimeDisabled(testDate: Date): boolean;
    validateAndNormalizeTime(date: Date): {
        isValid: boolean;
        normalizedDate: Date | null;
    };
    createDateWithTime(config: TimeConfig): Date;
    updateDateFromSelection(): Date;
    updateTimeDisplay(): void;
    getTimeFormatFromDisplayFormat(format: string): '12' | '24';
    scrollToTime(): Promise<void>;
    scrollToSelectedItem(id: string, behavior?: ScrollBehavior): Promise<boolean>;
    cleanupTimeouts(): void;
    onPositionChange(position: ConnectedOverlayPositionChange): void;
    private onChange;
    private onTouched;
    private isFullHourDisabled;
    private isFullMinuteDisabled;
    static ɵfac: i0.ɵɵFactoryDeclaration<TimePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TimePickerComponent, "persian-time-picker", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "rtl": { "alias": "rtl"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "minTime": { "alias": "minTime"; "required": false; }; "maxTime": { "alias": "maxTime"; "required": false; }; "lang": { "alias": "lang"; "required": false; }; "valueType": { "alias": "valueType"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "dateAdapter": { "alias": "dateAdapter"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "disableInputMask": { "alias": "disableInputMask"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disabledTimesFilter": { "alias": "disabledTimesFilter"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "readOnlyInput": { "alias": "readOnlyInput"; "required": false; }; "displayFormat": { "alias": "displayFormat"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; }, { "timeChange": "timeChange"; "openChange": "openChange"; }, never, never, true, never>;
}

declare class CustomTemplate {
    templateRef: TemplateRef<any>;
    type: string | undefined;
    name: string | undefined;
    constructor(templateRef: TemplateRef<any>);
    getType(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<CustomTemplate, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<CustomTemplate, "[dtp-template]", never, { "type": { "alias": "type"; "required": false; }; "name": { "alias": "dtp-template"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DatePickerPopupComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    changeDetectorRef: ChangeDetectorRef;
    persianDateTimePickerService: PersianDateTimePickerService;
    jalaliDateAdapter: JalaliDateAdapter;
    gregorianDateAdapter: GregorianDateAdapter;
    destroyService: DestroyService;
    rtl: boolean;
    selectedDate: Date | null;
    selectedStartDate: Date | null;
    selectedEndDate: Date | null;
    mode: DatePickerMode;
    isRange: boolean;
    customLabels?: Array<CustomLabels>;
    calendarType: CalendarType;
    minDate: Date | null;
    maxDate: Date | null;
    cssClass: string;
    footerDescription: string;
    activeInput: 'start' | 'end' | '' | null;
    showSidebar: boolean;
    showToday?: boolean;
    showTimePicker: boolean;
    timeDisplayFormat: string;
    dateFormat?: string;
    disabledDates: Array<Date | string>;
    disabledDatesFilter?: (date: Date) => boolean;
    disabledTimesFilter?: (date: Date) => boolean;
    templates?: QueryList<CustomTemplate>;
    dateSelected: EventEmitter<Date>;
    dateRangeSelected: EventEmitter<DateRange>;
    closePicker: EventEmitter<void>;
    clickInside: EventEmitter<boolean>;
    itemSelector?: ElementRef;
    timePicker?: TimePickerComponent;
    dateAdapter?: DateAdapter<Date>;
    weekDays: string[];
    periods: Array<CustomLabels>;
    days: Date[];
    currentDate?: Date;
    selectedPeriod: any;
    tempEndDate: Date | null;
    monthListNum: number[];
    yearList: number[];
    yearRanges: Array<YearRange>;
    viewMode: 'days' | 'months' | 'years';
    lang?: LanguageLocale;
    timeoutId: any;
    dayTemplate?: TemplateRef<any>;
    monthTemplate?: TemplateRef<any>;
    quarterTemplate?: TemplateRef<any>;
    yearTemplate?: TemplateRef<any>;
    constructor(elementRef: ElementRef, changeDetectorRef: ChangeDetectorRef, persianDateTimePickerService: PersianDateTimePickerService, jalaliDateAdapter: JalaliDateAdapter, gregorianDateAdapter: GregorianDateAdapter, destroyService: DestroyService);
    get getDate(): Date;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    initializeComponent(): void;
    initLabels(): void;
    generateDefaultPeriods(today: Date): void;
    setDateAdapter(): void;
    generateCalendar(): void;
    setViewMode(): void;
    showMonthSelector(): void;
    showYearSelector(): void;
    onTimeChange(time: string | Date): void;
    updateSingleDateTime(timeDate: Date): void;
    updateRangeDateTime(timeDate: Date): void;
    setTimePickerDate(date?: Date): void;
    selectDate(date: Date): void;
    handleRangeSelection(date: Date): void;
    handleSingleSelection(date: Date): void;
    selectMonth(month: number, closeAfterSelection?: boolean): void;
    selectYear(year: number, sideSelector?: boolean): void;
    goPrev(): void;
    goNext(): void;
    prevMonth(): void;
    nextMonth(): void;
    isSelected(date: Date): boolean;
    isRangeStart(date: Date): boolean | null;
    isRangeEnd(date: Date): boolean | null;
    isInRange(date: Date): boolean | null;
    isToday(date: Date): boolean;
    isActiveMonth(month: number): boolean;
    isActiveYear(year: number): boolean;
    isActiveYearRange(startYear: number): boolean;
    isDateDisabled(date: Date): boolean;
    isMonthDisabled(month: number): boolean;
    isYearDisabled(year: number): boolean;
    isYearRangeDisabled(yearRange: YearRange): boolean;
    isPrevMonthDisabled(): boolean;
    isNextMonthDisabled(): boolean;
    parseDisabledDates(): Date[];
    onMouseEnter(date: Date, event: Event): void;
    onClickInside(): void;
    getMonthName(month: number): string;
    getCurrentMonthName(): string;
    getCurrentYear(): number;
    getWeekDays(): string[];
    isSameMonth(date1: Date, date2: Date): boolean;
    closeDatePicker(): void;
    generateYearRanges(length?: number): void;
    generateYearList(length?: number): void;
    selectYearRange(startYear: number): void;
    isActivePeriod(period: CustomLabels): boolean;
    selectPeriod(period: CustomLabels): void;
    onTodayClick(): void;
    onOkClick(): void;
    scrollToSelectedItem(id?: number | null): void;
    determineScrollItemId(id: number | null): number | null;
    handleChanges(changes: SimpleChanges): void;
    setInitialDate(): void;
    determineInitialDate(): Date;
    adjustCurrentDateToValidRange(): void;
    private applyTimeToDate;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerPopupComponent, "persian-date-picker-popup", never, { "rtl": { "alias": "rtl"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "selectedStartDate": { "alias": "selectedStartDate"; "required": false; }; "selectedEndDate": { "alias": "selectedEndDate"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isRange": { "alias": "isRange"; "required": false; }; "customLabels": { "alias": "customLabels"; "required": false; }; "calendarType": { "alias": "calendarType"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "footerDescription": { "alias": "footerDescription"; "required": false; }; "activeInput": { "alias": "activeInput"; "required": false; }; "showSidebar": { "alias": "showSidebar"; "required": false; }; "showToday": { "alias": "showToday"; "required": false; }; "showTimePicker": { "alias": "showTimePicker"; "required": false; }; "timeDisplayFormat": { "alias": "timeDisplayFormat"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "disabledDates": { "alias": "disabledDates"; "required": false; }; "disabledDatesFilter": { "alias": "disabledDatesFilter"; "required": false; }; "disabledTimesFilter": { "alias": "disabledTimesFilter"; "required": false; }; "templates": { "alias": "templates"; "required": false; }; }, { "dateSelected": "dateSelected"; "dateRangeSelected": "dateRangeSelected"; "closePicker": "closePicker"; "clickInside": "clickInside"; }, never, never, true, never>;
}

declare class DatePickerComponent implements ControlValueAccessor, OnInit, OnChanges, AfterViewInit, OnDestroy {
    formBuilder: FormBuilder;
    elementRef: ElementRef;
    injector: Injector;
    changeDetectorRef: ChangeDetectorRef;
    persianDateTimePickerService: PersianDateTimePickerService;
    destroyService: DestroyService;
    ngZone: NgZone;
    jalaliDateAdapter: JalaliDateAdapter;
    gregorianDateAdapter: GregorianDateAdapter;
    rtl: boolean;
    mode: DatePickerMode;
    isRange: boolean;
    customLabels?: Array<CustomLabels>;
    calendarType: CalendarType;
    lang?: LanguageLocale;
    cssClass: string;
    footerDescription: string;
    rangeInputLabels?: RangeInputLabels;
    inputLabel?: string;
    placement: Placement;
    disabled: boolean;
    isInline: boolean;
    showSidebar: boolean;
    showToday: boolean;
    valueFormat: ValueFormat;
    disableInputMask: boolean;
    disabledDates: Array<Date | string>;
    disabledDatesFilter?: (date: Date) => boolean;
    disabledTimesFilter?: (date: Date) => boolean;
    allowEmpty: boolean;
    readOnly: boolean;
    readOnlyInput: boolean;
    onFocus: EventEmitter<any>;
    onBlur: EventEmitter<any>;
    onChangeValue: EventEmitter<any>;
    onOpenChange: EventEmitter<boolean>;
    datePickerInput?: ElementRef;
    rangePickerInputs?: QueryList<ElementRef<HTMLInputElement>>;
    datePickerPopup?: DatePickerPopupComponent;
    templates: QueryList<CustomTemplate>;
    origin?: CdkOverlayOrigin;
    overlayPositions: ConnectionPositionPair[];
    currentPositionX: HorizontalConnectionPos;
    currentPositionY: VerticalConnectionPos;
    document?: Document;
    isOpen: boolean;
    selectedDate: Date | null;
    selectedStartDate: Date | null;
    selectedEndDate: Date | null;
    form?: FormGroup;
    dateAdapter?: DateAdapter<Date>;
    activeInput: 'start' | 'end' | '' | null;
    hideStateHelper: boolean;
    isInternalChange: boolean;
    lastEmittedValue: any;
    showTimePicker: boolean;
    timeDisplayFormat: string;
    documentClickListener?: (event: MouseEvent) => void;
    constructor(formBuilder: FormBuilder, elementRef: ElementRef, injector: Injector, changeDetectorRef: ChangeDetectorRef, persianDateTimePickerService: PersianDateTimePickerService, destroyService: DestroyService, ngZone: NgZone, jalaliDateAdapter: JalaliDateAdapter, gregorianDateAdapter: GregorianDateAdapter, doc: Document);
    private _minDate;
    get minDate(): Date;
    set minDate(date: Date | string | null);
    private _maxDate;
    get maxDate(): Date;
    set maxDate(date: Date | string | null);
    private _format;
    get format(): string;
    set format(value: string);
    get valueAdapter(): JalaliDateAdapter | GregorianDateAdapter;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    initializeComponent(doc: Document): void;
    initialize(): void;
    setupAfterViewInit(): void;
    setDateAdapter(): void;
    setupFormControls(): void;
    handleChanges(changes: SimpleChanges): void;
    handleDocumentClick(event: MouseEvent): void;
    onInputChange(value: string, inputType?: 'start' | 'end'): void;
    handleRangeInputChange(value: string, inputType?: 'start' | 'end'): void;
    handleSingleInputChange(value: string): void;
    emitValueIfChanged(): void;
    prepareValueForEmission(): any;
    onDateSelected(date: Date): void;
    handleRangeDateSelection(date: Date): void;
    handleSingleDateSelection(date: Date): void;
    onDateRangeSelected(dateRange: DateRange): void;
    close(): void;
    open(): void;
    focus(): void;
    getInput(partType?: RangePartType): HTMLInputElement | undefined;
    getPlaceholder(inputType?: string | null): string;
    clampDate(date: Date): Date | null;
    clampDateTime(adjustedDate: Date | null, date: Date): Date;
    findNearestValidDate(date: Date): Date;
    validateAndNormalizeTime(date: Date): {
        isValid: boolean;
        normalizedDate: Date | null;
    };
    parseDisabledDates(): Date[];
    isDateDisabled(date: Date): boolean;
    isTimeDisabled(date: Date): boolean;
    dateFormatValidator(control: AbstractControl): ValidationErrors | null;
    getFormatForMode(): string;
    setPlacement(placement: Placement): void;
    onPositionChange(position: ConnectedOverlayPositionChange): void;
    onFocusout(event: FocusEvent): void;
    onInputBlur(inputType: 'start' | 'end' | null, event: Event): void;
    getInputValue(inputType: 'start' | 'end' | null): string | undefined;
    validateAndCorrectInput(value: string): string;
    handleCorrectedValue(inputType: 'start' | 'end' | null, correctedValue: string): void;
    handleRangeCorrectedValue(inputType: 'start' | 'end' | null, correctedValue: string): void;
    handleSingleCorrectedValue(correctedValue: string): void;
    onFocusInput(inputType: 'start' | 'end' | null, event: Event): void;
    toggleDatePicker(inputType: 'start' | 'end' | null, event: Event): void;
    onInputKeydown(event: KeyboardEvent): void;
    updateInputValue(): void;
    updateDatePickerPopup(): void;
    convertDateToFormat(date: Date, fromType: CalendarType): any;
    onChange: any;
    onTouch: any;
    writeValue(value: any): void;
    resetValues(): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setupActiveInputSubscription(): void;
    setupMouseDownEventHandler(): void;
    parseDateValue(value: any): Date | null;
    parseValueFromFormat(value: string | Date, targetAdapter: DateAdapter<Date>): Date | null;
    parseIncomingValue(value: any): Date | null;
    hasTimeComponent(format: string): boolean;
    extractTimeFormat(format: string): string;
    extractDateFormat(format: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerComponent, "persian-date-picker", never, { "rtl": { "alias": "rtl"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isRange": { "alias": "isRange"; "required": false; }; "customLabels": { "alias": "customLabels"; "required": false; }; "calendarType": { "alias": "calendarType"; "required": false; }; "lang": { "alias": "lang"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "footerDescription": { "alias": "footerDescription"; "required": false; }; "rangeInputLabels": { "alias": "rangeInputLabels"; "required": false; }; "inputLabel": { "alias": "inputLabel"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isInline": { "alias": "isInline"; "required": false; }; "showSidebar": { "alias": "showSidebar"; "required": false; }; "showToday": { "alias": "showToday"; "required": false; }; "valueFormat": { "alias": "valueFormat"; "required": false; }; "disableInputMask": { "alias": "disableInputMask"; "required": false; }; "disabledDates": { "alias": "disabledDates"; "required": false; }; "disabledDatesFilter": { "alias": "disabledDatesFilter"; "required": false; }; "disabledTimesFilter": { "alias": "disabledTimesFilter"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; "readOnly": { "alias": "readOnly"; "required": false; }; "readOnlyInput": { "alias": "readOnlyInput"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "format": { "alias": "format"; "required": false; }; }, { "onFocus": "onFocus"; "onBlur": "onBlur"; "onChangeValue": "onChangeValue"; "onOpenChange": "onOpenChange"; }, ["templates"], never, true, never>;
}

declare class DateMaskDirective {
    elementRef: ElementRef;
    dateFormat: string;
    disableInputMask: boolean;
    delimiters: string[];
    parts: string[];
    lastValue: string;
    constructor(elementRef: ElementRef);
    ngOnInit(): void;
    parseFormat(): void;
    isFormatChar(char: string): boolean;
    onInput(event: InputEvent): void;
    extractPart(value: string, format: string): string;
    removeProcessedPart(value: string, part: string): string;
    onKeyDown(event: KeyboardEvent): void;
    validatePart(value: string, format: string): string;
    getPartLength(format: string): number;
    getCurrentPartIndex(value: string, cursorPosition: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<DateMaskDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DateMaskDirective, "[dtp-dateMask]", never, { "dateFormat": { "alias": "dtp-dateMask"; "required": false; }; "disableInputMask": { "alias": "disableInputMask"; "required": false; }; }, {}, never, never, true, never>;
}

type SafeAny = any;
/**
 * Input decorator that handle a prop to do get/set automatically with toBoolean
 *
 * Why not using @InputBoolean alone without @Input? AOT needs @Input to be visible
 *
 * @howToUse
 * ```
 * @Input() @InputBoolean() visible: boolean = false;
 *
 * // Act as below:
 * // @Input()
 * // get visible() { return this.__visible; }
 * // set visible(value) { this.__visible = value; }
 * // __visible = false;
 * ```
 */
declare function InputBoolean(): any;
declare function toBoolean(value: boolean | string): boolean;
declare class NzConnectedOverlayDirective {
    private readonly cdkConnectedOverlay;
    private readonly destroyService;
    nzArrowPointAtCenter: boolean;
    constructor(cdkConnectedOverlay: CdkConnectedOverlay, destroyService: DestroyService);
    private updateArrowPosition;
    private getFlexibleConnectedPositionStrategyOrigin;
    private getOriginRect;
    static ɵfac: i0.ɵɵFactoryDeclaration<NzConnectedOverlayDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NzConnectedOverlayDirective, "[cdkConnectedOverlay][nzConnectedOverlay]", ["nzConnectedOverlay"], { "nzArrowPointAtCenter": { "alias": "nzArrowPointAtCenter"; "required": false; }; }, {}, never, never, true, never>;
}
declare const POSITION_MAP: {
    top: ConnectionPositionPair;
    topCenter: ConnectionPositionPair;
    topLeft: ConnectionPositionPair;
    topRight: ConnectionPositionPair;
    right: ConnectionPositionPair;
    rightTop: ConnectionPositionPair;
    rightBottom: ConnectionPositionPair;
    bottom: ConnectionPositionPair;
    bottomCenter: ConnectionPositionPair;
    bottomLeft: ConnectionPositionPair;
    bottomRight: ConnectionPositionPair;
    left: ConnectionPositionPair;
    leftTop: ConnectionPositionPair;
    leftBottom: ConnectionPositionPair;
};
type POSITION_TYPE = keyof typeof POSITION_MAP;
type POSITION_TYPE_HORIZONTAL = Extract<POSITION_TYPE, 'bottomLeft' | 'bottomCenter' | 'bottomRight' | 'topLeft' | 'topCenter' | 'topRight'>;
declare const DEFAULT_TOOLTIP_POSITIONS: ConnectionPositionPair[];
declare const DEFAULT_CASCADER_POSITIONS: ConnectionPositionPair[];
declare const DEFAULT_MENTION_TOP_POSITIONS: ConnectionPositionPair[];
declare const DEFAULT_MENTION_BOTTOM_POSITIONS: ConnectionPositionPair[];
declare function getPlacementName(position: ConnectedOverlayPositionChange): string | undefined;
declare const DATE_PICKER_POSITION_MAP: {
    bottomLeft: ConnectionPositionPair;
    topLeft: ConnectionPositionPair;
    bottomRight: ConnectionPositionPair;
    topRight: ConnectionPositionPair;
};
declare const DEFAULT_DATE_PICKER_POSITIONS: ConnectionPositionPair[];

declare class PersianDateTimePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<PersianDateTimePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<PersianDateTimePickerModule, never, [typeof DatePickerComponent, typeof TimePickerComponent, typeof DatePickerPopupComponent, typeof DateMaskDirective, typeof NzConnectedOverlayDirective, typeof CustomTemplate], [typeof DatePickerComponent, typeof TimePickerComponent, typeof DatePickerPopupComponent, typeof DateMaskDirective, typeof NzConnectedOverlayDirective, typeof CustomTemplate]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<PersianDateTimePickerModule>;
}

declare const slideMotion: AnimationTriggerMetadata;
declare const slideAlertMotion: AnimationTriggerMetadata;

export { CustomTemplate, DATE_PICKER_POSITION_MAP, DEFAULT_CASCADER_POSITIONS, DEFAULT_DATE_PICKER_POSITIONS, DEFAULT_MENTION_BOTTOM_POSITIONS, DEFAULT_MENTION_TOP_POSITIONS, DEFAULT_TOOLTIP_POSITIONS, DateMaskDirective, DatePickerComponent, DatePickerPopupComponent, DestroyService, EnglishLocale, GregorianDateAdapter, InputBoolean, JalaliDateAdapter, NzConnectedOverlayDirective, POSITION_MAP, PersianDateTimePickerModule, PersianDateTimePickerService, PersianLocale, TimePickerComponent, getPlacementName, slideAlertMotion, slideMotion, toBoolean };
export type { CalendarType, CustomLabels, DateAdapter, DatePickerMode, DateRange, LanguageLocale, POSITION_TYPE, POSITION_TYPE_HORIZONTAL, Placement, RangeInputLabels, RangePartType, SafeAny, ScrollBehavior$1 as ScrollBehavior, TimeConfig, TimeFormat, TimeValueType, ValidTimeResult, ValueFormat, YearRange };