@gipisistemas/ng-core 1.1.11 → 1.1.12

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@gipisistemas/ng-core",
-  "version": "1.1.11",
+  "version": "1.1.12",
   "peerDependencies": {
     "@angular/common": "~8.2.3",
     "@angular/core": "~8.2.3",
-    "@angular/cdk": "~8.2.1",
-    "@angular/cdk-experimental": "~8.1.3",
-    "@angular/material": "~8.1.3",
+    "@angular/cdk": "~8.2.3",
+    "@angular/cdk-experimental": "~8.2.3",
+    "@angular/material": "~8.2.3",
     "@angular/flex-layout": "~8.0.0-beta.27",
     "@material-extended/mde": "^2.3.1",
     "ngx-currency": "^2.3.3",

package/shared/gipi-components/datetime-picker/datetime-picker/datetime-picker.component.d.ts

@@ -0,0 +1,40 @@
+import { ChangeDetectorRef, ElementRef, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { GIPIDatetimepickerToggleComponent } from '../mat-datetime-picker/datetimepicker-toggle';
+import { GIPIDatetimepickerType } from '../mat-datetime-picker/datetimepicker-type';
+export declare type GIPIDateAndTimeType = Exclude<GIPIDatetimepickerType, 'date' | 'month' | 'year'>;
+export declare class GIPIDateAndTimePickerComponent implements OnInit, ControlValueAccessor {
+    elementRef: ElementRef<HTMLElement>;
+    private _changeDetectorRef;
+    GIPIDatetimepickerToggleRef: GIPIDatetimepickerToggleComponent<Date>;
+    private _name;
+    id: string;
+    name: string;
+    label: string;
+    placeholder: string;
+    minDate: Date;
+    maxDate: Date;
+    timeInterval: number;
+    help: string;
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _value;
+    get value(): any;
+    set value(value: any);
+    private _type;
+    get type(): GIPIDateAndTimeType;
+    set type(value: GIPIDateAndTimeType);
+    onChange: Function;
+    onTouched: Function;
+    constructor(elementRef: ElementRef<HTMLElement>, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState?(isDisabled: boolean): void;
+    toggleDatetimePicker(event: Event): void;
+}

package/shared/gipi-components/datetime-picker/datetime-picker.module.d.ts

@@ -0,0 +1,2 @@
+export declare class DatetimepickerModule {
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/calendar-body.d.ts

@@ -0,0 +1,50 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+/**
+ * An internal class that represents the data corresponding to a single calendar cell.
+ * @docs-private
+ */
+export declare class GIPIDatetimepickerCalendarCell {
+    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.
+ * @docs-private
+ */
+export declare class GIPIDatetimepickerCalendarBodyComponent implements OnChanges {
+    /** The number of blank cells to put at the beginning for the first row. */
+    _firstRowOffset: number;
+    /** Padding for the individual date cells. */
+    _cellPadding: string;
+    /** Width of an individual cell. */
+    _cellWidth: string;
+    /**
+     * The aspect ratio (width / height) to use for the cells in the table. This aspect ratio will be
+     * maintained even as the table resizes.
+     */
+    cellAspectRatio: number;
+    /** The label for the table. (e.g. "Jan 2017"). */
+    label: string;
+    /** The cells to display in the table. */
+    rows: GIPIDatetimepickerCalendarCell[][];
+    /** The value in the table that corresponds to today. */
+    todayValue: number;
+    /** The value in the table that is currently selected. */
+    selectedValue: number;
+    /** 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>;
+    _cellClicked(cell: GIPIDatetimepickerCalendarCell): void;
+    _isActiveCell(rowIndex: number, colIndex: number): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/calendar.d.ts

@@ -0,0 +1,140 @@
+import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, NgZone, OnDestroy } from '@angular/core';
+import { MatDatepickerIntl } from '@angular/material/datepicker';
+import { GIPIClockView } from './clock';
+import { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';
+import { GIPIDatetimepickerType } from './datetimepicker-type';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+import { GIPIDatetimeFormats } from './shared/adapter/datetime-formats';
+export declare type GIPICalendarView = 'clock' | 'month' | 'year' | 'multi-year';
+/**
+ * A calendar that is used as part of the datepicker.
+ * @docs-private
+ */
+export declare class GIPIDatetimepickerCalendarComponent<D> implements AfterContentInit, OnDestroy {
+    private _elementRef;
+    private _intl;
+    private _ngZone;
+    private _adapter;
+    private _dateFormats;
+    _AMPM: string;
+    _clockView: GIPIClockView;
+    _calendarState: string;
+    private _intlChanges;
+    private _clampedActiveDate;
+    /** Active multi year view when click on year. */
+    multiYearSelector: boolean;
+    /** Whether the calendar should be started in month or year view. */
+    startView: GIPICalendarView;
+    twelvehour: boolean;
+    timeInterval: number;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D, type: GIPIDatetimepickerFilterType) => boolean;
+    ariaLabel: string;
+    ariaNextMonthLabel: string;
+    ariaPrevMonthLabel: string;
+    ariaNextYearLabel: string;
+    ariaPrevYearLabel: string;
+    ariaNextMultiYearLabel: string;
+    ariaPrevMultiYearLabel: string;
+    /** Prevent user to select same date time */
+    preventSameDateTimeSelection: boolean;
+    private _type;
+    get type(): GIPIDatetimepickerType;
+    set type(value: GIPIDatetimepickerType);
+    /** A date representing the period (month or year) to start the calendar in. */
+    private _startAt;
+    get startAt(): D | null;
+    set startAt(value: D | null);
+    /** The currently selected date. */
+    private _selected;
+    get selected(): D | null;
+    set selected(value: D | null);
+    /** The minimum selectable date. */
+    private _minDate;
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    /** The maximum selectable date. */
+    private _maxDate;
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    /** Emits when the currently selected date changes. */
+    selectedChange: EventEmitter<D>;
+    /** Emits when the view has been changed. **/
+    viewChanged: EventEmitter<GIPICalendarView>;
+    _userSelection: EventEmitter<void>;
+    /** 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);
+    /** Whether the calendar is in month view. */
+    _currentView: GIPICalendarView;
+    get currentView(): GIPICalendarView;
+    set currentView(view: GIPICalendarView);
+    /** The label for the current calendar view. */
+    get _yearLabel(): string;
+    get _monthYearLabel(): string;
+    get _dateLabel(): string;
+    get periodButtonLabel(): string;
+    /** The label for the previous button. */
+    get prevButtonLabel(): string;
+    /** The label for the next button. */
+    get nextButtonLabel(): string;
+    get _hoursLabel(): string;
+    get _minutesLabel(): string;
+    get _ariaLabelNext(): string;
+    get _ariaLabelPrev(): string;
+    constructor(_elementRef: ElementRef, _intl: MatDatepickerIntl, _ngZone: NgZone, _adapter: GIPIDatetimeAdapter<D>, _dateFormats: GIPIDatetimeFormats, changeDetectorRef: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /** Date filter for the month and year views. */
+    _dateFilterForViews: (date: D) => boolean;
+    _userSelected(): 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;
+    _onActiveDateChange(date: D): void;
+    _updateDate(date: D): D;
+    _selectAMPM(date: D): void;
+    _ampmClicked(source: string): 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;
+    /** Handles keydown events on the calendar body. */
+    _handleCalendarBodyKeydown(event: KeyboardEvent): void;
+    _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 calendarState;
+    private _2digit;
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/clock.d.ts

@@ -0,0 +1,66 @@
+import { AfterContentInit, ElementRef, EventEmitter } from '@angular/core';
+import { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+export declare const CLOCK_RADIUS = 50;
+export declare const CLOCK_INNER_RADIUS = 27.5;
+export declare const CLOCK_OUTER_RADIUS = 41.25;
+export declare const CLOCK_TICK_RADIUS = 7.0833;
+export declare type GIPIClockView = 'hour' | 'minute';
+/**
+ * A clock that is used as part of the datepicker.
+ * @docs-private
+ */
+export declare class GIPIDatetimepickerClockComponent<D> implements AfterContentInit {
+    private _element;
+    private _adapter;
+    /** Hours and Minutes representing the clock view. */
+    _hours: Array<Object>;
+    _minutes: Array<Object>;
+    /** Whether the clock is in hour view. */
+    _hourView: boolean;
+    _selectedHour: number;
+    _selectedMinute: number;
+    private _timeChanged;
+    private mouseMoveListener;
+    private mouseUpListener;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D, type: GIPIDatetimepickerFilterType) => boolean;
+    interval: number;
+    twelvehour: boolean;
+    /** The date to display in this clock view. */
+    private _activeDate;
+    get activeDate(): D;
+    set activeDate(value: D);
+    /** The currently selected date. */
+    private _selected;
+    get selected(): D | null;
+    set selected(value: D | null);
+    /** The minimum selectable date. */
+    private _minDate;
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    /** The maximum selectable date. */
+    private _maxDate;
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    /** Whether the clock should be started in hour or minute view. */
+    set startView(value: GIPIClockView);
+    get _hand(): any;
+    /** Emits when the currently selected date changes. */
+    selectedChange: EventEmitter<D>;
+    activeDateChange: EventEmitter<D>;
+    _userSelection: EventEmitter<void>;
+    constructor(_element: ElementRef, _adapter: GIPIDatetimeAdapter<D>);
+    ngAfterContentInit(): void;
+    /** Handles mousedown events on the clock body. */
+    _handleMousedown(event: any): void;
+    _handleMousemove(event: any): void;
+    _handleMouseup(): void;
+    /** Initializes this clock view. */
+    private _init;
+    /**
+     * Set Time
+     * @param event
+     */
+    private setTime;
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-animations.d.ts

@@ -0,0 +1,8 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+/**
+ * This animation fades in the background color and text content of the
+ * select's options. It is time delayed to occur 100ms after the overlay
+ * panel has transformed in.
+ */
+export declare const fadeInContent: AnimationTriggerMetadata;
+export declare const slideCalendar: AnimationTriggerMetadata;

package/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-errors.d.ts

@@ -0,0 +1,2 @@
+/** @docs-private */
+export declare function createMissingDateImplError(provider: string): Error;

package/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-filtertype.d.ts

@@ -0,0 +1,5 @@
+export declare enum GIPIDatetimepickerFilterType {
+    DATE = 0,
+    HOUR = 1,
+    MINUTE = 2
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-input.d.ts

@@ -0,0 +1,98 @@
+import { AfterContentInit, ElementRef, EventEmitter, OnDestroy } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, ValidationErrors, Validator } from '@angular/forms';
+import { MatFormField } from '@angular/material/form-field';
+import { GIPIDatetimepickerComponent } from './datetimepicker';
+import { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+import { GIPIDatetimeFormats } from './shared/adapter/datetime-formats';
+export declare const GIPI_DATETIMEPICKER_VALUE_ACCESSOR: any;
+export declare const GIPI_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.
+ */
+export declare class GIPIDatetimepickerInputEvent<D> {
+    target: GIPIDatetimepickerInputDirective<D>;
+    targetElement: HTMLElement;
+    /** The new value for the target datepicker input. */
+    value: D | null;
+    constructor(target: GIPIDatetimepickerInputDirective<D>, targetElement: HTMLElement);
+}
+/** Directive used to connect an input to a MatDatepicker. */
+export declare class GIPIDatetimepickerInputDirective<D> implements AfterContentInit, ControlValueAccessor, OnDestroy, Validator {
+    private _elementRef;
+    _dateAdapter: GIPIDatetimeAdapter<D>;
+    private _dateFormats;
+    private _formField;
+    _datepicker: GIPIDatetimepickerComponent<D>;
+    _dateFilter: (date: D | null, type: GIPIDatetimepickerFilterType) => boolean;
+    /** Emits when the value changes (either due to user input or programmatic change). */
+    _valueChange: EventEmitter<D>;
+    /** 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;
+    /** The datepicker that this input is associated with. */
+    set gipiMatDatetimePicker(value: GIPIDatetimepickerComponent<D>);
+    set matDatepickerFilter(filter: (date: D | null, type: GIPIDatetimepickerFilterType) => boolean);
+    /** The value of the input. */
+    private _value;
+    get value(): D | null;
+    set value(value: D | null);
+    /** The minimum valid date. */
+    private _min;
+    get min(): D | null;
+    set min(value: D | null);
+    /** The maximum valid date. */
+    private _max;
+    get max(): D | null;
+    set max(value: D | null);
+    /** Whether the datepicker-input is disabled. */
+    private _disabled;
+    get disabled(): any;
+    set disabled(value: any);
+    /** Emits when a `change` event is fired on this `<input>`. */
+    dateChange: EventEmitter<GIPIDatetimepickerInputEvent<D>>;
+    /** Emits when an `input` event is fired on this `<input>`. */
+    dateInput: EventEmitter<GIPIDatetimepickerInputEvent<D>>;
+    constructor(_elementRef: ElementRef, _dateAdapter: GIPIDatetimeAdapter<D>, _dateFormats: GIPIDatetimeFormats, _formField: MatFormField);
+    _onTouched: () => void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    registerOnValidatorChange(fn: () => void): 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;
+    writeValue(value: D): void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    _onKeydown(event: KeyboardEvent): void;
+    _onInput(value: string): void;
+    _onChange(): void;
+    /** Handles blur events on the input. */
+    _onBlur(): void;
+    private registerDatepicker;
+    private getDisplayFormat;
+    private getParseFormat;
+    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;
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-toggle.d.ts

@@ -0,0 +1,20 @@
+import { AfterContentInit, ChangeDetectorRef, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { MatDatepickerIntl } from '@angular/material/datepicker';
+import { GIPIDatetimepickerComponent } from './datetimepicker';
+export declare class GIPIDatetimepickerToggleComponent<D> implements AfterContentInit, OnChanges, OnDestroy {
+    _intl: MatDatepickerIntl;
+    private _changeDetectorRef;
+    private _disabled;
+    private _stateChanges;
+    /** Datepicker instance that the button will toggle. */
+    datetimepicker: GIPIDatetimepickerComponent<D>;
+    /** Whether the toggle button is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    constructor(_intl: MatDatepickerIntl, _changeDetectorRef: ChangeDetectorRef);
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    ngAfterContentInit(): void;
+    _open(event: Event): void;
+    private _watchStateChanges;
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker-type.d.ts

@@ -0,0 +1 @@
+export declare type GIPIDatetimepickerType = ('date' | 'time' | 'month' | 'year' | 'datetime');

package/shared/gipi-components/datetime-picker/mat-datetime-picker/datetimepicker.d.ts

@@ -0,0 +1,133 @@
+import { Directionality } from '@angular/cdk/bidi';
+import { Overlay } from '@angular/cdk/overlay';
+import { AfterContentInit, EventEmitter, NgZone, OnDestroy, ViewContainerRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Subject } from 'rxjs';
+import { GIPICalendarView, GIPIDatetimepickerCalendarComponent } from './calendar';
+import { GIPIDatetimepickerFilterType } from './datetimepicker-filtertype';
+import { GIPIDatetimepickerInputDirective } from './datetimepicker-input';
+import { GIPIDatetimepickerType } from './datetimepicker-type';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+export declare type GIPIDatetimepickerMode = 'auto' | 'portrait' | 'landscape';
+/**
+ * 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).
+ * @docs-private
+ */
+export declare class GIPIDatetimepickerContentComponent<D> implements AfterContentInit {
+    _calendar: GIPIDatetimepickerCalendarComponent<D>;
+    datetimepicker: GIPIDatetimepickerComponent<D>;
+    ngAfterContentInit(): void;
+    onSelectionChange(date: D): void;
+    /**
+     * Handles keydown event on datepicker content.
+     * @param event The event.
+     */
+    _handleKeydown(event: KeyboardEvent): void;
+}
+export declare class GIPIDatetimepickerComponent<D> implements OnDestroy {
+    private _dialog;
+    private _overlay;
+    private _ngZone;
+    private _viewContainerRef;
+    private _scrollStrategy;
+    private _dateAdapter;
+    private _dir;
+    private _document;
+    /** Whether the calendar is open. */
+    opened: boolean;
+    /** The id for the datepicker calendar. */
+    id: string;
+    /** The input element this datepicker is associated with. */
+    _datepickerInput: GIPIDatetimepickerInputDirective<D>;
+    /** Emits when the datepicker is disabled. */
+    _disabledChange: Subject<boolean>;
+    private _validSelected;
+    /** A reference to the overlay when the calendar is opened as a popup. */
+    private _popupRef;
+    /** A reference to the dialog when the calendar is opened as a dialog. */
+    private _dialogRef;
+    /** A portal containing the calendar for this datepicker. */
+    private _calendarPortal;
+    /** The element that was focused before the datepicker was opened. */
+    private _focusedElementBeforeOpen;
+    private _inputSubscription;
+    /** Active multi year view when click on year. */
+    multiYearSelector: boolean;
+    /** if true change the clock to 12 hour format. */
+    twelvehour: boolean;
+    /** The view that the calendar should start in. */
+    startView: GIPICalendarView;
+    mode: GIPIDatetimepickerMode;
+    timeInterval: number;
+    ariaNextMonthLabel: string;
+    ariaPrevMonthLabel: string;
+    ariaNextYearLabel: string;
+    ariaPrevYearLabel: string;
+    /** Prevent user to select same date time */
+    preventSameDateTimeSelection: boolean;
+    /** Classes to be passed to the date picker panel. Supports the same syntax as `ngClass`. */
+    panelClass: string | string[];
+    /** The date to open the calendar to initially. */
+    private _startAt;
+    get startAt(): D | null;
+    set startAt(date: D | null);
+    private _openOnFocus;
+    get openOnFocus(): boolean;
+    set openOnFocus(value: boolean);
+    private _type;
+    get type(): GIPIDatetimepickerType;
+    set type(value: GIPIDatetimepickerType);
+    /** 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. */
+    private _touchUi;
+    get touchUi(): boolean;
+    set touchUi(value: boolean);
+    /** Whether the datepicker pop-up should be disabled. */
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    /** 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<GIPICalendarView>;
+    /**
+     * Emits new selected date when selected date changes.
+     * @deprecated Switch to the `dateChange` and `dateInput` binding on the input element.
+     */
+    selectedChanged: EventEmitter<D>;
+    /** 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: GIPIDatetimepickerFilterType) => boolean;
+    constructor(_dialog: MatDialog, _overlay: Overlay, _ngZone: NgZone, _viewContainerRef: ViewContainerRef, _scrollStrategy: any, _dateAdapter: GIPIDatetimeAdapter<D>, _dir: Directionality, _document: any);
+    _handleFocus(): void;
+    _viewChanged(type: GIPICalendarView): void;
+    ngOnDestroy(): void;
+    /** Selects the given date */
+    _select(date: D): void;
+    /**
+     * Register an input with this datepicker.
+     * @param input The datepicker input to register with this datepicker.
+     */
+    _registerInput(input: GIPIDatetimepickerInputDirective<D>): void;
+    /** Open the calendar. */
+    open(): void;
+    /** Close the calendar. */
+    close(): void;
+    /** Open the calendar as a dialog. */
+    private _openAsDialog;
+    /** Open the calendar as a popup. */
+    private _openAsPopup;
+    /** Create the popup. */
+    private _createPopup;
+    /** Create the popup PositionStrategy. */
+    private _createPopupPositionStrategy;
+}

package/shared/gipi-components/datetime-picker/mat-datetime-picker/month-view.d.ts

@@ -0,0 +1,53 @@
+import { AfterContentInit, EventEmitter } from '@angular/core';
+import { GIPIDatetimepickerCalendarCell } from './calendar-body';
+import { GIPIDatetimepickerType } from './datetimepicker-type';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+import { GIPIDatetimeFormats } from './shared/adapter/datetime-formats';
+/**
+ * An internal component used to display a single month in the datepicker.
+ * @docs-private
+ */
+export declare class GIPIDatetimepickerMonthViewComponent<D> implements AfterContentInit {
+    _adapter: GIPIDatetimeAdapter<D>;
+    private _dateFormats;
+    /** Grid of calendar cells representing the dates of the month. */
+    _weeks: GIPIDatetimepickerCalendarCell[][];
+    /** 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;
+    /** The date of the month that today falls on. Null if today is in another month. */
+    _todayDate: number;
+    /** The names of the weekdays. */
+    _weekdays: {
+        long: string;
+        narrow: string;
+    }[];
+    _calendarState: string;
+    type: GIPIDatetimepickerType;
+    /** A function used to filter which dates are selectable. */
+    dateFilter: (date: D) => boolean;
+    /** The date to display in this month view (everything other than the month and year is ignored). */
+    private _activeDate;
+    get activeDate(): D;
+    set activeDate(value: D);
+    /** The currently selected date. */
+    private _selected;
+    get selected(): D;
+    set selected(value: D);
+    /** Emits when a new date is selected. */
+    selectedChange: EventEmitter<D>;
+    _userSelection: EventEmitter<void>;
+    constructor(_adapter: GIPIDatetimeAdapter<D>, _dateFormats: GIPIDatetimeFormats);
+    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 calendarState;
+}