@gipisistemas/ng-core 1.0.67 → 1.0.68

package/shared/gipi-components/datepicker/mat-datepicker/calendar.d.ts

@@ -0,0 +1,152 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { AfterContentInit, AfterViewChecked, AfterViewInit, ChangeDetectorRef, EventEmitter, OnChanges, OnDestroy, SimpleChanges, TemplateRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { MatCalendarCellClassFunction, MatCalendarUserEvent } from './calendar-body';
+import { DateRange } from './date-selection-model';
+import { MatDatepickerIntl } from './datepicker-intl';
+import { MatMonthView } from './month-view';
+import { MatMultiYearView } from './multi-year-view';
+import { DateAdapter } from './shared/adapter/date-adapter';
+import { MatDateFormats } from './shared/adapter/date-formats';
+import { MatYearView } from './year-view';
+/**
+ * Possible views for the calendar.
+ * @docs-private
+ */
+export declare type MatCalendarView = 'month' | 'year' | 'multi-year';
+/**
+ * A calendar that is used as part of the datepicker.
+ * @docs-private
+ */
+export declare class MatCalendar<D> implements AfterContentInit, AfterViewChecked, OnDestroy, OnChanges {
+    private _dateAdapter;
+    private _dateFormats;
+    private _changeDetectorRef;
+    matCalendarRef: MatCalendar<D>;
+    /** Created by GIPI Sistemas */
+    templatePresetRange: TemplateRef<any>;
+    private _intlChanges;
+    /**
+     * Used for scheduling that focus should be moved to the active cell on the next tick.
+     * We need to schedule it, rather than do it immediately, because we have to wait
+     * for Angular to re-evaluate the view children.
+     */
+    private _moveFocusOnNextTick;
+    /** A date representing the period (month or year) to start the calendar in. */
+    get startAt(): D | null;
+    set startAt(value: D | null);
+    private _startAt;
+    /** Whether the calendar should be started in month or year view. */
+    startView: MatCalendarView;
+    /** The currently selected date. */
+    get selected(): DateRange<D> | D | null;
+    set selected(value: DateRange<D> | D | null);
+    private _selected;
+    /** The minimum selectable date. */
+    get minDate(): D | null;
+    set minDate(value: D | null);
+    private _minDate;
+    /** The maximum selectable date. */
+    get maxDate(): D | null;
+    set maxDate(value: D | null);
+    private _maxDate;
+    /** Function used to filter which dates are selectable. */
+    dateFilter: (date: D) => boolean;
+    /** Function that can be used to add custom CSS classes to dates. */
+    dateClass: MatCalendarCellClassFunction<D>;
+    /** Start of the comparison range. */
+    comparisonStart: D | null;
+    /** End of the comparison range. */
+    comparisonEnd: D | null;
+    /**
+     * Emits when the currently selected date changes.
+     * @breaking-change 11.0.0 Emitted value to change to `D | null`.
+     */
+    readonly selectedChange: EventEmitter<D>;
+    /**
+     * Emits the year chosen in multiyear view.
+     * This doesn't imply a change on the selected date.
+     */
+    readonly yearSelected: EventEmitter<D>;
+    /**
+     * Emits the month chosen in year view.
+     * This doesn't imply a change on the selected date.
+     */
+    readonly monthSelected: EventEmitter<D>;
+    /** Emits when any date is selected. */
+    readonly _userSelection: EventEmitter<MatCalendarUserEvent<D | null>>;
+    /** Reference to the current month view component. */
+    monthView: MatMonthView<D>;
+    /** Reference to the current year view component. */
+    yearView: MatYearView<D>;
+    /** Reference to the current multi-year view component. */
+    multiYearView: MatMultiYearView<D>;
+    /**
+     * 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);
+    private _clampedActiveDate;
+    /** Whether the calendar is in month view. */
+    get currentView(): MatCalendarView;
+    set currentView(value: MatCalendarView);
+    private _currentView;
+    /**
+     * Emits whenever there is a state change that the header may need to respond to.
+     */
+    stateChanges: Subject<void>;
+    constructor(_intl: MatDatepickerIntl, _dateAdapter: DateAdapter<D>, _dateFormats: MatDateFormats, _changeDetectorRef: ChangeDetectorRef);
+    ngAfterContentInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    focusActiveCell(): void;
+    /** Updates today's date after an update of the active date */
+    updateTodaysDate(): void;
+    /** Handles date selection in the month view. */
+    _dateSelected(event: MatCalendarUserEvent<D | null>): void;
+    /** Handles year selection in the multiyear view. */
+    _yearSelectedInMultiYearView(normalizedYear: D): void;
+    /** Handles month selection in the year view. */
+    _monthSelectedInYearView(normalizedMonth: D): void;
+    /** Handles year/month selection in the multi-year/year views. */
+    _goToDateInView(date: D, view: 'month' | 'year' | 'multi-year'): void;
+    /** Returns the component instance that corresponds to the current calendar view. */
+    private _getCurrentViewComponent;
+}
+/** Default header for MatCalendar */
+export declare class MatCalendarHeader<D> implements AfterViewInit {
+    private _intl;
+    private _dateAdapter;
+    private _dateFormats;
+    private _changeDetectorRef;
+    matCalendar: MatCalendar<D>;
+    constructor(_intl: MatDatepickerIntl, _dateAdapter: DateAdapter<D>, _dateFormats: MatDateFormats, _changeDetectorRef: ChangeDetectorRef);
+    ngAfterViewInit(): void;
+    /** The label for the current matCalendar view. */
+    get periodButtonText(): string;
+    get periodButtonLabel(): string;
+    /** The label for the previous button. */
+    get prevButtonLabel(): string;
+    /** The label for the next button. */
+    get nextButtonLabel(): string;
+    /** Handles user clicks on the period label. */
+    currentPeriodClicked(): 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;
+    /** Whether the two dates represent the same view in the current view mode (month or year). */
+    private _isSameView;
+}

package/shared/gipi-components/datepicker/mat-datepicker/date-range-input-parts.d.ts

@@ -0,0 +1,102 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DoCheck, ElementRef, InjectionToken, Injector, OnInit } from '@angular/core';
+import { FormGroupDirective, NgControl, NgForm, ValidatorFn } from '@angular/forms';
+import { CanUpdateErrorState, CanUpdateErrorStateCtor, ErrorStateMatcher, MatDateFormats } from '@angular/material/core';
+import { DateRange, DateSelectionModelChange } from './date-selection-model';
+import { DateFilterFn, MatDatepickerInputBase } from './datepicker-input-base';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/** Parent component that should be wrapped around `MatStartDate` and `MatEndDate`. */
+export interface MatDateRangeInputParent<D> {
+    id: string;
+    min: D | null;
+    max: D | null;
+    dateFilter: DateFilterFn<D>;
+    rangePicker: {
+        opened: boolean;
+        id: string;
+    };
+    _startInput: MatDateRangeInputPartBase<D>;
+    _endInput: MatDateRangeInputPartBase<D>;
+    _groupDisabled: boolean;
+    _handleChildValueChange(): void;
+    _openDatepicker(): void;
+}
+/**
+ * Used to provide the date range input wrapper component
+ * to the parts without circular dependencies.
+ */
+export declare const MAT_DATE_RANGE_INPUT_PARENT: InjectionToken<MatDateRangeInputParent<unknown>>;
+/**
+ * Base class for the individual inputs that can be projected inside a `mat-date-range-input`.
+ */
+declare abstract class MatDateRangeInputPartBase<D> extends MatDatepickerInputBase<DateRange<D>> implements OnInit, DoCheck {
+    _rangeInput: MatDateRangeInputParent<D>;
+    _defaultErrorStateMatcher: ErrorStateMatcher;
+    private _injector;
+    _parentForm: NgForm;
+    _parentFormGroup: FormGroupDirective;
+    /** @docs-private */
+    ngControl: NgControl;
+    /** @docs-private */
+    abstract updateErrorState(): void;
+    protected abstract _validator: ValidatorFn | null;
+    protected abstract _assignValueToModel(value: D | null): void;
+    protected abstract _getValueFromModel(modelValue: DateRange<D>): D | null;
+    constructor(_rangeInput: MatDateRangeInputParent<D>, elementRef: ElementRef<HTMLInputElement>, _defaultErrorStateMatcher: ErrorStateMatcher, _injector: Injector, _parentForm: NgForm, _parentFormGroup: FormGroupDirective, dateAdapter: DateAdapter<D>, dateFormats: MatDateFormats);
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    /** Gets whether the input is empty. */
+    isEmpty(): boolean;
+    /** Gets the placeholder of the input. */
+    _getPlaceholder(): string;
+    /** Focuses the input. */
+    focus(): void;
+    /** Handles `input` events on the input element. */
+    _onInput(value: string): void;
+    /** Opens the datepicker associated with the input. */
+    protected _openPopup(): void;
+    /** Gets the minimum date from the range input. */
+    _getMinDate(): D;
+    /** Gets the maximum date from the range input. */
+    _getMaxDate(): D;
+    /** Gets the date filter function from the range input. */
+    protected _getDateFilter(): DateFilterFn<D>;
+    protected _outsideValueChanged: () => void;
+    protected _parentDisabled(): boolean;
+}
+declare const _MatDateRangeInputBase: CanUpdateErrorStateCtor & typeof MatDateRangeInputPartBase;
+/** Input for entering the start date in a `mat-date-range-input`. */
+export declare class MatStartDate<D> extends _MatDateRangeInputBase<D> implements CanUpdateErrorState, DoCheck, OnInit {
+    /** Validator that checks that the start date isn't after the end date. */
+    private _startValidator;
+    constructor(rangeInput: MatDateRangeInputParent<D>, elementRef: ElementRef<HTMLInputElement>, defaultErrorStateMatcher: ErrorStateMatcher, injector: Injector, parentForm: NgForm, parentFormGroup: FormGroupDirective, dateAdapter: DateAdapter<D>, dateFormats: MatDateFormats);
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    protected _validator: ValidatorFn;
+    protected _getValueFromModel(modelValue: DateRange<D>): D;
+    protected _assignValueToModel(value: D | null): void;
+    protected _canEmitChangeEvent: (event: DateSelectionModelChange<DateRange<D>>) => boolean;
+    protected _formatValue(value: D | null): void;
+    /** Gets the value that should be used when mirroring the input's size. */
+    getMirrorValue(): string;
+}
+/** Input for entering the end date in a `mat-date-range-input`. */
+export declare class MatEndDate<D> extends _MatDateRangeInputBase<D> implements CanUpdateErrorState, DoCheck, OnInit {
+    /** Validator that checks that the end date isn't before the start date. */
+    private _endValidator;
+    constructor(rangeInput: MatDateRangeInputParent<D>, elementRef: ElementRef<HTMLInputElement>, defaultErrorStateMatcher: ErrorStateMatcher, injector: Injector, parentForm: NgForm, parentFormGroup: FormGroupDirective, dateAdapter: DateAdapter<D>, dateFormats: MatDateFormats);
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    protected _validator: ValidatorFn;
+    protected _getValueFromModel(modelValue: DateRange<D>): D;
+    protected _assignValueToModel(value: D | null): void;
+    protected _canEmitChangeEvent: (event: DateSelectionModelChange<DateRange<D>>) => boolean;
+    _onKeydown(event: KeyboardEvent): void;
+}
+export {};

