gramli-angular-mydatepicker/index.d.ts

Angular datepicker

import * as i0 from '@angular/core';
import { AfterViewInit, OnDestroy, ElementRef, Renderer2, ChangeDetectorRef, OnChanges, EventEmitter, SimpleChanges, ViewContainerRef } from '@angular/core';
import * as i10 from '@angular/forms';
import { ControlValueAccessor, Validator, AbstractControl } from '@angular/forms';
import * as i9 from '@angular/common';

interface IMyDate {
    year: number;
    month: number;
    day: number;
}

interface IMyDateRange {
    begin: IMyDate;
    end: IMyDate;
}

interface IMyMonth {
    monthTxt?: string;
    monthNbr: number;
    year: number;
}

interface IMyDisabledDate {
    disabled: boolean;
    styleClass?: string;
}

interface IMyMarkedDate {
    marked: boolean;
    color?: string;
    styleClass?: string;
}

interface IMyCalendarDay {
    dateObj: IMyDate;
    cmo: number;
    currDay: boolean;
    disabledDate: IMyDisabledDate;
    markedDate: IMyMarkedDate;
    highlight: boolean;
    range?: boolean;
    row?: number;
    col?: number;
}

interface IMyCalendarMonth {
    nbr: number;
    year: number;
    name: string;
    currMonth: boolean;
    selected: boolean;
    disabled: boolean;
    row?: number;
    col?: number;
}

interface IMyCalendarYear {
    year: number;
    currYear: boolean;
    selected: boolean;
    disabled: boolean;
    row?: number;
    col?: number;
}

interface IMyWeek {
    week: Array<IMyCalendarDay>;
    weekNbr: number;
}

interface IMyDayLabels {
    [day: string]: string;
}

interface IMyMonthLabels {
    [month: number]: string;
}

interface IMyMarkedDates {
    dates: Array<IMyDate>;
    color?: string;
    styleClass?: string;
}

interface IMyDisabledDates {
    dates: Array<IMyDate>;
    styleClass?: string;
}

interface IMyStyles {
    selector?: string;
    styles: string;
}

interface IMyDivHostElement {
    enabled: boolean;
    placeholder: string;
}

declare enum CalAnimation {
    None = 0,
    Fade = 1,
    ScaleTop = 2,
    ScaleCenter = 3,
    Rotate = 4,
    FlipDiagonal = 5,
    Own = 6
}

interface IMyCalendarAnimation {
    in: CalAnimation;
    out: CalAnimation;
}

declare enum DefaultView {
    Date = 1,
    Month = 2,
    Year = 3
}

declare enum Year {
    min = 1000,
    max = 9999
}

interface IMyOptions {
    dateRange?: boolean;
    inline?: boolean;
    dayLabels?: IMyDayLabels;
    monthLabels?: IMyMonthLabels;
    dateFormat?: string;
    defaultView?: DefaultView;
    firstDayOfWeek?: string;
    satHighlight?: boolean;
    sunHighlight?: boolean;
    highlightDates?: Array<IMyDate>;
    markCurrentDay?: boolean;
    markCurrentMonth?: boolean;
    markCurrentYear?: boolean;
    monthSelector?: boolean;
    yearSelector?: boolean;
    disableHeaderButtons?: boolean;
    showWeekNumbers?: boolean;
    selectorHeight?: string;
    selectorWidth?: string;
    disableUntil?: IMyDate;
    disableSince?: IMyDate;
    disableDates?: Array<IMyDate> | Array<IMyDisabledDates>;
    disableDateRanges?: Array<IMyDateRange>;
    disableWeekends?: boolean;
    disableWeekdays?: Array<string>;
    enableDates?: Array<IMyDate>;
    markDates?: Array<IMyMarkedDates>;
    markWeekends?: IMyMarkedDate;
    alignSelectorRight?: boolean;
    openSelectorTopOfInput?: boolean;
    closeSelectorOnDateSelect?: boolean;
    closeSelectorOnDocumentClick?: boolean;
    minYear?: Year | number;
    maxYear?: Year | number;
    showSelectorArrow?: boolean;
    appendSelectorToBody?: boolean;
    focusInputOnDateSelect?: boolean;
    moveFocusByArrowKeys?: boolean;
    dateRangeDatesDelimiter?: string;
    inputFieldValidation?: boolean;
    showMonthNumber?: boolean;
    todayTxt?: string;
    showFooterToday?: boolean;
    calendarAnimation?: IMyCalendarAnimation;
    viewChangeAnimation?: boolean;
    rtl?: boolean;
    stylesData?: IMyStyles;
    divHostElement?: IMyDivHostElement;
    ariaLabelPrevMonth?: string;
    ariaLabelNextMonth?: string;
}
interface IAngularMyDpOptions extends IMyOptions {
}

