cmat 0.0.28 → 0.0.29

package/components/material-datetimepicker/index.d.ts

@@ -1,5 +1,758 @@
+import * as i0 from '@angular/core';
+import { AfterContentInit, EventEmitter, ElementRef, OnDestroy, ChangeDetectorRef, InjectionToken, OnInit, Injector, ViewContainerRef, OnChanges, SimpleChanges } from '@angular/core';
+import { DatetimeAdapter, CmatDatetimeFormats } from 'cmat/components/adapter';
+import { Subject } from 'rxjs';
+import { Directionality } from '@angular/cdk/bidi';
+import { ScrollStrategy, Overlay } from '@angular/cdk/overlay';
+import { ThemePalette } from '@angular/material/core';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+import { MatFormField } from '@angular/material/form-field';
+import { MatButton } from '@angular/material/button';
+
+declare enum CmatDatetimepickerFilterType {
+    DATE = 0,
+    HOUR = 1,
+    MINUTE = 2
+}
+
+/** Possible types for datetimepicker. */
+type CmatDatetimepickerType = 'date' | 'time' | 'month' | 'year' | 'datetime';
+/** Possible views for datetimepicker calendar. */
+type CmatCalendarView = 'clock' | 'month' | 'year' | 'multi-year';
+/** Possible types for AM / PM */
+type CmatAMPM = 'AM' | 'PM';
+/** Possible modes for datetimepicker dropdown display. */
+type CmatDatetimepickerMode = 'auto' | 'portrait' | 'landscape';
+/** Possible positions for the datetimepicker dropdown along the X axis. */
+type DatetimepickerDropdownPositionX = 'start' | 'end';
+/** Possible positions for the datetimepicker dropdown along the Y axis. */
+type DatetimepickerDropdownPositionY = 'above' | 'below';
+type CmatClockView = 'hour' | 'minute';
+
+declare const CLOCK_RADIUS = 50;
+declare const CLOCK_INNER_RADIUS = 27.5;
+declare const CLOCK_OUTER_RADIUS = 41.25;
+declare const CLOCK_TICK_RADIUS = 7.0833;
 /**
- * Generated bundle index. Do not edit.
+ * A clock that is used as part of the datepicker.
  */