package/shared/gipi-components/datepicker/mat-datepicker/date-range-input.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { AfterContentInit, ChangeDetectorRef, ElementRef, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+import { ControlContainer, NgControl } from '@angular/forms';
+import { ThemePalette } from '@angular/material/core';
+import { MatFormField, MatFormFieldControl } from '@angular/material/form-field';
+import { Subject } from 'rxjs';
+import { MatDateRangeInputParent, MatEndDate, MatStartDate } from './date-range-input-parts';
+import { MatDateRangePicker, MatDateRangePickerInput } from './date-range-picker';
+import { DateRange } from './date-selection-model';
+import { MatDatepickerControl } from './datepicker-base';
+import { DateFilterFn } from './datepicker-input-base';
+import { DateAdapter } from './shared/adapter/date-adapter';
+export declare class MatDateRangeInput<D> implements MatFormFieldControl<DateRange<D>>, MatDatepickerControl<D>, MatDateRangeInputParent<D>, MatDateRangePickerInput<D>, AfterContentInit, OnChanges, OnDestroy {
+    private _changeDetectorRef;
+    private _elementRef;
+    private _dateAdapter;
+    private _formField?;
+    /** Current value of the range input. */
+    get value(): DateRange<D>;
+    /** Unique ID for the input. */
+    id: string;
+    /** Whether the control is focused. */
+    focused: boolean;
+    /** Whether the control's label should float. */
+    get shouldLabelFloat(): boolean;
+    /** Name of the form control. */
+    controlType: string;
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * Set the placeholder attribute on `matStartDate` and `matEndDate`.
+     * @docs-private
+     */
+    get placeholder(): string;
+    /** The range picker that this input is associated with. */
+    get rangePicker(): MatDateRangePicker<D>;
+    set rangePicker(rangePicker: MatDateRangePicker<D>);
+    private _rangePicker;
+    /** Whether the input is required. */
+    get required(): boolean;
+    set required(value: boolean);
+    private _required;
+    /** Function that can be used to filter out dates within the date range picker. */
+    get dateFilter(): DateFilterFn<D>;
+    set dateFilter(value: DateFilterFn<D>);
+    private _dateFilter;
+    /** The minimum valid date. */
+    get min(): D | null;
+    set min(value: D | null);
+    private _min;
+    /** The maximum valid date. */
+    get max(): D | null;
+    set max(value: D | null);
+    private _max;
+    /** Whether the input is disabled. */
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    _groupDisabled: boolean;
+    /** Whether the input is in an error state. */
+    get errorState(): boolean;
+    /** Whether the datepicker input is empty. */
+    get empty(): boolean;
+    /** Value for the `aria-describedby` attribute of the inputs. */
+    _ariaDescribedBy: string | null;
+    /** Date selection model currently registered with the input. */
+    private _model;
+    /** Separator text to be shown between the inputs. */
+    separator: string;
+    /** Start of the comparison range that should be shown in the calendar. */
+    comparisonStart: D | null;
+    /** End of the comparison range that should be shown in the calendar. */
+    comparisonEnd: D | null;
+    _startInput: MatStartDate<D>;
+    _endInput: MatEndDate<D>;
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * TODO(crisbeto): change type to `AbstractControlDirective` after #18206 lands.
+     * @docs-private
+     */
+    ngControl: NgControl | null;
+    /** Emits when the input's state has changed. */
+    stateChanges: Subject<void>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, _elementRef: ElementRef<HTMLElement>, control: ControlContainer, _dateAdapter: DateAdapter<D>, _formField?: MatFormField);
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * @docs-private
+     */
+    setDescribedByIds(ids: string[]): void;
+    /**
+     * Implemented as a part of `MatFormFieldControl`.
+     * @docs-private
+     */
+    onContainerClick(): void;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Gets the date at which the calendar should start. */
+    getStartValue(): D | null;
+    /** Gets the input's theme palette. */
+    getThemePalette(): ThemePalette;
+    /** Gets the element to which the calendar overlay should be attached. */
+    getConnectedOverlayOrigin(): ElementRef;
+    /** Gets the value that is used to mirror the state input. */
+    _getInputMirrorValue(): string;
+    /** Whether the input placeholders should be hidden. */
+    _shouldHidePlaceholders(): boolean;
+    /** Handles the value in one of the child inputs changing. */
+    _handleChildValueChange(): void;
+    /** Opens the date range picker associated with the input. */
+    _openDatepicker(): void;
+    /** Whether the separate text should be hidden. */
+    _shouldHideSeparator(): boolean;
+    /** Gets the value for the `aria-labelledby` attribute of the inputs. */
+    _getAriaLabelledby(): string;
+    /** Re-runs the validators on the start/end inputs. */
+    private _revalidate;
+    /** Registers the current date selection model with the start/end inputs. */
+    private _registerModel;
+}