interface IMySelectorPosition {
    top: string;
    left: string;
}

interface IMyWeekday {
    number: number;
    weekday: string;
}

interface IMyCalendarViewChanged {
    year: number;
    month: number;
    first: IMyWeekday;
    last: IMyWeekday;
}

interface IMySingleDateModel {
    date?: IMyDate;
    jsDate?: Date;
    formatted?: string;
    epoc?: number;
}

interface IMyDateRangeModel {
    beginDate?: IMyDate;
    beginJsDate?: Date;
    beginEpoc?: number;
    endDate?: IMyDate;
    endJsDate?: Date;
    endEpoc?: number;
    formatted?: string;
}

interface IMyDateModel {
    isRange: boolean;
    singleDate?: IMySingleDateModel;
    dateRange?: IMyDateRangeModel;
}

interface IMyRangeDateSelection {
    isBegin: boolean;
    date: IMyDate;
    jsDate: Date;
    dateFormat: string;
    formatted: string;
    epoc: number;
}

interface IMyDefaultMonth {
    defMonth: string;
    overrideSelection?: boolean;
}

interface IMyDateFormat {
    value: string;
    format: string;
}

interface IMyValidateOptions {
    validateDisabledDates?: boolean;
    selectedValue?: any;
}

declare class UtilService {
    weekDays: Array<string>;
    isDateValid(dateStr: string, options: IMyOptions, validateOpts: IMyValidateOptions): IMyDate;
    isDateValidDateRange(dateRangeStr: string, options: IMyOptions, validateOpts: IMyValidateOptions): IMyDateRange;
    getDateValue(dateStr: string, dateFormat: string, delimeters: Array<string>): Array<IMyDateFormat>;
    getMonthNumberByMonthName(df: IMyDateFormat, monthLabels: IMyMonthLabels): number;
    getNumberByValue(df: IMyDateFormat): number;
    parseDefaultMonth(monthString: string): IMyMonth;
    isDisabledDate(date: IMyDate, options: IMyOptions): IMyDisabledDate;
    getDisabledValue(disabled: boolean, styleClass: string): IMyDisabledDate;
    dateMatchToDates(date: IMyDate, dates: Array<IMyDate>): boolean;
    isDisabledMonth(year: number, month: number, options: IMyOptions): boolean;
    isDisabledYear(year: number, options: IMyOptions): boolean;
    isDisabledByDisableUntil(date: IMyDate, disableUntil: IMyDate): boolean;
    isDisabledByDisableSince(date: IMyDate, disableSince: IMyDate): boolean;
    isPastDatesEnabled(date: IMyDate, enableDates: Array<IMyDate>): boolean;
    isFutureDatesEnabled(date: IMyDate, enableDates: Array<IMyDate>): boolean;
    isDatesEnabled(dateBegin: IMyDate, dateEnd: IMyDate, enableDates: Array<IMyDate>): boolean;
    isDisabledByDisableDateRange(dateBegin: IMyDate, dateEnd: IMyDate, disableDateRanges: Array<IMyDateRange>): boolean;
    isMarkedDate(date: IMyDate, options: IMyOptions): IMyMarkedDate;
    getMarkedValue(marked: boolean, color: string, styleClass: string): IMyMarkedDate;
    isHighlightedDate(date: IMyDate, options: IMyOptions): boolean;
    getWeekNumber(date: IMyDate): number;
    getDateModel(date: IMyDate, dateRange: IMyDateRange, dateFormat: string, monthLabels: IMyMonthLabels, rangeDelimiter: string, dateStr?: string): IMyDateModel;
    formatDate(date: IMyDate, dateFormat: string, monthLabels: IMyMonthLabels): string;
    getOrdinal(date: number): string;
    getFormattedDate(model: IMyDateModel): string;
    preZero(val: number): string;
    isInitializedDate(date: IMyDate): boolean;
    isDateEarlier(firstDate: IMyDate, secondDate: IMyDate): boolean;
    isDateSameOrEarlier(firstDate: IMyDate, secondDate: IMyDate): boolean;
    isDateSame(firstDate: IMyDate, secondDate: IMyDate): boolean;
    isDateRangeBeginOrEndSame(dateRange: IMyDateRange, date: IMyDate): boolean;
    isDateRangeBegin(dateRange: IMyDateRange, date: IMyDate): boolean;
    isDateRangeEnd(dateRange: IMyDateRange, date: IMyDate): boolean;
    isDateInRange(date: IMyDate, dateRange: IMyDateRange): boolean;
    resetDate(): IMyDate;
    getTimeInMilliseconds(date: IMyDate): number;
    getToday(): IMyDate;
    getDayNumber(date: IMyDate): number;
    getWeekdayIndex(wd: string): number;
    getEpocTime(date: IMyDate): number;
    jsDateToMyDate(date: Date): IMyDate;
    myDateToJsDate(date: IMyDate): Date;
    datesInMonth(m: number, y: number): number;
    datesInPrevMonth(m: number, y: number): number;
    getJsDate(year: number, month: number, day: number): Date;
    getSelectedValue(selectedValue: any, dateRange: boolean): any;
    getKeyCodeFromEvent(event: any): number;
    checkKeyName(key: string, keyName: string): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<UtilService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<UtilService>;
}

