@anglr/datetime 1.0.0-beta.20220217103425 → 2.0.0

package/datetime.internal.d.ts

@@ -0,0 +1,2090 @@
+import { AbstractControl } from '@angular/forms';
+import { AnimationTriggerMetadata } from '@angular/animations';
+import { ChangeDetectorRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Dictionary } from '@jscrpt/common';
+import { ElementRef } from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import * as i0 from '@angular/core';
+import * as i7 from '@angular/common';
+import * as i8 from '@anglr/common';
+import { InjectionToken } from '@angular/core';
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { OnChanges } from '@angular/core';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { SimpleChanges } from '@angular/core';
+import { Subject } from 'rxjs';
+import { Subscription } from 'rxjs';
+import { Type } from '@angular/core';
+import { ValidationErrors } from '@angular/forms';
+import { Validator } from '@angular/forms';
+import { ValidatorFn } from '@angular/forms';
+
+/**
+ * Transforms type to required from nullable or undefined type
+ */
+declare class AsRequiredTypePipe implements PipeTransform {
+    /**
+     * Transforms type to required from nullable or undefined type
+     * @param value - Value to be transformed
+     * @param defaultValue - Default value to be used if undefined or null
+     */
+    transform(value: NgClassType, defaultValue?: string): Exclude<NgClassType, undefined | null>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsRequiredTypePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<AsRequiredTypePipe, "asRequiredType">;
+}
+
+/**
+ * Shared css classes for all pickers
+ */
+export declare interface CommonPickerCssClasses {
+    /**
+     * Period selection element wrapping displayed period and previous, next buttons
+     */
+    periodSelection?: string;
+    /**
+     * Element used for switching period to previous one
+     */
+    previousPeriod?: string;
+    /**
+     * Element used for switching period to next one
+     */
+    nextPeriod?: string;
+    /**
+     * Element representing currently displayed period
+     */
+    periodValue?: string;
+    /**
+     * Element wrapping displayed period data
+     */
+    periodData?: string;
+    /**
+     * Element representing single datum for period item
+     */
+    periodDatum?: string;
+}
+
+/**
+ * Injection token used for obtaining DateApi implementation
+ */
+export declare const DATE_API: InjectionToken<DateApi>;
+
+/**
+ * Injection token used for obtaining datetime picker configuration
+ */
+export declare const DATE_TIME_PICKER_CONFIGURATION: InjectionToken<DateTimePickerOptions<any>>;
+
+/**
+ * Injection token used for obtaining datetime selector configuration
+ */
+export declare const DATE_TIME_SELECTOR_CONFIGURATION: InjectionToken<DateTimeSelectorOptions<any>>;
+
+/**
+ * Date api abstraction, used for obtaining DateApi wrapper object
+ */
+export declare interface DateApi<TDate = any> {
+    /**
+     * Gets wrapping object used for manipulation
+     * @param value - Value to be converted (parsed) and used for manipulation
+     * @param format - Format string used for parsing string value
+     */
+    getValue(value: DateValue | TDate, format?: string): DateApiObject<TDate>;
+    /**
+     * Gets wrapping object used for manipulation instantiated to current date and time
+     */
+    now(): DateApiObject<TDate>;
+    /**
+     * Gets format string using pseudo format
+     * @param pseudoFormat - Pseudo format token, used for obtaining 'date' or 'time' format string
+     */
+    getFormat(pseudoFormat: string): string;
+    /**
+     * Gets information
+     */
+    weekStartsOnMonday(): boolean;
+    /**
+     * Gets array of weekday names in short format, order of days is dependent on locale
+     */
+    weekdaysShort(): string[];
+}
+
+/**
+ * Instance of object wrapping TDate, allowing manipulation with it
+ */
+export declare interface DateApiObject<TDate = any> {
+    /**
+     * Original value that is not changed unless 'updateOriginal' is called
+     */
+    readonly originalValue: TDate;
+    /**
+     * Instance of date
+     */
+    readonly value: TDate;
+    /**
+     * Gets indication whether provided instance of date is valid
+     */
+    isValid(): boolean;
+    /**
+     * Gets indication whether provided instance of date is weekend day
+     */
+    isWeekend(): boolean;
+    /**
+     * Formats date value
+     * @param format - Format token used for creating formatted string
+     */
+    format(format: string): string;
+    /**
+     * Updates value to start date and time of current decade
+     * @returns Itself for fluent API
+     */
+    startOfDecade(): DateApiObject<TDate>;
+    /**
+     * Updates value to end date and time of current decade
+     * @returns Itself for fluent API
+     */
+    endOfDecade(): DateApiObject<TDate>;
+    /**
+     * Updates value to start date and time of current year
+     * @returns Itself for fluent API
+     */
+    startOfYear(): DateApiObject<TDate>;
+    /**
+     * Updates value to end date and time of current year
+     * @returns Itself for fluent API
+     */
+    endOfYear(): DateApiObject<TDate>;
+    /**
+     * Add years, if count not specified adds 1 year
+     * @param count - Number of years count
+     * @returns Itself for fluent API
+     */
+    addYears(count?: number): DateApiObject<TDate>;
+    /**
+     * Subtract years, if count not specified subtract 1 year
+     * @param count - Number of years count
+     * @returns Itself for fluent API
+     */
+    subtractYears(count?: number): DateApiObject<TDate>;
+    /**
+     * Updates value to start date and time of current month
+     * @returns Itself for fluent API
+     */
+    startOfMonth(): DateApiObject<TDate>;
+    /**
+     * Updates value to end date and time of current month
+     * @returns Itself for fluent API
+     */
+    endOfMonth(): DateApiObject<TDate>;
+    /**
+     * Add months, if count not specified adds 1 month
+     * @param count - Number of months count
+     * @returns Itself for fluent API
+     */
+    addMonths(count?: number): DateApiObject<TDate>;
+    /**
+     * Subtract months, if count not specified subtract 1 month
+     * @param count - Number of months count
+     * @returns Itself for fluent API
+     */
+    subtractMonths(count?: number): DateApiObject<TDate>;
+    /**
+     * Updates value to start date and time of current week
+     * @returns Itself for fluent API
+     */
+    startOfWeek(): DateApiObject<TDate>;
+    /**
+     * Updates value to end date and time of current week
+     * @returns Itself for fluent API
+     */
+    endOfWeek(): DateApiObject<TDate>;
+    /**
+     * Add weeks, if count not specified adds 1 week
+     * @param count - Number of weeks count
+     * @returns Itself for fluent API
+     */
+    addWeeks(count?: number): DateApiObject<TDate>;
+    /**
+     * Subtract weeks, if count not specified subtract 1 week
+     * @param count - Number of weeks count
+     * @returns Itself for fluent API
+     */
+    subtractWeeks(count?: number): DateApiObject<TDate>;
+    /**
+     * Updates value to start date and time of current day
+     * @returns Itself for fluent API
+     */
+    startOfDay(): DateApiObject<TDate>;
+    /**
+     * Updates value to end date and time of current day
+     * @returns Itself for fluent API
+     */
+    endOfDay(): DateApiObject<TDate>;
+    /**
+     * Add days, if count not specified adds 1 day
+     * @param count - Number of days count
+     * @returns Itself for fluent API
+     */
+    addDays(count?: number): DateApiObject<TDate>;
+    /**
+     * Subtract days, if count not specified subtract 1 day
+     * @param count - Number of days count
+     * @returns Itself for fluent API
+     */
+    subtractDays(count?: number): DateApiObject<TDate>;
+    /**
+     * Gets number of days in month
+     */
+    daysInMonth(): number;
+    /**
+     * Gets year
+     */
+    year(): number;
+    /**
+     * Sets year
+     * @param year - Year to be set
+     */
+    year(year: number): DateApiObject<TDate>;
+    /**
+     * Gets or sets year
+     * @param year - If specified, sets year
+     */
+    year(year?: number): DateApiObject<TDate> | number;
+    /**
+     * Gets month
+     */
+    month(): number;
+    /**
+     * Sets month
+     * @param month - Month to be set
+     */
+    month(month: number): DateApiObject<TDate>;
+    /**
+     * Gets or sets month
+     * @param month - If specified, sets month
+     */
+    month(month?: number): DateApiObject<TDate> | number;
+    /**
+     * Gets day of month one based
+     */
+    dayOfMonth(): number;
+    /**
+     * Sets day of month one based
+     * @param day - Day of month to be set
+     */
+    dayOfMonth(day: number): DateApiObject<TDate>;
+    /**
+     * Gets or sets day of month one based
+     * @param day - If specified, sets day of month
+     */
+    dayOfMonth(day?: number): DateApiObject<TDate> | number;
+    /**
+     * Gets day of week zero based, first is monday
+     */
+    dayOfWeek(): number;
+    /**
+     * Sets day of week zero based, first is monday
+     * @param day - Day of week to be set
+     */
+    dayOfWeek(day: number): DateApiObject<TDate>;
+    /**
+     * Gets or sets day of week zero based, first is monday
+     * @param day - If specified, sets day of week
+     */
+    dayOfWeek(day?: number): number | DateApiObject<TDate>;
+    /**
+     * Gets indication whether current value is before 'date'
+     * @param date - Date which is this date compared to
+     */
+    isBefore(date: TDate): boolean;
+    /**
+     * Gets indication whether current value is after 'date'
+     * @param date - Date which is this date compared to
+     */
+    isAfter(date: TDate): boolean;
+    /**
+     * Gets number of days between this and provided date
+     * @param date - Date which is used for computation of diff against
+     */
+    diffDays(date: TDate): number;
+    /**
+     * Compares whether this date is same week as provided date
+     * @param date - Date which is used for comparison of same week
+     */
+    isSameWeek(date: TDate): boolean;
+    /**
+     * Compares whether this date is same decade as provided date
+     * @param date - Date which is used for comparison of same decade
+     */
+    isSameDecade(date: TDate): boolean;
+    /**
+     * Compares whether this date is same year as provided date
+     * @param date - Date which is used for comparison of same year
+     */
+    isSameYear(date: TDate): boolean;
+    /**
+     * Compares whether this date is same month as provided date
+     * @param date - Date which is used for comparison of same month
+     */
+    isSameMonth(date: TDate): boolean;
+    /**
+     * Compares whether this date is same day as provided date
+     * @param date - Date which is used for comparison of same day
+     */
+    isSameDay(date: TDate): boolean;
+    /**
+     * Creates clone of this instance, value and originalValue have same value and are cloned from value
+     */
+    clone(): DateApiObject<TDate>;
+    /**
+     * Creates clone of this instance, value and originalValue have same value and are cloned from originalValue
+     */
+    cloneOriginal(): DateApiObject<TDate>;
+    /**
+     * Updates originalValue, if value is not provided originalValue is set to value
+     * @param value - Value to be set as original, or null (value will be used as value)
+     * @returns Itself for fluent API
+     */
+    updateOriginal(value?: TDate): DateApiObject<TDate>;
+    /**
+     * Changes value to same value as originalValue
+     * @returns Itself for fluent API
+     */
+    resetOriginal(): DateApiObject<TDate>;
+}
+
+/**
+ * Pipe that is used for converting date
+ */
+export declare class DateConvertPipe<TDate = any> implements PipeTransform {
+    private _dateApi;
+    constructor(_dateApi: DateApi<TDate>);
+    /**
+     * Transforms value into date object
+     * @param value - value to be transformed
+     * @param parseFormat - format used for parsing string date
+     */
+    transform(value: TDate | DateValue, parseFormat?: string): TDate | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateConvertPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateConvertPipe<any>, "dateConvert">;
+}
+
+/**
+ * Pipe that is used for formatting date
+ */
+export declare class DateFormatPipe<TDate = any> implements PipeTransform {
+    private _formatProvider;
+    private _dateApi;
+    constructor(_formatProvider: FormatProvider, _dateApi: DateApi<TDate>);
+    /**
+     * Formats provided date into formatted string
+     * @param value - value to be transformed
+     * @param format - Format that is used for formatting, can be also 'FormatProvider' key
+     * @param parseFormat - format used for parsing string date
+     */
+    transform(value: TDate | DateValue, format?: string | keyof FormatProvider, parseFormat?: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFormatPipe<any>, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<DateFormatPipe<any>, "dateFormat">;
+}
+
+/**
+ * Module used for exporting date pipes
+ */
+export declare class DatePipesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePipesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DatePipesModule, [typeof i1_4.AsRequiredTypePipe, typeof i2_3.DateFormatPipe, typeof i3_3.DateConvertPipe], never, [typeof i1_4.AsRequiredTypePipe, typeof i2_3.DateFormatPipe, typeof i3_3.DateConvertPipe]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DatePipesModule>;
+}
+
+/**
+ * Parser used for parsing date using provided format and returning positions and selected date part
+ */
+export declare interface DatePositionParser {
+    /**
+     * Parse date as string and returns information about positions and selected part of date
+     * @param date - String date to be parsed
+     * @param cursorPosition - Current cursor position
+     */
+    parse(date: string, cursorPosition: number): DatePositionParserResult;
+    /**
+     * Parse date as string and returns information about position and selected part of date, while moving it to next part, if it was last part returns null
+     * @param date - String date to be parsed
+     * @param cursorPosition - Current cursor position
+     */
+    next(date: string, cursorPosition: number): null | DatePositionParserResult;
+    /**
+     * Parse date as string and returns information about position and selected part of date, while moving it to previous part, if it was first part returns null
+     * @param date - String date to be parsed
+     * @param cursorPosition - Current cursor position
+     */
+    previous(date: string, cursorPosition: number): null | DatePositionParserResult;
+}
+
+/**
+ * Result of date position parsing
+ */
+export declare interface DatePositionParserResult {
+    /**
+     * Index of charater where returned part of date starts
+     */
+    positionFrom: number;
+    /**
+     * Index of charater where returned part of date ends
+     */
+    positionTo: number;
+    /**
+     * Type of part that is selected
+     */
+    part: string;
+}
+
+/**
+ * Service used for parsing date
+ */
+export declare class DatePositionParserService {
+    /**
+     * Creates parser instance for specified format
+     * @param format - Format to be used for parsing date string
+     */
+    createParser(format: string): DatePositionParser;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatePositionParserService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatePositionParserService>;
+}
+
+/**
+ * Angular module for date time basic input selector component
+ */
+export declare class DateTimeBasicSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeBasicSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DateTimeBasicSelectorModule, [typeof i1.SimpleInputDateTimeSelectorComponent], never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DateTimeBasicSelectorModule>;
+}
+
+/**
+ * Component used for displaying day picker
+ */
+export declare class DateTimeDayPickerComponent<TDate = any> extends PickerBaseComponent<TDate, DayData<TDate>, DayPickerCssClasses> implements DateTimePicker<TDate, DayPickerCssClasses> {
+    /**
+     * Stored this picker month data
+     */
+    protected _thisMonthData: DayData<TDate>[];
+    /**
+     * Names of days
+     * @internal
+     */
+    weekdays: string[];
+    constructor(dateApi: DateApi<TDate>, changeDetector: ChangeDetectorRef);
+    /**
+     * Changes displayed month to next month
+     * @param event - Event that occured
+     * @internal
+     */
+    nextMonth(event: Event): void;
+    /**
+     * Changes displayed month to previous month
+     * @param event - Event that occured
+     * @internal
+     */
+    previousMonth(event: Event): void;
+    /**
+     * Selects day
+     * @param event - Event that occured
+     * @param day - Selects day
+     * @internal
+     */
+    select(event: Event, day: DayData<TDate>): void;
+    /**
+     * Set displays date to be displayed
+     * @param value - Value that identifies period that is going to be displayed
+     */
+    display(value: DateApiObject<TDate>): void;
+    /**
+     * Obtains end of period
+     * @param period - Period for which should be end obtained
+     */
+    protected _endOfPeriod(period: PeriodData<TDate>): TDate;
+    /**
+     * Tests whether provided value is in same period as displayed picker
+     * @param val - Tested value for same period as displayed picker
+     */
+    protected _isSamePeriodAsDisplayed(val: DateApiObject<TDate>): boolean;
+    /**
+     * Tests whether provided value is in same period target value
+     * @param val - Tested value
+     * @param target - Target value to be tested against
+     */
+    protected _isSamePeriod(val: DateApiObject<TDate>, target: TDate): boolean;
+    /**
+     * Gets period data for specified value
+     * @param val - Value for which is period data obtained
+     */
+    protected _getPeriodData(val: DateApiObject<TDate>): PeriodData<TDate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeDayPickerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeDayPickerComponent<any>, "date-time-day-picker", never, {}, {}, never, never>;
+}
+
+/**
+ * Directive injecting datetime max validator, validating max datetime value
+ */
+export declare class DatetimeMaxValidatorDirective<TDate = any> implements Validator {
+    /**
+     * Function used for validations
+     */
+    private _validator;
+    constructor(datetimeSelector: DateTimeSelectorComponent<TDate>, dateApi: DateApi<TDate>);
+    /**
+     * Validates input and returns validation result
+     * @param control - Control that is being validated
+     * @returns validation results
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimeMaxValidatorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatetimeMaxValidatorDirective<any>, "date-time-selector[validate][maxValue][formControlName]:not([range]),date-time-selector[validate][maxValue][formControl]:not([range]),date-time-selector[validate][maxValue][ngModel]:not([range])", never, {}, {}, never>;
+}
+
+/**
+ * Directive injecting datetime min validator, validating min datetime value
+ */
+export declare class DatetimeMinValidatorDirective<TDate = any> implements Validator {
+    /**
+     * Function used for validations
+     */
+    private _validator;
+    constructor(datetimeSelector: DateTimeSelectorComponent<TDate>, dateApi: DateApi<TDate>);
+    /**
+     * Validates input and returns validation result
+     * @param control - Control that is being validated
+     * @returns validation results
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimeMinValidatorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatetimeMinValidatorDirective<any>, "date-time-selector[validate][minValue][formControlName]:not([range]),date-time-selector[validate][minValue][formControl]:not([range]),date-time-selector[validate][minValue][ngModel]:not([range])", never, {}, {}, never>;
+}
+
+/**
+ * Component used for displaying month picker
+ */
+export declare class DateTimeMonthPickerComponent<TDate = any> extends PickerBaseComponent<TDate, MonthData<TDate>, MonthPickerCssClasses> implements DateTimePicker<TDate, MonthPickerCssClasses> {
+    constructor(dateApi: DateApi<TDate>, changeDetector: ChangeDetectorRef);
+    /**
+     * Changes displayed year to next year
+     * @param event - Event that occured
+     * @internal
+     */
+    nextYear(event: Event): void;
+    /**
+     * Changes displayed year to previous year
+     * @param event - Event that occured
+     * @internal
+     */
+    previousYear(event: Event): void;
+    /**
+     * Set displays date to be displayed
+     * @param value - Value that identifies period that is going to be displayed
+     */
+    display(value: DateApiObject<TDate>): void;
+    /**
+     * Obtains end of period
+     * @param period - Period for which should be end obtained
+     */
+    protected _endOfPeriod(period: PeriodData<TDate>): TDate;
+    /**
+     * Tests whether provided value is in same period as displayed picker
+     * @param val - Tested value for same period as displayed picker
+     */
+    protected _isSamePeriodAsDisplayed(val: DateApiObject<TDate>): boolean;
+    /**
+     * Tests whether provided value is in same period target value
+     * @param val - Tested value
+     * @param target - Target value to be tested against
+     */
+    protected _isSamePeriod(val: DateApiObject<TDate>, target: TDate): boolean;
+    /**
+     * Gets period data for specified value
+     * @param val - Value for which is period data obtained
+     */
+    protected _getPeriodData(val: DateApiObject<TDate>): PeriodData<TDate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeMonthPickerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeMonthPickerComponent<any>, "date-time-month-picker", never, {}, {}, never, never>;
+}
+
+/**
+ * Describes datetime picker component used for displaying and selecting value
+ */
+export declare interface DateTimePicker<TDate = any, TCssClasses = object> {
+    /**
+     * Gets current value of datetime
+     */
+    readonly value: DateTimeValue<TDate> | null;
+    /**
+     * Occurs when value changes
+     */
+    readonly valueChange: Observable<void>;
+    /**
+     * Occurs when user scales up
+     */
+    readonly scaleUp: Observable<TDate>;
+    /**
+     * Occurs when user scales down
+     */
+    readonly scaleDown: Observable<TDate>;
+    /**
+     * Sets css classes for picker, allowing to override defaults
+     * @param cssClasses - Css classes to be set for picker
+     */
+    setCssClasses(cssClasses: TCssClasses): void;
+    /**
+     * Sets minimal possible value for picker, that can be picked
+     * @param value - Minimal possible value that can be picked
+     */
+    setMinValue(value: TDate | null): void;
+    /**
+     * Sets maximal possible value for picker, that can be picked
+     * @param value - Maximal possible value that can be picked
+     */
+    setMaxValue(value: TDate | null): void;
+    /**
+     * Sets value of datetime picker
+     * @param value - Value to be set to this picker
+     */
+    setValue(value: DateTimeValue<TDate> | null): void;
+    /**
+     * Set displays date to be displayed
+     * @param value - Value that identifies period that is going to be displayed
+     */
+    display(value: DateApiObject<TDate>): void;
+    /**
+     * Sets indication whether can go down
+     * @param value - Indication whether can go down in period
+     */
+    setCanGoDown(value: boolean): void;
+    /**
+     * Sets indication whether can go up
+     * @param value - Indication whether can go up in period
+     */
+    setCanGoUp(value: boolean): void;
+    /**
+     * Explicitly runs invalidation of content (change detection)
+     */
+    invalidateVisuals(): void;
+}
+
+/**
+ * Component used for displaying date time picker
+ */
+export declare class DateTimePickerComponent<TDate = any> implements OnInit, OnDestroy {
+    protected _dateApi: DateApi<TDate>;
+    protected _changeDetector: ChangeDetectorRef;
+    /**
+     * Instance of active date time picker
+     */
+    protected _activePicker?: DateTimePicker<TDate>;
+    /**
+     * Name, id of displayed picker
+     */
+    protected _activePickerName: string;
+    /**
+     * Array of available picker names
+     */
+    protected _pickerNames: string[];
+    /**
+     * Current selected value
+     */
+    protected _value: DateTimeValue<TDate> | null;
+    /**
+     * All subscriptions for active picker
+     */
+    protected _activePickerSubscriptions: Subscription;
+    /**
+     * Date that should be displayed in picker, used when moving up or down in periods
+     */
+    protected _display?: TDate;
+    /**
+     * Minimal possible value that can be picked
+     */
+    protected _minValue: TDate | null;
+    /**
+     * Maximal possible value that can be picked
+     */
+    protected _maxValue: TDate | null;
+    /**
+     * Current options used by picker
+     */
+    protected _options: DateTimePickerOptions<DateTimePicker<TDate>>;
+    /**
+     * Currently active date time picker component type
+     * @internal
+     */
+    activePickerComponent?: Type<DateTimePicker<TDate>>;
+    /**
+     * Active picker index
+     * @internal
+     */
+    activePickerIndex: number;
+    /**
+     * Current options used by picker
+     */
+    get options(): DateTimePickerOptions<DateTimePicker<TDate>>;
+    set options(value: DateTimePickerOptions<DateTimePicker<TDate>>);
+    /**
+     * Current selected value
+     */
+    get value(): DateTimeValue<TDate> | null;
+    set value(value: DateTimeValue<TDate> | null);
+    /**
+     * Gets or sets minimal possible value for picker, that can be picked
+     */
+    get minValue(): TDate | null;
+    set minValue(value: TDate | null);
+    /**
+     * Gets or sets maximal possible value for picker, that can be picked
+     */
+    get maxValue(): TDate | null;
+    set maxValue(value: TDate | null);
+    /**
+     * Occurs when value changes
+     */
+    valueChange: EventEmitter<DateTimeValue<TDate>>;
+    constructor(configuration: DateTimePickerOptions<DateTimePicker<TDate>>, _dateApi: DateApi<TDate>, _changeDetector: ChangeDetectorRef);
+    /**
+     * Initialize component
+     */
+    ngOnInit(): void;
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handles created or destroyed date time picker instance
+     * @param picker - Instance of picker or null
+     * @internal
+     */
+    pickerCreated(picker: DateTimePicker<TDate>): void;
+    /**
+     * Sets picker css classes
+     */
+    protected _setPickerCssClasses(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimePickerComponent<any>, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimePickerComponent<any>, "date-time-picker", never, { "options": "options"; "value": "value"; "minValue": "minValue"; "maxValue": "maxValue"; }, { "valueChange": "valueChange"; }, never, never>;
+}
+
+/**
+ * Css classes applied to datetime picker
+ */
+export declare interface DateTimePickerCssClasses {
+    /**
+     * Shared css classes for all pickers
+     */
+    pickerShared?: CommonPickerCssClasses;
+    /**
+     * Custom css classes specific for each picker type
+     */
+    pickerCustom?: Dictionary<object>;
+}
+
+/**
+ * Angular module for date time picker components
+ */
+export declare class DateTimePickerModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimePickerModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DateTimePickerModule, [typeof i1_3.DateTimePickerComponent, typeof i2_2.DateTimeDayPickerComponent, typeof i3_2.DateTimeMonthPickerComponent, typeof i4_2.DateTimeYearPickerComponent], [typeof i7.CommonModule, typeof i8.CommonDynamicModule, typeof i7_2.DatePipesModule], [typeof i1_3.DateTimePickerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DateTimePickerModule>;
+}
+
+/**
+ * Defintion of datetime picker component options
+ */
+export declare interface DateTimePickerOptions<TPicker = any> {
+    /**
+     * Order of pickers, it's possible use less pickers as is defined in pickerPeriodsDefinition for example 'month,year'
+     */
+    pickerPeriodsOrder?: string[] | string;
+    /**
+     * Definition of types for each period type for picker
+     */
+    pickerPeriodsDefinition?: Dictionary<Type<TPicker>>;
+    /**
+     * Name of default period for picker that is displayed
+     */
+    defaultPeriod?: string;
+    /**
+     * Css classes for date time picker
+     */
+    cssClasses?: DateTimePickerCssClasses;
+}
+
+/**
+ * Service used for parsing relative date time strings
+ */
+export declare class DateTimeRelativeParser<TDate = any> {
+    protected _injector: Injector;
+    /**
+     * Date api for handling
+     */
+    protected _dateApi?: DateApi<TDate>;
+    constructor(_injector: Injector);
+    /**
+     * Tries to parse relative value and returns parsed TDate, otherwise returns input value
+     * @param value - Value to be parsed
+     */
+    parse(value: TDate | DateValue): TDate | DateValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeRelativeParser<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateTimeRelativeParser<any>>;
+}
+
+/**
+ * Describes datetime selector component used for displaying and selecting value
+ */
+export declare interface DateTimeSelector<TDate = any> {
+    /**
+     * Currently used format for displaying data
+     */
+    format: string;
+    /**
+     * Placeholder that is displayed when there is no value selected
+     */
+    placeholder?: string;
+    /**
+     * Gets current value of datetime
+     */
+    readonly value: DateTimeValue<TDate> | null;
+    /**
+     * Gets formatted value
+     */
+    readonly formattedValue: string | null;
+    /**
+     * Gets indication whether is current value valid
+     */
+    readonly valid: boolean;
+    /**
+     * Occurs when value changes
+     */
+    readonly valueChange: Observable<void>;
+    /**
+     * Occurs when selector is touched by user
+     */
+    readonly touched: Observable<void>;
+    /**
+     * Occurs when selector requires picker to be displayed or hidden
+     */
+    readonly pickerRequest: Observable<boolean>;
+    /**
+     * Sets minimal possible value for picker, that can be picked
+     * @param value - Minimal possible value that can be picked
+     */
+    setMinValue(value: TDate | null): void;
+    /**
+     * Sets maximal possible value for picker, that can be picked
+     * @param value - Maximal possible value that can be picked
+     */
+    setMaxValue(value: TDate | null): void;
+    /**
+     * Sets value of datetime selector
+     * @param value - Value to be set to this selector
+     */
+    setValue(value: DateTimeValue<TDate> | null): void;
+    /**
+     * Sets as 'control' disabled
+     * @param disabled - Indication whether sets value as disabled, if omitted it is same as disabled set to true
+     */
+    setDisabled(disabled?: boolean): void;
+    /**
+     * Explicitly runs invalidation of content (change detection)
+     */
+    invalidateVisuals(): void;
+}
+
+/**
+ * Component used for displaying and selecting date time
+ */
+export declare class DateTimeSelectorComponent<TDate = any> implements OnInit, OnChanges, OnDestroy {
+    protected _valueProvider: DateValueProvider<TDate>;
+    protected _changeDetector: ChangeDetectorRef;
+    protected _dateApi: DateApi<TDate>;
+    /**
+     * Current value of datetime
+     */
+    protected _value: DateTimeValue<TDate> | null;
+    /**
+     * Occurs when selector is touched by user
+     */
+    protected _touched: Subject<void>;
+    /**
+     * Occurs when value changes
+     */
+    protected _valueChange: Subject<void>;
+    /**
+     * Indication whether is control disabled
+     */
+    protected _disabled: boolean;
+    /**
+     * Instance of active date time selector
+     */
+    protected _activeSelector?: DateTimeSelector<TDate>;
+    /**
+     * All subscriptions for active selector
+     */
+    protected _activeSelectorSubscriptions: Subscription;
+    /**
+     * Subscription for changes of min value selector
+     */
+    protected _minValueChangeSubscription: Subscription | null;
+    /**
+     * Subscription for changes of max value selector
+     */
+    protected _maxValueChangeSubscription: Subscription | null;
+    /**
+     * Current options used by selector
+     */
+    protected _options: DateTimeSelectorOptions<DateTimeSelector<TDate>>;
+    /**
+     * Placeholder that is displayed when there is no value selected
+     */
+    protected _placeholder?: string;
+    /**
+     * Gets or sets current value of datetime
+     */
+    get value(): DateTimeValue<TDate> | null;
+    set value(value: DateTimeValue<TDate> | null);
+    /**
+     * Gets indication whether is current value valid
+     */
+    get valid(): boolean;
+    /**
+     * Gets or sets formatted value
+     */
+    get formattedValue(): string | null;
+    set formattedValue(value: string | null);
+    /**
+     * Occurs when selector is touched by user
+     */
+    get touched(): Observable<void>;
+    /**
+     * Occurs when value changes
+     */
+    get valueChange(): Observable<void>;
+    /**
+     * Currently active date time selector component type
+     * @internal
+     */
+    activeSelectorComponent?: Type<DateTimeSelector<TDate>>;
+    /**
+     * Indication whether is picker visible or not
+     * @internal
+     */
+    pickerVisible: boolean;
+    /**
+     * Gets or sets minimal possible value for picker, that can be picked
+     */
+    min: TDate | null;
+    /**
+     * Gets or sets maximal possible value for picker, that can be picked
+     */
+    max: TDate | null;
+    /**
+     * Format of displayed
+     */
+    format: string;
+    /**
+     * Gets or sets placeholder that is displayed when there is no value selected
+     */
+    get placeholder(): string | undefined;
+    set placeholder(value: string | undefined);
+    /**
+     * Current options used by selector
+     */
+    get options(): DateTimeSelectorOptions<DateTimeSelector<TDate>>;
+    set options(value: DateTimeSelectorOptions<DateTimeSelector<TDate>>);
+    /**
+     * Gets or sets minimal possible value for picker, that can be picked
+     */
+    get minValue(): TDate | string | null | DateTimeSelectorComponent<TDate>;
+    set minValue(value: TDate | string | null | DateTimeSelectorComponent<TDate>);
+    /**
+     * Gets or sets maximal possible value for picker, that can be picked
+     */
+    get maxValue(): TDate | string | null | DateTimeSelectorComponent<TDate>;
+    set maxValue(value: TDate | string | null | DateTimeSelectorComponent<TDate>);
+    constructor(configuration: DateTimeSelectorOptions<DateTimeSelector<TDate>>, _valueProvider: DateValueProvider<TDate>, _changeDetector: ChangeDetectorRef, _dateApi: DateApi<TDate>, formatProvider: FormatProvider);
+    /**
+     * Initialize component
+     */
+    ngOnInit(): void;
+    /**
+     * Called when input value changes
+     */
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Handles created or destroyed date time selector instance
+     * @param selector - Instance of selector or null
+     * @internal
+     */
+    selectorCreated(selector: DateTimeSelector<TDate>): void;
+    /**
+     * Handles changed value by picker
+     * @param value - Value that was changed
+     * @internal
+     */
+    pickerChangedValue(value: DateTimeValue<TDate>): void;
+    /**
+     * Sets as 'control' disabled
+     * @param disabled - Indication whether sets value as disabled, if omitted it is same as disabled set to true
+     */
+    setDisabled(disabled?: boolean): void;
+    /**
+     * Gets simple value of selector
+     */
+    valueOf(): TDate | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeSelectorComponent<any>, [{ optional: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeSelectorComponent<any>, "date-time-selector", never, { "format": "format"; "placeholder": "placeholder"; "options": "options"; "minValue": "minValue"; "maxValue": "maxValue"; }, {}, never, never>;
+}
+
+/**
+ * Value accessor for getting and setting values for date time selector
+ */
+export declare class DateTimeSelectorControlValueAccessor<TDate> implements ControlValueAccessor, OnDestroy {
+    protected _selector: DateTimeSelectorComponent<TDate>;
+    /**
+     * Subscriptions that are destroyed on directive destruction
+     */
+    protected _subscriptions: Subscription;
+    /**
+     * Indication whether value for selector is represented as range from, to
+     */
+    range: boolean;
+    /**
+     * Indication whether value for selector is represented as formatted string value, if both 'formatted' and 'range' are set, 'range' takes precedence
+     */
+    formatted: boolean;
+    constructor(_selector: DateTimeSelectorComponent<TDate>);
+    /**
+     * Called when component is destroyed
+     */
+    ngOnDestroy(): void;
+    /**
+     * Sets value to datetime selector
+     */
+    writeValue(value: string | DateTimeValue<TDate> | TDate | null): void;
+    /**
+     * Registers callback that is called when value of datetime selector value changes
+     */
+    registerOnChange(fn: (data: string | DateTimeValue<TDate> | TDate | null) => any): void;
+    /**
+     * Registers callback that is called when datetime selector was touched by user
+     */
+    registerOnTouched(fn: () => any): void;
+    /**
+     * Used for setting control as disabled
+     * @param isDisabled - disabled status to set on the element
+     */
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * Used for emitting value that was changed
+     * @param fn - Function that is used for emitting changed value
+     */
+    protected _emitValue(fn: (value: string | DateTimeValue<TDate> | TDate | null) => any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeSelectorControlValueAccessor<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DateTimeSelectorControlValueAccessor<any>, "date-time-selector[formControlName],date-time-selector[formControl],date-time-selector[ngModel]", never, { "range": "range"; "formatted": "formatted"; }, {}, never>;
+}
+
+/**
+ * Angular module for date time selector components
+ */
+export declare class DateTimeSelectorModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeSelectorModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DateTimeSelectorModule, [typeof i1_2.DateTimeSelectorComponent, typeof i2.InputDateTimeSelectorComponent, typeof i3.DateTimeSelectorControlValueAccessor, typeof i4.DatetimeValidatorDirective, typeof i5.DatetimeMinValidatorDirective, typeof i6.DatetimeMaxValidatorDirective], [typeof i7.CommonModule, typeof i8.CommonDynamicModule, typeof i9.DateTimePickerModule], [typeof i1_2.DateTimeSelectorComponent, typeof i3.DateTimeSelectorControlValueAccessor, typeof i4.DatetimeValidatorDirective, typeof i5.DatetimeMinValidatorDirective, typeof i6.DatetimeMaxValidatorDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DateTimeSelectorModule>;
+}
+
+/**
+ * Defintion of datetime selector component options
+ */
+export declare interface DateTimeSelectorOptions<TSelector = any, TPicker = any> extends DateTimePickerOptions<TPicker> {
+    /**
+     * Definition of type that is used for selector
+     */
+    selectorComponent: Type<TSelector>;
+    /**
+     * Indication whether close picker on value selection
+     */
+    pickerCloseOnValueSelect?: boolean;
+    /**
+     * Indication whether picker is disabled
+     */
+    pickerDisabled?: boolean;
+}
+
+/**
+ * Directive injecting datetime validator, validating datetime
+ */
+export declare class DatetimeValidatorDirective<TDate = any> implements Validator {
+    /**
+     * Function used for validations
+     */
+    private _validator;
+    constructor(datetimeSelector: DateTimeSelectorComponent<TDate>);
+    /**
+     * Validates input and returns validation result
+     * @param control - Control that is being validated
+     * @returns validation results
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatetimeValidatorDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatetimeValidatorDirective<any>, "date-time-selector[validate][formControlName]:not([range]),date-time-selector[validate][formControl]:not([range]),date-time-selector[validate][ngModel]:not([range])", never, {}, {}, never>;
+}
+
+/**
+ * Represents datetime value as period
+ */
+export declare interface DateTimeValue<TDate = any> {
+    /**
+     * Starting date and time of period
+     */
+    from: TDate;
+    /**
+     * Ending date and time of period
+     */
+    to: TDate;
+}
+
+/**
+ * Represents object that holds data for indentification of validity of date time
+ */
+export declare interface DateTimeValueObject<TDate = any> {
+    /**
+     * Current value of datetime
+     */
+    readonly value: DateTimeValue<TDate> | null;
+    /**
+     * Indicaiton whether is current value valid, empty value is valid
+     */
+    readonly valid: boolean;
+    /**
+     * Minimal possible value, that can be
+     */
+    readonly minValue: TDate | null;
+    /**
+     * Maximal possible value, that can be
+     */
+    readonly maxValue: TDate | null;
+}
+
+/**
+ * Component used for displaying year picker
+ */
+export declare class DateTimeYearPickerComponent<TDate = any> extends PickerBaseComponent<TDate, YearData<TDate>, YearPickerCssClasses> implements DateTimePicker<TDate, YearPickerCssClasses> {
+    /**
+     * Displayed decade period
+     * @internal
+     */
+    period: string;
+    constructor(dateApi: DateApi<TDate>, changeDetector: ChangeDetectorRef);
+    /**
+     * Changes displayed decade to next decade
+     * @param event - Event that occured
+     * @internal
+     */
+    nextDecade(event: Event): void;
+    /**
+     * Changes displayed decade to previous decade
+     * @param event - Event that occured
+     * @internal
+     */
+    previousDecade(event: Event): void;
+    /**
+     * Set displays date to be displayed
+     * @param value - Value that identifies period that is going to be displayed
+     */
+    display(value: DateApiObject<TDate>): void;
+    /**
+     * Obtains end of period
+     * @param period - Period for which should be end obtained
+     */
+    protected _endOfPeriod(period: PeriodData<TDate>): TDate;
+    /**
+     * Tests whether provided value is in same period as displayed picker
+     * @param val - Tested value for same period as displayed picker
+     */
+    protected _isSamePeriodAsDisplayed(val: DateApiObject<TDate>): boolean;
+    /**
+     * Tests whether provided value is in same period target value
+     * @param val - Tested value
+     * @param target - Target value to be tested against
+     */
+    protected _isSamePeriod(val: DateApiObject<TDate>, target: TDate): boolean;
+    /**
+     * Gets period data for specified value
+     * @param val - Value for which is period data obtained
+     */
+    protected _getPeriodData(val: DateApiObject<TDate>): PeriodData<TDate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateTimeYearPickerComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateTimeYearPickerComponent<any>, "date-time-year-picker", never, {}, {}, never, never>;
+}
+
+/**
+ * Date can be represented as formatted string, timestamp or javascript Date object
+ */
+export declare type DateValue = Date | string | number;
+
+/**
+ * Class used for obtaining DateTimeValue for various formats
+ */
+export declare class DateValueProvider<TDate = any> {
+    protected _dateApi: DateApi<TDate>;
+    constructor(_dateApi: DateApi<TDate>);
+    /**
+     * Gets DateTimeValue from single value based on format
+     * @param value - Current value to be converted to ranged value
+     * @param format - Format that is requested to be displayed, it tells what range should be created
+     */
+    getValue(value: TDate, format: string): DateTimeValue<TDate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateValueProvider<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DateValueProvider<any>>;
+}
+
+/**
+ * Represents day component of datetime
+ */
+export declare const DAY = "day";
+
+/**
+ * Data that represents day in date picker
+ */
+export declare interface DayData<TDate = any> extends PeriodData<TDate> {
+    /**
+     * Indication that range is selected and this day is between selected dates
+     */
+    betweenActive: boolean;
+    /**
+     * Indication that this day is out of currently selected month
+     */
+    otherMonth: boolean;
+    /**
+     * Indication that this day is today
+     */
+    today: boolean;
+    /**
+     * Indication that this day is weekend day
+     */
+    weekend: boolean;
+    /**
+     * Day number of month
+     */
+    day: number;
+}
+
+/**
+ * Specific css classes for day picker
+ */
+export declare interface DayPickerCssClasses extends CommonPickerCssClasses {
+    /**
+     * Element displaying weekday name
+     */
+    weekdayName?: string;
+}
+
+/**
+ * Represents decade component of datetime
+ */
+export declare const DECADE = "decade";
+
+/**
+ * Default implementation of DatePositionParser
+ */
+export declare class DefaultDatePositionParser implements DatePositionParser {
+    protected _format: string;
+    /**
+     * Indication whether format contains separators
+     */
+    protected _hasSeparator: boolean;
+    /**
+     * Array of date parts of parsed date format
+     */
+    protected _datePartsIndexes: string[];
+    /**
+     * Object storing indexes for strict date parts of parsed date format
+     */
+    protected _strictDatePartsIndexes: {
+        [index: number]: {
+            part: string;
+            length: number;
+        };
+    };
+    constructor(_format: string);
+    /**
+     * Parse date as string and returns information about position and selected part of date, while moving it to next part, if it was last part returns null
+     * @param date - String date to be parsed
+     * @param cursorPosition - Current cursor position
+     */
+    next(date: string, cursorPosition: number): null | DatePositionParserResult;
+    /**
+     * Parse date as string and returns information about position and selected part of date, while moving it to previous part, if it was first part returns null
+     * @param date - String date to be parsed
+     * @param cursorPosition - Current cursor position
+     */
+    previous(date: string, cursorPosition: number): null | DatePositionParserResult;
+    /**
+     * Parse date as string and returns information about positions and selected part of date
+     * @param date - String date to be parsed
+     * @param cursorPosition - Current cursor position
+     */
+    parse(date: string, cursorPosition: number): DatePositionParserResult;
+    /**
+     * Initialize parser, process format
+     */
+    protected _initialize(): void;
+}
+
+/**
+ * Animation trigger for animating children on enter leave
+ */
+export declare const enterLeaveAnimateChildTrigger: AnimationTriggerMetadata;
+
+/**
+ * Injection token used for obtaining FormatProvider implementation
+ */
+export declare const FORMAT_PROVIDER: InjectionToken<FormatProvider>;
+
+/**
+ * Format provider used for obtaining some special formats 'placeholders'
+ */
+export declare interface FormatProvider {
+    /**
+     * Format placeholder for displaying date
+     */
+    readonly date: string;
+    /**
+     * Format placeholder for displaying date and time
+     */
+    readonly dateTime: string;
+    /**
+     * Format placeholder for displaying time
+     */
+    readonly time: string;
+}
+
+/**
+ * Represents hour component of datetime
+ */
+export declare const HOUR = "hour";
+
+declare namespace i1 {
+    export {
+        SimpleInputDateTimeSelectorComponent
+    }
+}
+
+declare namespace i1_2 {
+    export {
+        DateTimeSelectorComponent
+    }
+}
+
+declare namespace i1_3 {
+    export {
+        DateTimePickerComponent
+    }
+}
+
+declare namespace i1_4 {
+    export {
+        NgClassType,
+        AsRequiredTypePipe
+    }
+}
+
+declare namespace i2 {
+    export {
+        InputDateTimeSelectorComponent
+    }
+}
+
+declare namespace i2_2 {
+    export {
+        DateTimeDayPickerComponent
+    }
+}
+
+declare namespace i2_3 {
+    export {
+        DateFormatPipe
+    }
+}
+
+declare namespace i3 {
+    export {
+        DateTimeSelectorControlValueAccessor
+    }
+}
+
+declare namespace i3_2 {
+    export {
+        DateTimeMonthPickerComponent
+    }
+}
+
+declare namespace i3_3 {
+    export {
+        DateConvertPipe
+    }
+}
+
+declare namespace i4 {
+    export {
+        DatetimeValidatorDirective
+    }
+}
+
+declare namespace i4_2 {
+    export {
+        DateTimeYearPickerComponent
+    }
+}
+
+declare namespace i5 {
+    export {
+        DatetimeMinValidatorDirective
+    }
+}
+
+declare namespace i6 {
+    export {
+        DatetimeMaxValidatorDirective
+    }
+}
+
+declare namespace i7_2 {
+    export {
+        DatePipesModule
+    }
+}
+
+declare namespace i9 {
+    export {
+        DateTimePickerModule
+    }
+}
+
+/**
+ * Component used as datetime selector with input
+ */
+export declare class InputDateTimeSelectorComponent<TDate = any> implements DateTimeSelector<TDate> {
+    protected _dateApi: DateApi<TDate>;
+    protected _parserSvc: DatePositionParserService;
+    protected _valueProvider: DateValueProvider<TDate>;
+    protected _changeDetector: ChangeDetectorRef;
+    /**
+     * Occurs when value changes
+     */
+    protected _valueChange: Subject<void>;
+    /**
+     * Occurs when selector is touched by user
+     */
+    protected _touched: Subject<void>;
+    /**
+     * Occurs when selector requires picker to be displayed or hidden
+     */
+    protected _pickerRequest: Subject<boolean>;
+    /**
+     * Instance of parser created for specific format
+     */
+    protected _parser: DatePositionParser | null;
+    /**
+     * Currently used format for displaying data
+     */
+    protected _format: string;
+    /**
+     * Current value representation as date api wrapper
+     */
+    protected _dateApiValue: null | DateApiObject<TDate>;
+    /**
+     * Indication whether is current value valid value
+     */
+    protected _isValid: boolean;
+    /**
+     * Minimal possible value that can be picked
+     */
+    protected _minValue: TDate | null;
+    /**
+     * Maximal possible value that can be picked
+     */
+    protected _maxValue: TDate | null;
+    /**
+     * Gets or sets currently used format for displaying data
+     */
+    get format(): string;
+    set format(value: string);
+    /**
+     * Gets or sets placeholder that is displayed when there is no value selected
+     */
+    placeholder: string | undefined;
+    /**
+     * Gets current value of datetime
+     */
+    get value(): DateTimeValue<TDate> | null;
+    /**
+     * Gets formatted value
+     */
+    get formattedValue(): string | null;
+    /**
+     * Gets indication whether is current value valid
+     */
+    get valid(): boolean;
+    /**
+     * Occurs when value changes
+     */
+    get valueChange(): Observable<void>;
+    /**
+     * Occurs when selector is touched by user
+     */
+    get touched(): Observable<void>;
+    /**
+     * Occurs when selector requires picker to be displayed
+     */
+    get pickerRequest(): Observable<boolean>;
+    /**
+     * Indication whether is input disabled
+     * @internal
+     */
+    disabled: boolean;
+    /**
+     * Instance of html input element
+     * @internal
+     */
+    inputElement?: ElementRef<HTMLInputElement>;
+    /**
+     * Gets or sets string representation current of value
+     */
+    protected get currentValue(): string | null;
+    protected set currentValue(value: string | null);
+    /**
+     * Gets input element used for handling date time value
+     */
+    protected get input(): HTMLInputElement;
+    constructor(_dateApi: DateApi<TDate>, _parserSvc: DatePositionParserService, _valueProvider: DateValueProvider<TDate>, _changeDetector: ChangeDetectorRef);
+    /**
+     * Sets minimal possible value for picker, that can be picked
+     * @param value - Minimal possible value that can be picked
+     */
+    setMinValue(value: TDate | null): void;
+    /**
+     * Sets maximal possible value for picker, that can be picked
+     * @param value - Maximal possible value that can be picked
+     */
+    setMaxValue(value: TDate | null): void;
+    /**
+     * Sets value of datetime selector
+     * @param value - Value to be set to this selector
+     */
+    setValue(value: DateTimeValue<TDate> | null): void;
+    /**
+     * Sets as 'control' disabled
+     * @param disabled - Indication whether sets value as disabled, if omitted it is same as disabled set to true
+     */
+    setDisabled(disabled?: boolean): void;
+    /**
+     * Explicitly runs invalidation of content (change detection)
+     */
+    invalidateVisuals(): void;
+    /**
+     * Handles gaining of focus
+     * @internal
+     */
+    handleFocus(): void;
+    /**
+     * Handles blur on input
+     * @internal
+     */
+    handleBlur(): void;
+    /**
+     * Handles user input
+     * @internal
+     */
+    handleInput(): void;
+    /**
+     * Handles selection of text inside of input
+     * @internal
+     */
+    handleSelect(): void;
+    /**
+     * Handles click event inside of input
+     * @internal
+     */
+    handleClick(): void;
+    /**
+     * Handles keyboard events
+     * @param event - Keyboard event that occured
+     * @param input - Html input element that holds current value and selection
+     * @internal
+     */
+    handleKeyboard(event: KeyboardEvent): void;
+    /**
+     * Shows current value in input
+     */
+    protected _show(): void;
+    /**
+     * Tests whether are min or max constraint broken, returns true if constraint is broken
+     */
+    protected _minMaxConstraintTest(): boolean;
+    /**
+     * Runs code with check whether min max constrains was broken
+     * @param code - Code that should be executed which can change current value
+     */
+    protected _withMinMaxConstraint(code: () => void): void;
+    /**
+     * Clears current value
+     */
+    protected _clearValue(): void;
+    /**
+     * Changes current value of date for for specified part by single step
+     * @param part - Part of date that should be changed
+     * @param increment - Indication whether value should be incremented or decremented
+     */
+    protected _stepChangeValue(part: string, increment: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InputDateTimeSelectorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InputDateTimeSelectorComponent<any>, "input-date-time-selector", never, {}, {}, never, never>;
+}
+
+/**
+ * Represents minute component of datetime
+ */
+export declare const MINUTE = "minute";
+
+/**
+ * Represents month component of datetime
+ */
+export declare const MONTH = "month";
+
+/**
+ * Data that represents month in date picker
+ */
+export declare interface MonthData<TDate = any> extends PeriodData<TDate> {
+    /**
+     * Name of month
+     */
+    name: string;
+}
+
+/**
+ * Specific css classes for month picker
+ */
+export declare interface MonthPickerCssClasses extends CommonPickerCssClasses {
+}
+
+/**
+ * Type that represents ngClass
+ */
+declare type NgClassType = string | string[] | Set<string> | Dictionary<any> | undefined | null;
+
+/**
+ * Data that represents data for any picker type
+ */
+export declare interface PeriodData<TDate = any> {
+    /**
+     * Indication that this period item is active and selected
+     */
+    active: boolean;
+    /**
+     * Indication that this period item is disabled
+     */
+    disabled: boolean;
+    /**
+     * Date for this period item
+     */
+    date: TDate;
+}
+
+/**
+ * Base class used as base for picker
+ */
+export declare abstract class PickerBaseComponent<TDate = any, TDateData extends PeriodData<TDate> = any, TCssClasses = object> implements DateTimePicker<TDate, TCssClasses> {
+    protected _dateApi: DateApi<TDate>;
+    protected _changeDetector: ChangeDetectorRef;
+    /**
+     * Current value of datetime
+     */
+    protected _value: DateTimeValue<TDate> | null;
+    /**
+     * Occurs when value changes
+     */
+    protected _valueChange: Subject<void>;
+    /**
+     * Occurs when user scales up
+     */
+    protected _scaleUp: Subject<TDate>;
+    /**
+     * Occurs when user scales down
+     */
+    protected _scaleDown: Subject<TDate>;
+    /**
+     * Minimal possible value that can be picked
+     */
+    protected _minValue: TDate | null;
+    /**
+     * Maximal possible value that can be picked
+     */
+    protected _maxValue: TDate | null;
+    /**
+     * Gets current value of datetime
+     */
+    get value(): DateTimeValue<TDate> | null;
+    /**
+     * Occurs when value changes
+     */
+    get valueChange(): Observable<void>;
+    /**
+     * Occurs when user scales up
+     */
+    get scaleUp(): Observable<TDate>;
+    /**
+     * Occurs when user scales down
+     */
+    get scaleDown(): Observable<TDate>;
+    /**
+     * Date api instance for displayed date
+     * @internal
+     */
+    displayDate: DateApiObject<TDate> | null;
+    /**
+     * Indication whether can go up in period
+     * @internal
+     */
+    canGoUp: boolean;
+    /**
+     * Indication whether can go down in period
+     * @internal
+     */
+    canGoDown: boolean;
+    /**
+     * Array of period data to be displayed
+     * @internal
+     */
+    periodData: TDateData[];
+    /**
+     * Css classes that are used within picker
+     * @internal
+     */
+    cssClasses: TCssClasses;
+    constructor(_dateApi: DateApi<TDate>, _changeDetector: ChangeDetectorRef);
+    /**
+     * Changes displayed period to "higher" period
+     * @param event - Event that occured
+     * @internal
+     */
+    goUp(event: Event): void;
+    /**
+     * Selects period
+     * @param event - Event that occured
+     * @param period - Selected period
+     * @internal
+     */
+    select(event: Event, period: PeriodData<TDate>): void;
+    /**
+     * Sets css classes for picker, allowing to override defaults
+     * @param cssClasses - Css classes to be set for picker
+     */
+    setCssClasses(cssClasses: TCssClasses): void;
+    /**
+     * Sets minimal possible value for picker, that can be picked
+     * @param value - Minimal possible value that can be picked
+     */
+    setMinValue(value: TDate | null): void;
+    /**
+     * Sets maximal possible value for picker, that can be picked
+     * @param value - Maximal possible value that can be picked
+     */
+    setMaxValue(value: TDate | null): void;
+    /**
+     * Sets value of datetime picker
+     * @param value - Value to be set to this picker
+     */
+    setValue(value: DateTimeValue<TDate> | null): void;
+    /**
+     * Set displays date to be displayed
+     * @param value - Value that identifies period that is going to be displayed
+     */
+    abstract display(value: DateApiObject<TDate>): void;
+    /**
+     * Sets indication whether can go down
+     * @param value - Indication whether can go down in period
+     */
+    setCanGoDown(value: boolean): void;
+    /**
+     * Sets indication whether can go up
+     * @param value - Indication whether can go up in period
+     */
+    setCanGoUp(value: boolean): void;
+    /**
+     * Explicitly runs invalidation of content (change detection)
+     */
+    invalidateVisuals(): void;
+    /**
+     * Handles click anyway in picker, that blocks blur
+     * @param event - Event that occured
+     * @internal
+     */
+    handleClick(event: Event): void;
+    /**
+     * Sets period as active
+     * @param period - Period to be set as active
+     */
+    protected _setPeriod(period: PeriodData<TDate>): void;
+    /**
+     * Updates minimal and maximal value for picker
+     */
+    protected _updateMinMax(): void;
+    /**
+     * Obtains end of period
+     * @param period - Period for which should be end obtained
+     */
+    protected abstract _endOfPeriod(period: PeriodData<TDate>): TDate;
+    /**
+     * Tests whether provided value is in same period as displayed picker
+     * @param val - Tested value for same period as displayed picker
+     */
+    protected abstract _isSamePeriodAsDisplayed(val: DateApiObject<TDate>): boolean;
+    /**
+     * Tests whether provided value is in same period target value
+     * @param val - Tested value
+     * @param target - Target value to be tested against
+     */
+    protected abstract _isSamePeriod(val: DateApiObject<TDate>, target: TDate): boolean;
+    /**
+     * Gets period data for specified value
+     * @param val - Value for which is period data obtained
+     */
+    protected abstract _getPeriodData(val: DateApiObject<TDate>): PeriodData<TDate>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PickerBaseComponent<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PickerBaseComponent<any, any, any>, never, never, {}, {}, never>;
+}
+
+/**
+ * Represents quarter component of datetime
+ */
+export declare const QUARTER = "quarter";
+
+/**
+ * Animation trigger for animating scale up and scale down picker
+ */
+export declare const scaleUpDownTrigger: AnimationTriggerMetadata;
+
+/**
+ * Component used as datetime selector with simple input
+ */
+export declare class SimpleInputDateTimeSelectorComponent<TDate = any> implements DateTimeSelector<TDate> {
+    protected _dateApi: DateApi<TDate>;
+    protected _valueProvider: DateValueProvider<TDate>;
+    protected _changeDetector: ChangeDetectorRef;
+    /**
+     * Occurs when value changes
+     */
+    protected _valueChange: Subject<void>;
+    /**
+     * Occurs when selector is touched by user
+     */
+    protected _touched: Subject<void>;
+    /**
+     * Occurs when selector requires picker to be displayed or hidden
+     */
+    protected _pickerRequest: Subject<boolean>;
+    /**
+     * Currently used format for displaying data
+     */
+    protected _format: string;
+    /**
+     * Current value representation as date api wrapper
+     */
+    protected _dateApiValue: null | DateApiObject<TDate>;
+    /**
+     * Indication whether is current value valid value
+     */
+    protected _isValid: boolean;
+    /**
+     * Minimal possible value that can be picked
+     */
+    protected _minValue: TDate | null;
+    /**
+     * Maximal possible value that can be picked
+     */
+    protected _maxValue: TDate | null;
+    /**
+     * Gets or sets currently used format for displaying data
+     */
+    get format(): string;
+    set format(value: string);
+    /**
+     * Gets or sets placeholder that is displayed when there is no value selected
+     */
+    placeholder: string | undefined;
+    /**
+     * Gets current value of datetime
+     */
+    get value(): DateTimeValue<TDate> | null;
+    /**
+     * Gets formatted value
+     */
+    get formattedValue(): string | null;
+    /**
+     * Gets indication whether is current value valid
+     */
+    get valid(): boolean;
+    /**
+     * Occurs when value changes
+     */
+    get valueChange(): Observable<void>;
+    /**
+     * Occurs when selector is touched by user
+     */
+    get touched(): Observable<void>;
+    /**
+     * Occurs when selector requires picker to be displayed
+     */
+    get pickerRequest(): Observable<boolean>;
+    /**
+     * Indication whether is input disabled
+     * @internal
+     */
+    disabled: boolean;
+    /**
+     * Instance of html input element
+     * @internal
+     */
+    inputElement?: ElementRef<HTMLInputElement>;
+    /**
+     * Gets or sets string representation current of value
+     */
+    protected get currentValue(): string | null;
+    protected set currentValue(value: string | null);
+    /**
+     * Gets input element used for handling date time value
+     */
+    protected get input(): HTMLInputElement;
+    constructor(_dateApi: DateApi<TDate>, _valueProvider: DateValueProvider<TDate>, _changeDetector: ChangeDetectorRef);
+    /**
+     * Sets minimal possible value for picker, that can be picked
+     * @param value - Minimal possible value that can be picked
+     */
+    setMinValue(value: TDate | null): void;
+    /**
+     * Sets maximal possible value for picker, that can be picked
+     * @param value - Maximal possible value that can be picked
+     */
+    setMaxValue(value: TDate | null): void;
+    /**
+     * Sets value of datetime selector
+     * @param value - Value to be set to this selector
+     */
+    setValue(value: DateTimeValue<TDate> | null): void;
+    /**
+     * Sets as 'control' disabled
+     * @param disabled - Indication whether sets value as disabled, if omitted it is same as disabled set to true
+     */
+    setDisabled(disabled?: boolean): void;
+    /**
+     * Explicitly runs invalidation of content (change detection)
+     */
+    invalidateVisuals(): void;
+    /**
+     * Handles gaining of focus
+     * @internal
+     */
+    handleFocus(): void;
+    /**
+     * Handles blur on input
+     * @internal
+     */
+    handleBlur(): void;
+    /**
+     * Handles user input
+     * @internal
+     */
+    handleInput(): void;
+    /**
+     * Handles click event inside of input
+     * @internal
+     */
+    handleClick(): void;
+    /**
+     * Handles keyboard events
+     * @param event - Keyboard event that occured
+     * @param input - Html input element that holds current value and selection
+     * @internal
+     */
+    handleKeyboard(event: KeyboardEvent): void;
+    /**
+     * Clears current value
+     */
+    protected _clearValue(): void;
+    /**
+     * Tests whether are min or max constraint broken, returns true if constraint is broken
+     */
+    protected _minMaxConstraintTest(): boolean;
+    /**
+     * Runs code with check whether min max constrains was broken
+     * @param code - Code that should be executed which can change current value
+     */
+    protected _withMinMaxConstraint(code: () => void): void;
+    /**
+     * Shows current value in input
+     */
+    protected _show(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SimpleInputDateTimeSelectorComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SimpleInputDateTimeSelectorComponent<any>, "simple-input-date-time-selector", never, {}, {}, never, never>;
+}
+
+/**
+ * Validations functions for datetime
+ */
+export declare class Validators {
+    /**
+     * Creates validator function that validates control if its value is valid datetime value
+     * @param datetime - Object storing information about datetime value
+     */
+    static datetime<TDate = any>(datetime: DateTimeValueObject<TDate>): ValidatorFn;
+    /**
+     * Creates validator function that validates control if its value is withing range of minimal datetime value
+     * @param datetime - Object storing information about datetime value
+     * @param dateApi - Date api object
+     */
+    static minDatetime<TDate = any>(datetime: DateTimeValueObject<TDate>, dateApi: DateApi<TDate>): ValidatorFn;
+    /**
+     * Creates validator function that validates control if its value is withing range of maximal datetime value
+     * @param datetime - Object storing information about datetime value
+     * @param dateApi - Date api object
+     */
+    static maxDatetime<TDate = any>(datetime: DateTimeValueObject<TDate>, dateApi: DateApi<TDate>): ValidatorFn;
+}
+
+/**
+ * Represents week component of datetime
+ */
+export declare const WEEK = "week";
+
+/**
+ * Represents year component of datetime
+ */
+export declare const YEAR = "year";
+
+/**
+ * Data that represents year in date picker
+ */
+export declare interface YearData<TDate = any> extends PeriodData<TDate> {
+    /**
+     * Value of year
+     */
+    value: number;
+}
+
+/**
+ * Specific css classes for year picker
+ */
+export declare interface YearPickerCssClasses extends CommonPickerCssClasses {
+}
+
+export { }