package/shared/gipi-components/datepicker/mat-datepicker/date-range-picker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { DateRange } from './date-selection-model';
+import { MatDatepickerBase, MatDatepickerContent, MatDatepickerControl } from './datepicker-base';
+/**
+ * Input that can be associated with a date range picker.
+ * @docs-private
+ */
+export interface MatDateRangePickerInput<D> extends MatDatepickerControl<D> {
+    comparisonStart: D | null;
+    comparisonEnd: D | null;
+}
+/** Component responsible for managing the date range picker popup/dialog. */
+export declare class MatDateRangePicker<D> extends MatDatepickerBase<MatDateRangePickerInput<D>, DateRange<D>, D> {
+    protected _forwardContentValues(instance: MatDatepickerContent<DateRange<D>, D>): void;
+}

package/shared/gipi-components/datepicker/mat-datepicker/date-range-selection-strategy.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { FactoryProvider, InjectionToken } from '@angular/core';
+import { DateRange } from './date-selection-model';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/** Injection token used to customize the date range selection behavior. */
+export declare const MAT_DATE_RANGE_SELECTION_STRATEGY: InjectionToken<MatDateRangeSelectionStrategy<any>>;
+/** Object that can be provided in order to customize the date range selection behavior. */
+export interface MatDateRangeSelectionStrategy<D> {
+    /**
+     * Called when the user has finished selecting a value.
+     * @param date Date that was selected. Will be null if the user cleared the selection.
+     * @param currentRange Range that is currently show in the calendar.
+     * @param event DOM event that triggered the selection. Currently only corresponds to a `click`
+     *    event, but it may get expanded in the future.
+     */
+    selectionFinished(date: D | null, currentRange: DateRange<D>, event: Event): DateRange<D>;
+    /**
+     * Called when the user has activated a new date (e.g. by hovering over
+     * it or moving focus) and the calendar tries to display a date range.
+     *
+     * @param activeDate Date that the user has activated. Will be null if the user moved
+     *    focus to an element that's no a calendar cell.
+     * @param currentRange Range that is currently shown in the calendar.
+     * @param event DOM event that caused the preview to be changed. Will be either a
+     *    `mouseenter`/`mouseleave` or `focus`/`blur` depending on how the user is navigating.
+     */
+    createPreview(activeDate: D | null, currentRange: DateRange<D>, event: Event): DateRange<D>;
+}
+/** Provides the default date range selection behavior. */
+export declare class DefaultMatCalendarRangeStrategy<D> implements MatDateRangeSelectionStrategy<D> {
+    private _dateAdapter;
+    constructor(_dateAdapter: DateAdapter<D>);
+    selectionFinished(date: D, currentRange: DateRange<D>): DateRange<D>;
+    createPreview(activeDate: D | null, currentRange: DateRange<D>): DateRange<D>;
+}
+/** @docs-private */
+export declare function MAT_CALENDAR_RANGE_STRATEGY_PROVIDER_FACTORY(parent: MatDateRangeSelectionStrategy<unknown>, adapter: DateAdapter<unknown>): MatDateRangeSelectionStrategy<unknown>;
+/** @docs-private */
+export declare const MAT_CALENDAR_RANGE_STRATEGY_PROVIDER: FactoryProvider;