declare enum HeaderAction {
    PrevBtnClick = 1,
    NextBtnClick = 2,
    MonthBtnClick = 3,
    YearBtnClick = 4
}

declare enum ActiveView {
    Date = 1,
    Month = 2,
    Year = 3
}

declare class CalendarComponent implements AfterViewInit, OnDestroy {
    private elem;
    private renderer;
    private cdr;
    private utilService;
    selectorEl: ElementRef;
    styleEl: ElementRef;
    position: string;
    opts: IMyOptions;
    visibleMonth: IMyMonth;
    selectedMonth: IMyMonth;
    selectedDate: IMyDate;
    selectedDateRange: IMyDateRange;
    weekDays: Array<string>;
    dates: Array<IMyWeek>;
    months: Array<Array<IMyCalendarMonth>>;
    years: Array<Array<IMyCalendarYear>>;
    yearsDuration: string;
    dayIdx: number;
    weekDayOpts: Array<string>;
    selectMonth: boolean;
    selectYear: boolean;
    viewChanged: boolean;
    dateChanged: (dm: IMyDateModel, close: boolean) => void;
    calendarViewChanged: (cvc: IMyCalendarViewChanged) => void;
    rangeDateSelection: (rds: IMyRangeDateSelection) => void;
    viewActivated: (va: ActiveView) => void;
    closedByEsc: () => void;
    selectorPos: IMySelectorPosition;
    prevViewDisabled: boolean;
    nextViewDisabled: boolean;
    clickListener: () => void;
    constructor(elem: ElementRef, renderer: Renderer2, cdr: ChangeDetectorRef, utilService: UtilService);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    initializeComponent(opts: IMyOptions, defaultMonth: IMyDefaultMonth, selectedValue: any, inputValue: string, selectorPos: IMySelectorPosition, dc: (dm: IMyDateModel, close: boolean) => void, cvc: (cvc: IMyCalendarViewChanged) => void, rds: (rds: IMyRangeDateSelection) => void, va: (va: ActiveView) => void, cbe: () => void): void;
    initializeView(defaultMonth: IMyDefaultMonth, selectedValue: any, inputValue: string): void;
    refreshComponent(opts: IMyOptions, defaultMonth: IMyDefaultMonth, selectedValue: any, inputValue: string): void;
    headerAction(headerAction: HeaderAction): void;
    setDefaultView(defaultView: DefaultView): void;
    setCalendarAnimation(calAnimation: IMyCalendarAnimation, isOpen: boolean): void;
    resetDateValue(): void;
    clearDate(): void;
    resetMonthYearSelect(): void;
    onMonthViewBtnClicked(): void;
    monthViewBtnClicked(): void;
    onMonthCellClicked(cell: IMyCalendarMonth): void;
    onMonthCellKeyDown(event: any): void;
    onYearViewBtnClicked(): void;
    yearViewBtnClicked(): void;
    onYearCellClicked(cell: IMyCalendarYear): void;
    onYearCellKeyDown(event: any): void;
    generateMonths(): void;
    generateYears(inputYear: number): void;
    onTodayFooterClicked(): void;
    getYearValueByRowAndCol(row: number, col: number): number;
    setCalendarVisibleMonth(): void;
    onViewActivated(event: any): void;
    onPrevNavigateBtnClicked(): void;
    onNextNavigateBtnClicked(): void;
    setDateViewMonth(isNext: boolean): void;
    onCloseSelector(event: any): void;
    onDayCellClicked(cell: IMyCalendarDay): void;
    onDayCellKeyDown(event: any): void;
    getSourceRowAndColumnFromEvent(event: any): any;
    getTargetFocusRowAndColumn(event: any, row: number, col: number, rowCount: number, colCount: number): any;
    focusCellElement(type: string, row: number, col: number, direction: boolean, colCount: number): void;
    focusToSelector(): void;
    getCalendarElements(): any;
    selectDate(date: IMyDate): void;
    monthStartIdx(y: number, m: number): number;
    isCurrDay(d: number, m: number, y: number, today: IMyDate): boolean;
    getDayNumber(date: IMyDate): number;
    getWeekday(date: IMyDate): string;
    sundayIdx(): number;
    generateCalendar(m: number, y: number, notifyChange: boolean): void;
    setDateViewHeaderBtnDisabledState(m: number, y: number): void;
    setMonthViewHeaderBtnDisabledState(y: number): void;
    setYearViewHeaderBtnDisabledState(yp: number, yn: number): void;
    swapHeaderBtnDisabled(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarComponent, "lib-angular-mydatepicker-calendar", never, {}, {}, never, never, false, never>;
}

declare class SelectionBarComponent implements OnChanges {
    opts: IMyOptions;
    yearsDuration: string;
    visibleMonth: IMyMonth;
    selectMonth: boolean;
    selectYear: boolean;
    prevViewDisabled: boolean;
    nextViewDisabled: boolean;
    prevNavigateBtnClicked: EventEmitter<void>;
    nextNavigateBtnClicked: EventEmitter<void>;
    monthViewBtnClicked: EventEmitter<void>;
    yearViewBtnClicked: EventEmitter<void>;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    onPrevNavigateBtnClicked(event: any): void;
    onNextNavigateBtnClicked(event: any): void;
    onMonthViewBtnClicked(event: any): void;
    onYearViewBtnClicked(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectionBarComponent, "lib-selection-bar", never, { "opts": { "alias": "opts"; "required": false; }; "yearsDuration": { "alias": "yearsDuration"; "required": false; }; "visibleMonth": { "alias": "visibleMonth"; "required": false; }; "selectMonth": { "alias": "selectMonth"; "required": false; }; "selectYear": { "alias": "selectYear"; "required": false; }; "prevViewDisabled": { "alias": "prevViewDisabled"; "required": false; }; "nextViewDisabled": { "alias": "nextViewDisabled"; "required": false; }; }, { "prevNavigateBtnClicked": "prevNavigateBtnClicked"; "nextNavigateBtnClicked": "nextNavigateBtnClicked"; "monthViewBtnClicked": "monthViewBtnClicked"; "yearViewBtnClicked": "yearViewBtnClicked"; }, never, never, false, never>;
}

declare class DayViewComponent implements OnChanges, AfterViewInit {
    private utilService;
    opts: IMyOptions;
    dates: Array<IMyWeek>;
    weekDays: Array<string>;
    selectedDate: IMyDate;
    selectedDateRange: IMyDateRange;
    viewChanged: boolean;
    dayCellClicked: EventEmitter<IMyCalendarDay>;
    dayCellKeyDown: EventEmitter<any>;
    viewActivated: EventEmitter<ActiveView>;
    prevMonthId: number;
    currMonthId: number;
    nextMonthId: number;
    constructor(utilService: UtilService);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    onDayCellClicked(event: any, cell: IMyCalendarDay): void;
    onDayCellKeyDown(event: any, cell: IMyCalendarDay): void;
    onDayCellMouseEnter(cell: any): void;
    onDayCellMouseLeave(): void;
    isDateInRange(date: IMyDate): boolean;
    isDateSame(date: IMyDate): boolean;
    isDateRangeBeginOrEndSame(date: IMyDate): boolean;
    isDateRangeBegin(date: IMyDate): boolean;
    isDateRangeEnd(date: IMyDate): boolean;
    isDaySelected(day: IMyCalendarDay): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<DayViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DayViewComponent, "lib-day-view", never, { "opts": { "alias": "opts"; "required": false; }; "dates": { "alias": "dates"; "required": false; }; "weekDays": { "alias": "weekDays"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "selectedDateRange": { "alias": "selectedDateRange"; "required": false; }; "viewChanged": { "alias": "viewChanged"; "required": false; }; }, { "dayCellClicked": "dayCellClicked"; "dayCellKeyDown": "dayCellKeyDown"; "viewActivated": "viewActivated"; }, never, never, false, never>;
}

declare class MonthViewComponent implements OnChanges, AfterViewInit {
    private utilService;
    opts: IMyOptions;
    months: Array<Array<IMyCalendarMonth>>;
    viewChanged: boolean;
    monthCellClicked: EventEmitter<IMyCalendarMonth>;
    monthCellKeyDown: EventEmitter<any>;
    viewActivated: EventEmitter<ActiveView>;
    constructor(utilService: UtilService);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    onMonthCellClicked(event: any, cell: IMyCalendarMonth): void;
    onMonthCellKeyDown(event: any, cell: IMyCalendarMonth): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MonthViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MonthViewComponent, "lib-month-view", never, { "opts": { "alias": "opts"; "required": false; }; "months": { "alias": "months"; "required": false; }; "viewChanged": { "alias": "viewChanged"; "required": false; }; }, { "monthCellClicked": "monthCellClicked"; "monthCellKeyDown": "monthCellKeyDown"; "viewActivated": "viewActivated"; }, never, never, false, never>;
}

declare class YearViewComponent implements OnChanges, AfterViewInit {
    private utilService;
    opts: IMyOptions;
    years: Array<Array<IMyCalendarYear>>;
    viewChanged: boolean;
    yearCellClicked: EventEmitter<IMyCalendarYear>;
    yearCellKeyDown: EventEmitter<any>;
    viewActivated: EventEmitter<ActiveView>;
    constructor(utilService: UtilService);
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    onYearCellClicked(event: any, cell: IMyCalendarYear): void;
    onYearCellKeyDown(event: any, cell: IMyCalendarYear): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<YearViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<YearViewComponent, "lib-year-view", never, { "opts": { "alias": "opts"; "required": false; }; "years": { "alias": "years"; "required": false; }; "viewChanged": { "alias": "viewChanged"; "required": false; }; }, { "yearCellClicked": "yearCellClicked"; "yearCellKeyDown": "yearCellKeyDown"; "viewActivated": "viewActivated"; }, never, never, false, never>;
}

declare class FooterBarComponent implements OnChanges {
    private utilService;
    opts: IMyOptions;
    footerBarTxtClicked: EventEmitter<void>;
    footerBarTxt: string;
    constructor(utilService: UtilService);
    ngOnChanges(changes: SimpleChanges): void;
    onFooterBarTxtClicked(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FooterBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FooterBarComponent, "lib-footer-bar", never, { "opts": { "alias": "opts"; "required": false; }; }, { "footerBarTxtClicked": "footerBarTxtClicked"; }, never, never, false, never>;
}

interface IMyInputFieldChanged {
    value: string;
    dateFormat: string;
    valid: boolean;
}

declare class LocaleService {
    private locales;
    getLocaleOptions(locale?: string): IMyOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocaleService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocaleService>;
}

declare class DefaultConfigService {
    private defaultConfig;
    getDefaultConfig(): IMyOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultConfigService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DefaultConfigService>;
}

declare class AngularMyDatePickerDirective implements OnChanges, OnDestroy, ControlValueAccessor, Validator {
    private localeService;
    private utilService;
    private vcRef;
    private renderer;
    private cdr;
    private elem;
    private config;
    options: IMyOptions;
    locale: string;
    defaultMonth: IMyDefaultMonth;
    dateChanged: EventEmitter<IMyDateModel>;
    inputFieldChanged: EventEmitter<IMyInputFieldChanged>;
    calendarViewChanged: EventEmitter<IMyCalendarViewChanged>;
    calendarToggle: EventEmitter<number>;
    rangeDateSelection: EventEmitter<IMyRangeDateSelection>;
    viewActivated: EventEmitter<ActiveView>;
    private cRef;
    private hostText;
    private preventClose;
    private disabled;
    private selectedValue;
    private opts;
    onChangeCb: (_: any) => void;
    onTouchedCb: () => void;
    constructor(localeService: LocaleService, utilService: UtilService, vcRef: ViewContainerRef, renderer: Renderer2, cdr: ChangeDetectorRef, elem: ElementRef, config: DefaultConfigService);
    onKeyUp(event: any): void;
    onBlur(): void;
    private onClickWrapper;
    private onClick;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    setLocaleOptions(): void;
    parseOptions(opts: IMyOptions): void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    validate(c: AbstractControl): {
        [p: string]: any;
    };
    openCalendar(): void;
    closeCalendar(): void;
    toggleCalendar(): boolean | null;
    clearDate(): void;
    isDateValid(): boolean;
    headerAction(headerAction: HeaderAction): void;
    setHostValue(value: string): void;
    private ignoreKeyPress;
    private onAnimateWrapper;
    private animationEnd;
    private closeSelector;
    private removeComponent;
    private updateModel;
    private getHostValue;
    private focusToInput;
    private emitDateChanged;
    private setSelectedValue;
    private emitInputFieldChanged;
    private emitCalendarChanged;
    private emitRangeDateSelection;
    private emitViewActivated;
    private emitCalendarToggle;
    private appendSelector;
    private getSelectorPosition;
    private getSelectorDimension;
    static ɵfac: i0.ɵɵFactoryDeclaration<AngularMyDatePickerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AngularMyDatePickerDirective, "[angular-mydatepicker]", ["angular-mydatepicker"], { "options": { "alias": "options"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "defaultMonth": { "alias": "defaultMonth"; "required": false; }; }, { "dateChanged": "dateChanged"; "inputFieldChanged": "inputFieldChanged"; "calendarViewChanged": "calendarViewChanged"; "calendarToggle": "calendarToggle"; "rangeDateSelection": "rangeDateSelection"; "viewActivated": "viewActivated"; }, never, never, false, never>;
}

declare class AngularMyDatePickerCalendarDirective implements AfterViewInit {
    private el;
    libAngularMyDatePickerCalendar: any;
    constructor(el: ElementRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AngularMyDatePickerCalendarDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AngularMyDatePickerCalendarDirective, "[libAngularMyDatePickerCalendar]", never, { "libAngularMyDatePickerCalendar": { "alias": "libAngularMyDatePickerCalendar"; "required": false; }; }, {}, never, never, false, never>;
}

declare class AngularMyDatePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<AngularMyDatePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<AngularMyDatePickerModule, [typeof CalendarComponent, typeof SelectionBarComponent, typeof DayViewComponent, typeof MonthViewComponent, typeof YearViewComponent, typeof FooterBarComponent, typeof AngularMyDatePickerDirective, typeof AngularMyDatePickerCalendarDirective], [typeof i9.CommonModule, typeof i10.FormsModule], [typeof CalendarComponent, typeof SelectionBarComponent, typeof DayViewComponent, typeof MonthViewComponent, typeof YearViewComponent, typeof FooterBarComponent, typeof AngularMyDatePickerDirective, typeof AngularMyDatePickerCalendarDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<AngularMyDatePickerModule>;
}

interface IMyLocales {
    [lang: string]: IMyOptions;
}

declare enum CalToggle {
    Open = 1,
    CloseByDateSel = 2,
    CloseByCalBtn = 3,
    CloseByOutClick = 4,
    CloseByEsc = 5
}

/**
 * Event key codes
 */
declare enum KeyCode {
    enter = 13,
    esc = 27,
    space = 32,
    leftArrow = 37,
    upArrow = 38,
    rightArrow = 39,
    downArrow = 40,
    tab = 9,
    shift = 16
}

/**
 * Event key names
 */
declare enum KeyName {
    enter = "Enter",
    esc = "Escape|Esc",
    space = " |Spacebar",
    leftArrow = "ArrowLeft|Left",
    upArrow = "ArrowUp|Up",
    rightArrow = "ArrowRight|Right",
    downArrow = "ArrowDown|Down",
    tab = "Tab",
    shift = "Shift"
}

declare enum MonthId {
    prev = 1,
    curr = 2,
    next = 3
}

/**
 * Constants
 */
declare const D = "d";
declare const DD = "dd";
declare const M = "m";
declare const MM = "mm";
declare const MMM = "mmm";
declare const Y = "y";
declare const YYYY = "yyyy";
declare const ORDINAL = "##";
declare const ST = "st";
declare const ND = "nd";
declare const RD = "rd";
declare const DATE_ROW_COUNT = 5;
declare const DATE_COL_COUNT = 6;
declare const MONTH_ROW_COUNT = 3;
declare const MONTH_COL_COUNT = 2;
declare const YEAR_ROW_COUNT = 4;
declare const YEAR_COL_COUNT = 4;
declare const DOT = ".";
declare const UNDER_LINE = "_";
declare const PIPE = "|";
declare const YEAR_SEPARATOR = " - ";
declare const SU = "su";
declare const MO = "mo";
declare const TU = "tu";
declare const WE = "we";
declare const TH = "th";
declare const FR = "fr";
declare const SA = "sa";
declare const DEFAULT_LOCALE = "en";
declare const ZERO_STR = "0";
declare const EMPTY_STR = "";
declare const SPACE_STR = " ";
declare const CLICK = "click";
declare const KEYUP = "keyup";
declare const BLUR = "blur";
declare const DISABLED = "disabled";
declare const BODY = "body";
declare const VALUE = "value";
declare const OPTIONS = "options";
declare const DEFAULT_MONTH = "defaultMonth";
declare const LOCALE = "locale";
declare const OBJECT = "object";
declare const PX = "px";
declare const STYLE = "style";
declare const INNER_HTML = "innerHTML";
declare const OPTS = "opts";
declare const YEARS_DURATION = "yearsDuration";
declare const YEARS = "years";
declare const VISIBLE_MONTH = "visibleMonth";
declare const SELECT_MONTH = "selectMonth";
declare const SELECT_YEAR = "selectYear";
declare const PREV_VIEW_DISABLED = "prevViewDisabled";
declare const NEXT_VIEW_DISABLED = "nextViewDisabled";
declare const DATES = "dates";
declare const WEEK_DAYS = "weekDays";
declare const SELECTED_DATE = "selectedDate";
declare const SELECTED_DATE_RANGE = "selectedDateRange";
declare const MONTHS = "months";
declare const ANIMATION_END = "animationend";
declare const ANIMATION_TIMEOUT = 550;
declare const MY_DP_ANIMATION = "myDpAnimation";
declare const ANIMATION_NAMES: string[];
declare const IN = "In";
declare const OUT = "Out";
declare const TABINDEX = "tabindex";
declare const TD_SELECTOR = "table tbody tr td:not(.myDpDaycellWeekNbr)";
declare const PREVENT_CLOSE_TIMEOUT = 50;

export { ANIMATION_END, ANIMATION_NAMES, ANIMATION_TIMEOUT, ActiveView, AngularMyDatePickerCalendarDirective, AngularMyDatePickerDirective, AngularMyDatePickerModule, BLUR, BODY, CLICK, CalAnimation, CalToggle, CalendarComponent, D, DATES, DATE_COL_COUNT, DATE_ROW_COUNT, DD, DEFAULT_LOCALE, DEFAULT_MONTH, DISABLED, DOT, DayViewComponent, DefaultConfigService, DefaultView, EMPTY_STR, FR, FooterBarComponent, HeaderAction, IN, INNER_HTML, KEYUP, KeyCode, KeyName, LOCALE, LocaleService, M, MM, MMM, MO, MONTHS, MONTH_COL_COUNT, MONTH_ROW_COUNT, MY_DP_ANIMATION, MonthId, MonthViewComponent, ND, NEXT_VIEW_DISABLED, OBJECT, OPTIONS, OPTS, ORDINAL, OUT, PIPE, PREVENT_CLOSE_TIMEOUT, PREV_VIEW_DISABLED, PX, RD, SA, SELECTED_DATE, SELECTED_DATE_RANGE, SELECT_MONTH, SELECT_YEAR, SPACE_STR, ST, STYLE, SU, SelectionBarComponent, TABINDEX, TD_SELECTOR, TH, TU, UNDER_LINE, UtilService, VALUE, VISIBLE_MONTH, WE, WEEK_DAYS, Y, YEARS, YEARS_DURATION, YEAR_COL_COUNT, YEAR_ROW_COUNT, YEAR_SEPARATOR, YYYY, Year, YearViewComponent, ZERO_STR };
export type { IAngularMyDpOptions, IMyCalendarAnimation, IMyCalendarDay, IMyCalendarMonth, IMyCalendarViewChanged, IMyCalendarYear, IMyDate, IMyDateFormat, IMyDateModel, IMyDateRange, IMyDateRangeModel, IMyDayLabels, IMyDefaultMonth, IMyDisabledDate, IMyDisabledDates, IMyDivHostElement, IMyInputFieldChanged, IMyLocales, IMyMarkedDate, IMyMarkedDates, IMyMonth, IMyMonthLabels, IMyOptions, IMyRangeDateSelection, IMySelectorPosition, IMySingleDateModel, IMyStyles, IMyWeek, IMyWeekday };