-/// <amd-module name="cmat/components/material-datetimepicker" />
-export * from './public-api';
+declare class CmatDatetimepickerClockComponent<D> implements AfterContentInit {
+    private _element;
+    private _adapter;
+    userSelection: EventEmitter<void>;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D, type: CmatDatetimepickerFilterType) => boolean;
+    interval: number;
+    twelvehour: boolean;
+    /** Emits when the currently selected date changes. */
+    selectedChange: EventEmitter<D>;
+    activeDateChange: EventEmitter<D>;
+    role: string;
+    class: string;
+    /** Hours and Minutes representing the clock view. */
+    hours: any[];
+    minutes: any[];
+    /** Whether the clock is in hour view. */
+    hourView: boolean;
+    selectedHour: number;
+    selectedMinute: number;
+    private _timeChanged;
+    private _mouseMoveListener;
+    private _mouseUpListener;
+    private _activeDate;
+    private _selected;
+    private _minDate;
+    private _maxDate;
+    constructor(_element: ElementRef, _adapter: DatetimeAdapter<D>);
+    /**
+     * The date to display in this clock view.
+     */
+    get activeDate(): D;
+    set activeDate(value: D);
+    /** The currently selected date. */
+    get selected(): D | null;
+    set selected(value: D | null);
+    /** The minimum selectable date. */
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    /** The maximum selectable date. */
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    /** Whether the clock should be started in hour or minute view. */
+    set startView(value: CmatClockView);
+    get hand(): any;
+    /** Handles mousedown events on the clock body. */
+    handleMousedown(event: MouseEvent): void;
+    ngAfterContentInit(): void;
+    handleMousemove(event: any): void;
+    handleMouseup(): void;
+    /** Initializes this clock view. */
+    private _init;
+    /**
+     * Set Time
+     *
+     * @param event
+     */
+    private _setTime;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerClockComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerClockComponent<any>, "cmat-datetimepicker-clock", ["cmatDatetimepickerClock"], { "dateFilter": { "alias": "dateFilter"; "required": false; }; "interval": { "alias": "interval"; "required": false; }; "twelvehour": { "alias": "twelvehour"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; "activeDateChange": "activeDateChange"; }, never, never, true, never>;
+}
+
+declare class CmatDatetimepickerIntl {
+    /**
+     * Stream to emit from when labels are changed. Use this to notify components when the labels have
+     * changed after initialization.
+     */
+    readonly changes: Subject<void>;
+    /** A label for the calendar popup (used by screen readers). */
+    calendarLabel: string;
+    /** A label for the button used to open the calendar popup (used by screen readers). */
+    openCalendarLabel: string;
+    /** Label for the button used to close the calendar popup. */
+    closeCalendarLabel: string;
+    /** A label for the previous month button (used by screen readers). */
+    prevMonthLabel: string;
+    /** A label for the next month button (used by screen readers). */
+    nextMonthLabel: string;
+    /** A label for the previous year button (used by screen readers). */
+    prevYearLabel: string;
+    /** A label for the next year button (used by screen readers). */
+    nextYearLabel: string;
+    /** A label for the previous multi-year button (used by screen readers). */
+    prevMultiYearLabel: string;
+    /** A label for the next multi-year button (used by screen readers). */
+    nextMultiYearLabel: string;
+    /** A label for the 'switch to month view' button (used by screen readers). */
+    switchToMonthViewLabel: string;
+    /** A label for the 'switch to year view' button (used by screen readers). */
+    switchToYearViewLabel: string;
+    /** A label for the 'switch to multi-year view' button (used by screen readers). */
+    switchToMultiYearViewLabel: string;
+    /** A label for the first date of a range of dates (used by screen readers). */
+    startDateLabel: string;
+    /** A label for the last date of a range of dates (used by screen readers). */
+    endDateLabel: string;
+    /** A label for the 'switch to clock hour view' button (used by screen readers). */
+    switchToClockHourViewLabel: string;
+    /** A label for the 'switch to clock minute view' button (used by screen readers). */
+    switchToClockMinuteViewLabel: string;
+    /** Label used for ok button within the manual time input. */
+    okLabel: string;
+    /** Label used for cancel button within the manual time input. */
+    cancelLabel: string;
+    /** Formats a range of years (used for visuals). */
+    formatYearRange(start: string, end: string): string;
+    /** Formats a label for a range of years (used by screen readers). */
+    formatYearRangeLabel(start: string, end: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CmatDatetimepickerIntl>;
+}
+
+/**
+ * A calendar that is used as part of the datepicker.
+ */
+declare class CmatDatetimepickerCalendarComponent<D> implements AfterContentInit, OnDestroy {
+    private _elementRef;
+    private _intl;
+    private _adapter;
+    private _dateFormats;
+    userSelection: EventEmitter<void>;
+    /** Active multi year view when click on year. */
+    multiYearSelector: boolean;
+    /** Whether the calendar should be started in month or year view. */
+    startView: CmatCalendarView;
+    twelvehour: boolean;
+    timeInterval: number;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D, type: CmatDatetimepickerFilterType) => boolean;
+    /** Prevent user to select same date time */
+    preventSameDateTimeSelection: boolean;
+    /** Emits when the currently selected date changes. */
+    selectedChange: EventEmitter<D>;
+    /** Emits when the view has been changed. **/
+    viewChanged: EventEmitter<CmatCalendarView>;
+    class: string;
+    label: string;
+    role: string;
+    tabindex: number;
+    AMPM: CmatAMPM;
+    clockView: CmatClockView;
+    calendarState: string;
+    /** Whether the calendar is in month view. */
+    private _currentView;
+    private _intlChanges;
+    private _clampedActiveDate;
+    private _type;
+    private _startAt;
+    private _selected;
+    private _minDate;
+    private _maxDate;
+    private _timeInput;
+    constructor(_elementRef: ElementRef, _intl: CmatDatetimepickerIntl, _adapter: DatetimeAdapter<D>, _dateFormats: CmatDatetimeFormats, changeDetectorRef: ChangeDetectorRef);
+    get type(): CmatDatetimepickerType;
+    set type(value: CmatDatetimepickerType);
+    /** A date representing the period (month or year) to start the calendar in. */
+    get startAt(): D | null;
+    set startAt(value: D | null);
+    /**
+     * Whether the calendar is in time mode. In time mode the calendar clock gets time input elements rather then just clock
+     *
+     * When touchUi is enabled this will be disabled
+     */
+    get timeInput(): boolean;
+    set timeInput(value: boolean);
+    /** The currently selected date. */
+    get selected(): D | null;
+    set selected(value: D | null);
+    /** The minimum selectable date. */
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    /** The maximum selectable date. */
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    /**
+     * The current active date. This determines which time period is shown and which date is
+     * highlighted when using keyboard navigation.
+     */
+    get activeDate(): D;
+    set activeDate(value: D);
+    get currentView(): CmatCalendarView;
+    set currentView(view: CmatCalendarView);
+    /** The label for the current calendar view. */
+    get yearButtonText(): string;
+    get yearPeriodText(): string;
+    get yearButtonLabel(): string;
+    get dateButtonText(): string;
+    get dateButtonLabel(): string;
+    get hoursButtonText(): string;
+    get hourButtonLabel(): string;
+    get minutesButtonText(): string;
+    get minuteButtonLabel(): string;
+    get prevButtonLabel(): string;
+    get nextButtonLabel(): string;
+    handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    /** Date filter for the month and year views. */
+    dateFilterForViews: (date: D) => boolean;
+    userSelected(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Handles date selection in the month view. */
+    dateSelected(date: D): void;
+    /** Handles month selection in the year view. */
+    monthSelected(month: D): void;
+    /** Handles year selection in the multi year view. */
+    yearSelected(year: D): void;
+    timeSelected(date: D): void;
+    dialTimeSelected(date: D): void;
+    onActiveDateChange(date: D): void;
+    updateDate(date: D): D;
+    selectAMPM(date: D): void;
+    ampmClicked(source: CmatAMPM): void;
+    yearClicked(): void;
+    dateClicked(): void;
+    hoursClicked(): void;
+    minutesClicked(): void;
+    /** Handles user clicks on the previous button. */
+    previousClicked(): void;
+    /** Handles user clicks on the next button. */
+    nextClicked(): void;
+    /** Whether the previous period button is enabled. */
+    previousEnabled(): boolean;
+    /** Whether the next period button is enabled. */
+    nextEnabled(): boolean;
+    focusActiveCell(): void;
+    calendarStateDone(): void;
+    /** Whether the two dates represent the same view in the current view mode (month or year). */
+    private _isSameView;
+    /** Handles keydown events on the calendar body when calendar is in month view. */
+    private _handleCalendarBodyKeydownInMonthView;
+    /** Handles keydown events on the calendar body when calendar is in year view. */
+    private _handleCalendarBodyKeydownInYearView;
+    /** Handles keydown events on the calendar body when calendar is in multi-year view. */
+    private _handleCalendarBodyKeydownInMultiYearView;
+    /** Handles keydown events on the calendar body when calendar is in month view. */
+    private _handleCalendarBodyKeydownInClockView;
+    /**
+     * Determine the date for the month that comes before the given month in the same column in the
+     * calendar table.
+     */
+    private _prevMonthInSameCol;
+    /**
+     * Determine the date for the month that comes after the given month in the same column in the
+     * calendar table.
+     */
+    private _nextMonthInSameCol;
+    private _changeCalendarState;
+    private _2digit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerCalendarComponent<any>, [null, null, { optional: true; }, { optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerCalendarComponent<any>, "cmat-datetimepicker-calendar", ["cmatDatetimepickerCalendar"], { "multiYearSelector": { "alias": "multiYearSelector"; "required": false; }; "startView": { "alias": "startView"; "required": false; }; "twelvehour": { "alias": "twelvehour"; "required": false; }; "timeInterval": { "alias": "timeInterval"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "preventSameDateTimeSelection": { "alias": "preventSameDateTimeSelection"; "required": false; }; "type": { "alias": "type"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "timeInput": { "alias": "timeInput"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; "viewChanged": "viewChanged"; }, never, never, true, never>;
+}
+
+/**
+ * An internal class that represents the data corresponding to a single calendar cell.
+ */
+declare class CmatDatetimepickerCalendarCellComponent {
+    value: number;
+    displayValue: string;
+    ariaLabel: string;
+    enabled: boolean;
+    constructor(value: number, displayValue: string, ariaLabel: string, enabled: boolean);
+}
+/**
+ * An internal component used to display calendar data in a table.
+ */
+declare class CmatDatetimepickerCalendarBodyComponent {
+    /** The label for the table. (e.g. "Jan 2017"). */
+    label: string;
+    /** The cells to display in the table. */
+    rows: CmatDatetimepickerCalendarCellComponent[][];
+    /** The value in the table that corresponds to today. */
+    todayValue: number | null;
+    /** The value in the table that is currently selected. */
+    selectedValue: number | null;
+    /** The minimum number of free cells needed to fit the label in the first row. */
+    labelMinRequiredCells: number;
+    /** The number of columns in the table. */
+    numCols: number;
+    /** Whether to allow selection of disabled cells. */
+    allowDisabledSelection: boolean;
+    /** The cell number of the active cell in the table. */
+    activeCell: number;
+    /** Emits when a new value is selected. */
+    selectedValueChange: EventEmitter<number>;
+    class: string;
+    /** The number of blank cells to put at the beginning for the first row. */
+    get _firstRowOffset(): number;
+    cellClicked(cell: CmatDatetimepickerCalendarCellComponent): void;
+    isActiveCell(rowIndex: number, colIndex: number): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerCalendarBodyComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerCalendarBodyComponent, "[cmat-datetimepicker-calendar-body]", ["cmatDatetimepickerCalendarBody"], { "label": { "alias": "label"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "todayValue": { "alias": "todayValue"; "required": false; }; "selectedValue": { "alias": "selectedValue"; "required": false; }; "labelMinRequiredCells": { "alias": "labelMinRequiredCells"; "required": false; }; "numCols": { "alias": "numCols"; "required": false; }; "allowDisabledSelection": { "alias": "allowDisabledSelection"; "required": false; }; "activeCell": { "alias": "activeCell"; "required": false; }; }, { "selectedValueChange": "selectedValueChange"; }, never, never, true, never>;
+}
+
+declare const CMAT_DATETIMEPICKER_VALUE_ACCESSOR: any;
+declare const CMAT_DATETIMEPICKER_VALIDATORS: any;
+/**
+ * An event used for datepicker input and change events. We don't always have access to a native
+ * input or change event because the event may have been triggered by the user clicking on the
+ * calendar popup. For consistency, we always use MatDatepickerInputEvent instead.
+ */
+declare class CmatDatetimepickerInputEvent<D> {
+    target: CmatDatetimepickerInputDirective<D>;
+    targetElement: HTMLElement;
+    /** The new value for the target datepicker input. */
+    value: D | null;
+    constructor(target: CmatDatetimepickerInputDirective<D>, targetElement: HTMLElement);
+}
+/** Directive used to connect an input to a MatDatepicker. */
+declare class CmatDatetimepickerInputDirective<D> implements AfterContentInit, ControlValueAccessor, OnDestroy, Validator {
+    private _elementRef;
+    _dateAdapter: DatetimeAdapter<D>;
+    private _dateFormats;
+    private _formField;
+    /** Emits when a `change` event is fired on this `<input>`. */
+    dateChange: EventEmitter<CmatDatetimepickerInputEvent<D>>;
+    /** Emits when an `input` event is fired on this `<input>`. */
+    dateInput: EventEmitter<CmatDatetimepickerInputEvent<D>>;
+    datetimepicker: CmatDatetimepickerComponent<D>;
+    dateFilter: (date: D | null, type: CmatDatetimepickerFilterType) => boolean;
+    /** Emits when the value changes (either due to user input or programmatic change). */
+    valueChange: EventEmitter<D | null>;
+    /** Emits when the disabled state has changed */
+    disabledChange: EventEmitter<boolean>;
+    private _datepickerSubscription;
+    private _localeSubscription;
+    /** Whether the last value set on the input was valid. */
+    private _lastValueValid;
+    private _value;
+    private _min;
+    private _max;
+    private _disabled;
+    constructor(_elementRef: ElementRef, _dateAdapter: DatetimeAdapter<D>, _dateFormats: CmatDatetimeFormats, _formField: MatFormField);
+    /** The datepicker that this input is associated with. */
+    set cmatDatetimepicker(value: CmatDatetimepickerComponent<D>);
+    set cmatDatepickerFilter(filter: (date: D | null, type: CmatDatetimepickerFilterType) => boolean);
+    /** The value of the input. */
+    get value(): D | null;
+    set value(value: D | null);
+    /** The minimum valid date. */
+    get min(): D | null;
+    set min(value: D | null);
+    /** The maximum valid date. */
+    get max(): D | null;
+    set max(value: D | null);
+    /** Whether the datepicker-input is disabled. */
+    get disabled(): boolean;
+    set disabled(value: any);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    registerOnValidatorChange(fn: VoidFunction): void;
+    validate(c: AbstractControl): ValidationErrors | null;
+    /**
+     * Gets the element that the datepicker popup should be connected to.
+     *
+     * @return The element to connect the popup to.
+     */
+    getConnectedOverlayOrigin(): ElementRef;
+    /** Gets the ID of an element that should be used a description for the calendar overlay. */
+    getOverlayLabelId(): string | null;
+    writeValue(value: D): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: VoidFunction): void;
+    setDisabledState(disabled: boolean): void;
+    onKeydown(event: KeyboardEvent): void;
+    onInput(value: string): void;
+    onChange(): void;
+    /** Handles blur events on the input. */
+    onBlur(): void;
+    /** Returns the palette used by the input's form field, if any. */
+    getThemePalette(): ThemePalette;
+    private _registerDatetimepicker;
+    private _getDisplayFormat;
+    private _getParseFormat;
+    private _onTouched;
+    private _cvaOnChange;
+    private _validatorOnChange;
+    /** The form control validator for whether the input parses. */
+    private _parseValidator;
+    /** The form control validator for the min date. */
+    private _minValidator;
+    /** The form control validator for the max date. */
+    private _maxValidator;
+    /** The form control validator for the date filter. */
+    private _filterValidator;
+    /** The combined form control validator for this input. */
+    private _validator;
+    /** Formats a value and sets it on the input element. */
+    private _formatValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerInputDirective<any>, [null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDatetimepickerInputDirective<any>, "input[cmatDatetimepicker]", ["cmatDatepickerInput"], { "cmatDatetimepicker": { "alias": "cmatDatetimepicker"; "required": false; }; "cmatDatepickerFilter": { "alias": "cmatDatepickerFilter"; "required": false; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "dateChange": "dateChange"; "dateInput": "dateInput"; }, never, never, true, never>;
+}
+
+/** Injection token that determines the scroll handling while the calendar is open. */
+declare const CMAT_DATETIMEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
+declare function CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy;
+declare const CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    deps: (typeof Overlay)[];
+    useFactory: typeof CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY;
+};
+/**
+ * Component used as the content for the datepicker dialog and popup. We use this instead of using
+ * MatCalendar directly as the content so we can control the initial focus. This also gives us a
+ * place to put additional features of the popup that are not part of the calendar itself in the
+ * future. (e.g. confirmation buttons).
+ */
+declare class CmatDatetimepickerContentComponent<D> implements OnInit, AfterContentInit, OnDestroy {
+    protected _elementRef: ElementRef;
+    private _changeDetectorRef;
+    _calendar: CmatDatetimepickerCalendarComponent<D>;
+    color: ThemePalette;
+    datetimepicker: CmatDatetimepickerComponent<D>;
+    /** Whether the datetimepicker is above or below the input. */
+    isAbove: boolean;
+    /** Current state of the animation. */
+    animationState: 'enter-dropdown' | 'enter-dialog' | 'void';
+    /** Emits when an animation has finished. */
+    readonly animationDone: Subject<void>;
+    /** Id of the label for the `role="dialog"` element. */
+    dialogLabelId: string | null;
+    constructor(_elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    startExitAnimation(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerContentComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerContentComponent<any>, "cmat-datetimepicker-content", ["cmatDatetimepickerContent"], { "color": { "alias": "color"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare class CmatDatetimepickerComponent<D> implements OnDestroy {
+    private _overlay;
+    private _injector;
+    private _viewContainerRef;
+    private _scrollStrategy;
+    private _dateAdapter;
+    private _dir;
+    private _document;
+    /** The view that the calendar should start in. */
+    startView: CmatCalendarView;
+    mode: CmatDatetimepickerMode;
+    timeInterval: number;
+    /** Prevent user to select same date time */
+    preventSameDateTimeSelection: boolean;
+    /** Preferred position of the datetimepicker in the X axis. */
+    xPosition: DatetimepickerDropdownPositionX;
+    /** Preferred position of the datetimepicker in the Y axis. */
+    yPosition: DatetimepickerDropdownPositionY;
+    selectedChanged: EventEmitter<D>;
+    /** Emits when the datepicker has been opened. */
+    openedStream: EventEmitter<void>;
+    /** Emits when the datepicker has been closed. */
+    closedStream: EventEmitter<void>;
+    /** Emits when the view has been changed. **/
+    viewChanged: EventEmitter<CmatCalendarView>;
+    /** Whether the calendar is open. */
+    /** The id for the datepicker calendar. */
+    id: string;
+    /** The input element this datepicker is associated with. */
+    datetimepickerInput: CmatDatetimepickerInputDirective<D>;
+    /** Emits when the datepicker is disabled. */
+    disabledChange: Subject<boolean>;
+    private _validSelected;
+    /** A reference to the overlay into which we've rendered the calendar. */
+    private _overlayRef;
+    /** Reference to the component instance rendered in the overlay. */
+    private _componentRef;
+    /** The element that was focused before the datetimepicker was opened. */
+    private _focusedElementBeforeOpen;
+    /** Unique class that will be added to the backdrop so that the test harnesses can look it up. */
+    private _backdropHarnessClass;
+    private _inputStateChanges;
+    private _multiYearSelector;
+    private _twelvehour;
+    private _panelClass;
+    private _opened;
+    private _color;
+    private _startAt;
+    private _type;
+    private _touchUi;
+    private _disabled;
+    private _timeInput;
+    private _restoreFocus;
+    constructor(_overlay: Overlay, _injector: Injector, _viewContainerRef: ViewContainerRef, _scrollStrategy: any, _dateAdapter: DatetimeAdapter<D>, _dir: Directionality, _document: any);
+    /** Whether to show multi-year view. */
+    get multiYearSelector(): boolean;
+    set multiYearSelector(value: boolean);
+    /** Whether the clock uses 12 hour format. */
+    get twelvehour(): boolean;
+    set twelvehour(value: boolean);
+    /**
+     * Classes to be passed to the date picker panel.
+     * Supports string and string array values, similar to `ngClass`.
+     */
+    get panelClass(): string | string[];
+    set panelClass(value: string | string[]);
+    /** Whether the calendar is open. */
+    get opened(): boolean;
+    set opened(value: boolean);
+    /** Color palette to use on the datetimepicker's calendar. */
+    get color(): ThemePalette;
+    set color(value: ThemePalette);
+    /** The date to open the calendar to initially. */
+    get startAt(): D | null;
+    set startAt(date: D | null);
+    get type(): CmatDatetimepickerType;
+    set type(value: CmatDatetimepickerType);
+    /**
+     * Whether the calendar is in time mode. In time mode the calendar clock gets time input
+     * elements rather then just clock. When `touchUi` is enabled this will be disabled.
+     */
+    get timeInput(): boolean;
+    set timeInput(value: boolean);
+    /**
+     * Whether the calendar UI is in touch mode. In touch mode the calendar opens in a dialog rather
+     * than a popup and elements have more padding to allow for bigger touch targets.
+     */
+    get touchUi(): boolean;
+    set touchUi(value: boolean);
+    /** Whether the datepicker pop-up should be disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /**
+     * Whether to restore focus to the previously-focused element when the panel is closed.
+     * Note that automatic focus restoration is an accessibility feature and it is recommended that
+     * you provide your own equivalent, if you decide to turn it off.
+     */
+    get restoreFocus(): boolean;
+    set restoreFocus(value: boolean);
+    /** The currently selected date. */
+    get selected(): D | null;
+    set selected(value: D | null);
+    /** The minimum selectable date. */
+    get minDate(): D | null;
+    /** The maximum selectable date. */
+    get maxDate(): D | null;
+    get dateFilter(): (date: D | null, type: CmatDatetimepickerFilterType) => boolean;
+    ngOnDestroy(): void;
+    /**
+     * Register an input with this datepicker.
+     *
+     * @param input The datepicker input to register with this datepicker.
+     */
+    registerInput(input: CmatDatetimepickerInputDirective<D>): void;
+    /** Open the calendar. */
+    open(): void;
+    /** Close the calendar. */
+    close(): void;
+    /** Selects the given date */
+    select(date: D): void;
+    viewChange(type: CmatCalendarView): void;
+    /**
+     * Forwards relevant values from the datetimepicker to the
+     * datetimepicker content inside the overlay.
+     */
+    private _forwardContentValues;
+    /** Opens the overlay with the calendar. */
+    private _openOverlay;
+    /** Destroys the current overlay. */
+    private _destroyOverlay;
+    /** Gets a position strategy that will open the calendar as a dropdown. */
+    private _getDialogStrategy;
+    /** Gets a position strategy that will open the calendar as a dropdown. */
+    private _getDropdownStrategy;
+    /**
+     * Sets the positions of the datetimepicker in dropdown mode based on the current configuration.
+     */
+    private _setConnectedPositions;
+    /** Gets an observable that will emit when the overlay is supposed to be closed. */
+    private _getCloseStream;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerComponent<any>, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerComponent<any>, "cmat-datetimepicker", ["cmatDatetimepicker"], { "startView": { "alias": "startView"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "timeInterval": { "alias": "timeInterval"; "required": false; }; "preventSameDateTimeSelection": { "alias": "preventSameDateTimeSelection"; "required": false; }; "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "multiYearSelector": { "alias": "multiYearSelector"; "required": false; }; "twelvehour": { "alias": "twelvehour"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "color": { "alias": "color"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "type": { "alias": "type"; "required": false; }; "timeInput": { "alias": "timeInput"; "required": false; }; "touchUi": { "alias": "touchUi"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "restoreFocus": { "alias": "restoreFocus"; "required": false; }; }, { "selectedChanged": "selectedChanged"; "openedStream": "openedStream"; "closedStream": "closedStream"; "viewChanged": "viewChanged"; }, never, never, true, never>;
+}
+
+/** Can be used to override the icon of a `cmatDatetimepickerToggle`. */
+declare class CmatDatetimepickerToggleIconDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerToggleIconDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CmatDatetimepickerToggleIconDirective, "[cmatDatetimepickerToggleIcon]", never, {}, {}, never, never, true, never>;
+}
+declare class CmatDatetimepickerToggleComponent<D> implements AfterContentInit, OnChanges, OnDestroy {
+    protected intl: CmatDatetimepickerIntl;
+    private _changeDetectorRef;
+    /** Datepicker instance that the button will toggle. */
+    datetimepicker: CmatDatetimepickerComponent<D>;
+    /** Tabindex for the toggle. */
+    tabIndex: number;
+    /** Screen-reader label for the button. */
+    ariaLabel?: string;
+    /** Whether ripples on the toggle should be disabled. */
+    disableRipple: boolean;
+    /** Custom icon set by the consumer. */
+    customIcon: CmatDatetimepickerToggleIconDirective;
+    /** Underlying button element. */
+    button: MatButton;
+    class: string;
+    private _stateChanges;
+    private _disabled;
+    constructor(intl: CmatDatetimepickerIntl, _changeDetectorRef: ChangeDetectorRef);
+    /** Whether the toggle button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    open(event: Event): void;
+    private _watchStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerToggleComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerToggleComponent<any>, "cmat-datetimepicker-toggle", ["cmatDatetimepickerToggle"], { "datetimepicker": { "alias": "for"; "required": false; }; "tabIndex": { "alias": "tabIndex"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "disableRipple": { "alias": "disableRipple"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, ["customIcon"], ["[cmatDatetimepickerToggleIcon]"], true, never>;
+}
+
+/**
+ * An internal component used to display a single month in the datepicker.
+ */
+declare class CmatDatetimepickerMonthViewComponent<D> implements AfterContentInit {
+    adapter: DatetimeAdapter<D>;
+    private _dateFormats;
+    type: CmatDatetimepickerType;
+    userSelection: EventEmitter<void>;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D) => boolean;
+    /** Emits when a new date is selected. */
+    selectedChange: EventEmitter<D>;
+    /** Grid of calendar cells representing the dates of the month. */
+    weeks: CmatDatetimepickerCalendarCellComponent[][];
+    /** The number of blank cells in the first row before the 1st of the month. */
+    firstWeekOffset: number;
+    /**
+     * The date of the month that the currently selected Date falls on.
+     * Null if the currently selected Date is in another month.
+     */
+    selectedDate: number | null;
+    /** The date of the month that today falls on. Null if today is in another month. */
+    todayDate: number | null;
+    /** The names of the weekdays. */
+    weekdays: {
+        long: string;
+        narrow: string;
+    }[];
+    calendarState: string;
+    private _activeDate;
+    private _selected;
+    constructor(adapter: DatetimeAdapter<D>, _dateFormats: CmatDatetimeFormats);
+    /**
+     * The date to display in this month view (everything other than the month and year is ignored).
+     */
+    get activeDate(): D;
+    set activeDate(value: D);
+    /** The currently selected date. */
+    get selected(): D;
+    set selected(value: D);
+    ngAfterContentInit(): void;
+    /** Handles when a new date is selected. */
+    dateSelected(date: number): void;
+    calendarStateDone(): void;
+    /** Initializes this month view. */
+    private _init;
+    /** Creates MdCalendarCells for the dates in this month. */
+    private _createWeekCells;
+    /**
+     * Gets the date in this month that the given Date falls on.
+     * Returns null if the given Date is in another month.
+     */
+    private _getDateInCurrentMonth;
+    private _changeCalendarState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerMonthViewComponent<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerMonthViewComponent<any>, "cmat-datetimepicker-month-view", ["cmatDatetimepickerMonthView"], { "type": { "alias": "type"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+/**
+ * An internal component used to display a single year in the datepicker.
+ */
+declare class CmatDatetimepickerYearViewComponent<D> implements AfterContentInit {
+    adapter: DatetimeAdapter<D>;
+    private _dateFormats;
+    userSelection: EventEmitter<void>;
+    type: CmatDatetimepickerType;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D) => boolean;
+    /** Emits when a new month is selected. */
+    selectedChange: EventEmitter<D>;
+    /** Grid of calendar cells representing the months of the year. */
+    months: CmatDatetimepickerCalendarCellComponent[][];
+    /** The label for this year (e.g. "2017"). */
+    yearLabel: string;
+    /** The month in this year that today falls on. Null if today is in a different year. */
+    todayMonth: number | null;
+    /**
+     * The month in this year that the selected Date falls on.
+     * Null if the selected Date is in a different year.
+     */
+    selectedMonth: number | null;
+    calendarState: string;
+    private _activeDate;
+    private _selected;
+    constructor(adapter: DatetimeAdapter<D>, _dateFormats: CmatDatetimeFormats);
+    /** The date to display in this year view (everything other than the year is ignored). */
+    get activeDate(): D;
+    set activeDate(value: D);
+    /** The currently selected date. */
+    get selected(): D;
+    set selected(value: D);
+    ngAfterContentInit(): void;
+    /** Handles when a new month is selected. */
+    monthSelected(month: number): void;
+    calendarStateDone(): void;
+    /** Initializes this month view. */
+    private _init;
+    /**
+     * Gets the month in this year that the given Date falls on.
+     * Returns null if the given Date is in another year.
+     */
+    private _getMonthInCurrentYear;
+    /** Creates an MdCalendarCell for the given month. */
+    private _createCellForMonth;
+    /** Whether the given month is enabled. */
+    private _isMonthEnabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CmatDatetimepickerYearViewComponent<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CmatDatetimepickerYearViewComponent<any>, "cmat-datetimepicker-year-view", ["cmatDatetimepickerYearView"], { "type": { "alias": "type"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "userSelection": "userSelection"; "selectedChange": "selectedChange"; }, never, never, true, never>;
+}
+
+export { CLOCK_INNER_RADIUS, CLOCK_OUTER_RADIUS, CLOCK_RADIUS, CLOCK_TICK_RADIUS, CMAT_DATETIMEPICKER_SCROLL_STRATEGY, CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY, CMAT_DATETIMEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, CMAT_DATETIMEPICKER_VALIDATORS, CMAT_DATETIMEPICKER_VALUE_ACCESSOR, CmatDatetimepickerCalendarBodyComponent, CmatDatetimepickerCalendarCellComponent, CmatDatetimepickerCalendarComponent, CmatDatetimepickerClockComponent, CmatDatetimepickerComponent, CmatDatetimepickerContentComponent, CmatDatetimepickerFilterType, CmatDatetimepickerInputDirective, CmatDatetimepickerInputEvent, CmatDatetimepickerMonthViewComponent, CmatDatetimepickerToggleComponent, CmatDatetimepickerToggleIconDirective, CmatDatetimepickerYearViewComponent };
+export type { CmatAMPM, CmatCalendarView, CmatClockView, CmatDatetimepickerMode, CmatDatetimepickerType, DatetimepickerDropdownPositionX, DatetimepickerDropdownPositionY };