package/shared/gipi-components/datepicker/mat-datepicker/date-selection-model.d.ts

@@ -0,0 +1,106 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { FactoryProvider, OnDestroy } from '@angular/core';
+import { Observable } from 'rxjs';
+import { DateAdapter } from './shared/adapter/date-adapter';
+/** A class representing a range of dates. */
+export declare class DateRange<D> {
+    /** The start date of the range. */
+    readonly start: D | null;
+    /** The end date of the range. */
+    readonly end: D | null;
+    /**
+     * Ensures that objects with a `start` and `end` property can't be assigned to a variable that
+     * expects a `DateRange`
+     */
+    private _disableStructuralEquivalency;
+    constructor(
+    /** The start date of the range. */
+    start: D | null, 
+    /** The end date of the range. */
+    end: D | null);
+}
+/**
+ * Conditionally picks the date type, if a DateRange is passed in.
+ * @docs-private
+ */
+export declare type ExtractDateTypeFromSelection<T> = T extends DateRange<infer D> ? D : NonNullable<T>;
+/** Event emitted by the date selection model when its selection changes. */
+export interface DateSelectionModelChange<S> {
+    /** New value for the selection. */
+    selection: S;
+    /** Object that triggered the change. */
+    source: unknown;
+}
+/** A selection model containing a date selection. */
+export declare abstract class MatDateSelectionModel<S, D = any> implements OnDestroy {
+    /** The current selection. */
+    readonly selection: S;
+    protected _adapter: DateAdapter<D>;
+    private _selectionChanged;
+    /** Emits when the selection has changed. */
+    selectionChanged: Observable<DateSelectionModelChange<S>>;
+    protected constructor(
+    /** The current selection. */
+    selection: S, _adapter: DateAdapter<D>);
+    /**
+     * Updates the current selection in the model.
+     * @param value New selection that should be assigned.
+     * @param source Object that triggered the selection change.
+     */
+    updateSelection(value: S, source: unknown): void;
+    ngOnDestroy(): void;
+    protected _isValidDateInstance(date: D): boolean;
+    /** Adds a date to the current selection. */
+    abstract add(date: D | null): void;
+    /** Checks whether the current selection is valid. */
+    abstract isValid(): boolean;
+    /** Checks whether the current selection is complete. */
+    abstract isComplete(): boolean;
+}
+/**  A selection model that contains a single date. */
+export declare class MatSingleDateSelectionModel<D> extends MatDateSelectionModel<D | null, D> {
+    constructor(adapter: DateAdapter<D>);
+    /**
+     * Adds a date to the current selection. In the case of a single date selection, the added date
+     * simply overwrites the previous selection
+     */
+    add(date: D | null): void;
+    /** Checks whether the current selection is valid. */
+    isValid(): boolean;
+    /**
+     * Checks whether the current selection is complete. In the case of a single date selection, this
+     * is true if the current selection is not null.
+     */
+    isComplete(): boolean;
+}
+/**  A selection model that contains a date range. */
+export declare class MatRangeDateSelectionModel<D> extends MatDateSelectionModel<DateRange<D>, D> {
+    constructor(adapter: DateAdapter<D>);
+    /**
+     * Adds a date to the current selection. In the case of a date range selection, the added date
+     * fills in the next `null` value in the range. If both the start and the end already have a date,
+     * the selection is reset so that the given date is the new `start` and the `end` is null.
+     */
+    add(date: D | null): void;
+    /** Checks whether the current selection is valid. */
+    isValid(): boolean;
+    /**
+     * Checks whether the current selection is complete. In the case of a date range selection, this
+     * is true if the current selection has a non-null `start` and `end`.
+     */
+    isComplete(): boolean;
+}
+/** @docs-private */
+export declare function MAT_SINGLE_DATE_SELECTION_MODEL_FACTORY(parent: MatSingleDateSelectionModel<unknown>, adapter: DateAdapter<unknown>): MatSingleDateSelectionModel<unknown>;
+/** Used to provide a single selection model to a component. */
+export declare const MAT_SINGLE_DATE_SELECTION_MODEL_PROVIDER: FactoryProvider;
+/** @docs-private */
+export declare function MAT_RANGE_DATE_SELECTION_MODEL_FACTORY(parent: MatSingleDateSelectionModel<unknown>, adapter: DateAdapter<unknown>): MatSingleDateSelectionModel<unknown> | MatRangeDateSelectionModel<unknown>;
+/** Used to provide a range selection model to a component. */
+export declare const MAT_RANGE_DATE_SELECTION_MODEL_PROVIDER: FactoryProvider;

package/shared/gipi-components/datepicker/mat-datepicker/datepicker-animations.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { AnimationTriggerMetadata } from '@angular/animations';
+/**
+ * Animations used by the Material datepicker.
+ * @docs-private
+ */
+export declare const matDatepickerAnimations: {
+    readonly transformPanel: AnimationTriggerMetadata;
+    readonly fadeInCalendar: AnimationTriggerMetadata;
+};