@gipisistemas/ng-core 1.1.0 → 1.1.1

package/shared/components/textarea/textarea.component.d.ts

@@ -0,0 +1,35 @@
+import { ElementRef, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+export declare class TextareaComponent implements ControlValueAccessor, OnInit {
+    _elementRef: ElementRef;
+    name: string;
+    label: string;
+    placeholder: string;
+    disabled: boolean;
+    required: boolean;
+    maxlength: number;
+    rows: number;
+    appearance: string;
+    val: any;
+    get value(): any;
+    set value(val: any);
+    upperCase: boolean;
+    mentionConfiguration: {};
+    private _minHeight;
+    get minHeight(): string;
+    set minHeight(value: string);
+    private _height;
+    get height(): string;
+    set height(value: string);
+    private _maxHeight;
+    get maxHeight(): string;
+    set maxHeight(value: string);
+    constructor();
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: any): void;
+    checkUppercase(value: any): any;
+}

package/shared/directives/dynamic-tab.directive.d.ts

@@ -0,0 +1,5 @@
+import { ViewContainerRef } from '@angular/core';
+export declare class DynamicTabDirective {
+    viewContainer: ViewContainerRef;
+    constructor(viewContainer: ViewContainerRef);
+}

package/shared/directives/generic-template.directive.d.ts

@@ -0,0 +1,8 @@
+import { TemplateRef } from '@angular/core';
+export declare class ItssTemplate {
+    template: TemplateRef<any>;
+    type: string;
+    name: string;
+    constructor(template: TemplateRef<any>);
+    getType(): string;
+}

package/shared/directives/input-select-infinite-scroll.directive.d.ts

@@ -0,0 +1,35 @@
+import { AfterViewInit, EventEmitter, NgZone, OnDestroy, OnInit } from '@angular/core';
+import { MatSelect } from '@angular/material/select';
+/**
+ * Esta diretiva foi reescrita utilizando se do projeto a seguir
+ * https://github.com/HaidarZ/ng-mat-select-infinite-scroll
+ */
+export declare class InputSelectInfiniteScrollDirective implements OnInit, OnDestroy, AfterViewInit {
+    private matSelect;
+    private ngZone;
+    /**
+     * A distância limite da parte inferior da lista de opções para chamar o evento
+     * infiniteScroll quando rolado. O valor limite pode ser em porcentagem ou em
+     * pixels. Por exemplo, use o valor de 10%para que o infiniteScrollevento de saída
+     * seja chamado quando o usuário precisar de 10% para chegar ao fundo.
+     */
+    threshold: string;
+    /** O tempo limite antes de disparar o evento infiniteScroll */
+    debounceTime: number;
+    complete: boolean;
+    /** Emitido quando o scroller dentro do mat-select atinge a distância necessária */
+    infiniteScroll: EventEmitter<void>;
+    private _panel;
+    private _thrPx;
+    private _thrPc;
+    private _singleOptionHeight;
+    private _destroyed$;
+    constructor(matSelect: MatSelect, ngZone: NgZone);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    evaluateThreshold(): void;
+    registerScrollListener(): void;
+    handleScrollEvent(event: any): void;
+    getSelectItemHeightPx(): number;
+}

package/shared/directives/lower-case.directive.d.ts

@@ -0,0 +1,9 @@
+import { NgControl } from '@angular/forms';
+export declare class LowerCaseDirective {
+    ngControl: NgControl;
+    enabledLowerCase: boolean;
+    constructor(ngControl: NgControl);
+    ngModelChange(event: any): void;
+    keydown(event: any): void;
+    onInputChange(event: any): void;
+}

package/shared/directives/phone-mask.directive.d.ts

@@ -0,0 +1,8 @@
+import { NgControl } from '@angular/forms';
+export declare class PhoneMaskDirective {
+    ngControl: NgControl;
+    constructor(ngControl: NgControl);
+    onModelChange(event: any): void;
+    keydownBackspace(event: any): void;
+    onInputChange(event: any, backspace: any): void;
+}

package/shared/directives/space-drop.directive.d.ts

@@ -0,0 +1,9 @@
+import { NgControl } from '@angular/forms';
+export declare class SpaceDropDirective {
+    ngControl: NgControl;
+    spaceDrop: boolean;
+    constructor(ngControl: NgControl);
+    ngModelChange(event: any): void;
+    keydown(event: any): void;
+    onInputChange(event: any): void;
+}

package/shared/directives/upper-case.directive.d.ts

@@ -0,0 +1,9 @@
+import { NgControl } from '@angular/forms';
+export declare class UpperCaseDirective {
+    ngControl: NgControl;
+    enabledUpperCase: boolean;
+    constructor(ngControl: NgControl);
+    ngModelChange(event: any): void;
+    keydown(event: any): void;
+    onInputChange(event: any): void;
+}

package/shared/gipi-components/abstract-form/abstract-form.component.d.ts

@@ -0,0 +1,21 @@
+import { OnInit } from '@angular/core';
+import { GIPIActionRowComponent } from '../action-row/action-row.component';
+export declare class GIPIAbstractFormComponent implements OnInit {
+    attrId: string;
+    attrName: string;
+    get attrMargin(): "0" | "0 auto";
+    GIPIActionRowComponent: GIPIActionRowComponent;
+    set id(value: string);
+    set name(value: string);
+    flexDirection: 'row' | 'column';
+    gap: string | number;
+    alignItems: 'start' | 'center' | 'end' | 'flex-start' | 'flex-end' | 'stretch';
+    justifyContent: 'start' | 'center' | 'end' | 'flex-start' | 'flex-end' | 'space-around' | 'space-between' | 'space-evenly' | 'stretch';
+    padding: string | number;
+    dialog: boolean;
+    loading: boolean;
+    get getPadding(): string;
+    get getGap(): string;
+    constructor();
+    ngOnInit(): void;
+}

package/shared/gipi-components/action-row/action-row.component.d.ts

@@ -0,0 +1,5 @@
+import { OnInit } from '@angular/core';
+export declare class GIPIActionRowComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+}

package/shared/gipi-components/badge/badge.component.d.ts

@@ -0,0 +1,8 @@
+import { OnInit } from '@angular/core';
+export declare class GIPIBadgeComponent implements OnInit {
+    label: string;
+    color: string;
+    textColor: string;
+    constructor();
+    ngOnInit(): void;
+}

package/shared/gipi-components/button/button.component.d.ts

@@ -0,0 +1,56 @@
+import { ElementRef, EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { GIPIPopoverTrigger } from '../popover/shared/popover-trigger';
+declare type ButtonIconPosition = 'left' | 'right' | 'top' | 'bottom' | 'center';
+export declare class GIPIButtonComponent implements OnInit, OnDestroy {
+    private _elementRef;
+    readonly isButtonPrimary: boolean;
+    readonly isButtonPrimaryIcon: boolean;
+    readonly isButtonSecondary: boolean;
+    readonly isButtonSecondaryIcon: boolean;
+    readonly isButtonTertiary: boolean;
+    readonly isButtonTertiaryIcon: boolean;
+    readonly isButtonLink: boolean;
+    readonly isButtonIcon: boolean;
+    readonly isButtonAction: boolean;
+    _overlayVisible: boolean;
+    popoverTrigger: GIPIPopoverTrigger;
+    id: string;
+    name: string;
+    type: 'button' | 'submit' | 'reset';
+    ariaLabel: string;
+    title: string;
+    label: string;
+    buttonClass: string;
+    buttonPadding: number | string;
+    iconWidth: number | string;
+    iconHeight: number | string;
+    icon: string;
+    svgIcon: string;
+    iconPos: ButtonIconPosition;
+    disabled: boolean;
+    loading: boolean;
+    notification: boolean;
+    tooltip: string;
+    popover: boolean;
+    overlay: boolean;
+    isForInput: boolean;
+    onShowOverlay: EventEmitter<void>;
+    onOpenPopover: EventEmitter<void>;
+    onClosePopover: EventEmitter<void>;
+    onClick: EventEmitter<MouseEvent>;
+    onFocus: EventEmitter<MouseEvent>;
+    onBlur: EventEmitter<MouseEvent>;
+    constructor(_elementRef: ElementRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    getHostElement(): any;
+    private _hasHostAttributes;
+    toggleOverlay(): void;
+    showPopover(): void;
+    closePopover(): void;
+    handleClick(event: MouseEvent): void;
+    handleFocus(event: MouseEvent): void;
+    handleBlur(event: MouseEvent): void;
+    onResize(event: UIEvent): void;
+}
+export {};

package/shared/gipi-components/chips/chips.component.d.ts

@@ -0,0 +1,37 @@
+import { ChangeDetectorRef, ElementRef, EventEmitter, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+export declare class RemoveChange<T> {
+    chip: T;
+    index: number;
+}
+export declare class GIPIChipsComponent<T> implements OnInit, ControlValueAccessor {
+    private _changeDetectorRef;
+    elementRef: ElementRef;
+    private _name;
+    id: number | string;
+    name: string;
+    label: string;
+    labelRemoveAll: string;
+    ariaLabel: string;
+    disabled: boolean;
+    showRemovableAll: boolean;
+    showRemovable: boolean;
+    property: string;
+    private _value;
+    set value(value: T[]);
+    get value(): T[];
+    onFocus: EventEmitter<Event>;
+    onClick: EventEmitter<Event>;
+    removeChange: EventEmitter<RemoveChange<T>>;
+    removeAllChange: EventEmitter<void>;
+    constructor(_changeDetectorRef: ChangeDetectorRef, elementRef: ElementRef);
+    ngOnInit(): void;
+    onChange: any;
+    onTouch: any;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(value: boolean): void;
+    removeChip(chip: T, index: number): void;
+    removeAllChips(): void;
+}

package/shared/gipi-components/confirmation-dialog/confirmation-dialog.component.d.ts

@@ -0,0 +1,11 @@
+import { OnInit } from '@angular/core';
+import { MatDialogRef } from '@angular/material';
+import { AppMessages } from '../../../core/app-messages';
+import { ConfirmationDTO } from '../../../core/models/dto/confirmation.dto';
+export declare class GIPIConfirmationDialogComponent implements OnInit {
+    dialogRef: MatDialogRef<GIPIConfirmationDialogComponent>;
+    confirmation: ConfirmationDTO;
+    messages: AppMessages;
+    constructor(dialogRef: MatDialogRef<GIPIConfirmationDialogComponent>, confirmation: ConfirmationDTO, messages: AppMessages);
+    ngOnInit(): void;
+}

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

@@ -0,0 +1,71 @@
+import { ChangeDetectorRef, ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { DateRange } from '../mat-datepicker/date-selection-model';
+import { DateFilterFn } from '../mat-datepicker/datepicker-input-base';
+import { MatDatepickerToggle } from '../mat-datepicker/datepicker-toggle';
+import { PresetRanges } from './shared/preset-range/preset-range.component';
+export declare let nextUniqueId: number;
+export declare class DateRangePickerComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    matDatepickerToggleRef: MatDatepickerToggle<Date>;
+    private _name;
+    private _startDate;
+    get startDate(): Date;
+    set startDate(value: Date);
+    private _endDate;
+    get endDate(): Date;
+    set endDate(value: Date);
+    idStartDate: string;
+    idEndDate: string;
+    nameStartDate: string;
+    nameEndDate: string;
+    label: string;
+    placeholderStartDate: string;
+    placeholderEndDate: string;
+    help: string;
+    separator: string;
+    private _customRangeLabel;
+    get customRangeLabel(): string;
+    set customRangeLabel(value: string);
+    private _ranges;
+    get ranges(): PresetRanges<Date>;
+    set ranges(value: PresetRanges<Date>);
+    private _maxRange;
+    get maxRange(): number;
+    set maxRange(value: number);
+    private _minDate;
+    get minDate(): Date;
+    set minDate(value: Date);
+    private _maxDate;
+    get maxDate(): Date;
+    set maxDate(value: Date);
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    private _readonly;
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _dateFilter;
+    get dateFilter(): DateFilterFn<Date>;
+    set dateFilter(value: DateFilterFn<Date>);
+    private _value;
+    get value(): DateRange<Date>;
+    set value(value: DateRange<Date>);
+    onChange: Function;
+    onTouched: Function;
+    get formattedValue(): string;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: DateRange<Date>): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onInputContentClick(event: MouseEvent): void;
+    generatedStartDate(valueDate: string, keyUp: boolean): void;
+    generatedEndDate(valueDate: string, keyUp: boolean): void;
+}

package/shared/gipi-components/datepicker/date-range-picker/shared/max-range/max-range-selection-startegy.d.ts

@@ -0,0 +1,11 @@
+import { MatDateRangeSelectionStrategy } from "../../../mat-datepicker/date-range-selection-strategy";
+import { DateRange } from "../../../mat-datepicker/date-selection-model";
+import { DateAdapter } from "../../../mat-datepicker/shared/adapter/date-adapter";
+export declare class MaxRangeSelectionStrategy<D> implements MatDateRangeSelectionStrategy<D> {
+    private _dateAdapter;
+    start: any;
+    delta: number;
+    constructor(_dateAdapter: DateAdapter<D>);
+    selectionFinished(date: D, currentRange: DateRange<D>): DateRange<D>;
+    createPreview(activeDate: D | null, currentRange: DateRange<D>): DateRange<D>;
+}

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

@@ -0,0 +1,6 @@
+import { MaxRangeSelectionStrategy } from './max-range-selection-startegy';
+export declare class MaxRangeDirective {
+    private maxRangeStrategy;
+    constructor(maxRangeStrategy: MaxRangeSelectionStrategy<any>);
+    set maxRange(value: number);
+}

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

@@ -0,0 +1,40 @@
+import { ChangeDetectorRef, OnDestroy, OnInit } from '@angular/core';
+import { MatCalendar } from '../../../mat-datepicker/calendar';
+import { MatDateRangeInput } from '../../../mat-datepicker/date-range-input';
+import { MatDateRangePicker } from '../../../mat-datepicker/date-range-picker';
+export interface PresetRanges<D> {
+    [index: string]: [D, D];
+}
+export declare class PresetRangeComponent implements OnInit, OnDestroy {
+    private _changeDetectorRef;
+    private readonly _destroy$;
+    rangesArray: string[];
+    selectedRange: string;
+    matDateRangeInput: MatDateRangeInput<Date>;
+    matCalendar: MatCalendar<Date>;
+    matDateRangePicker: MatDateRangePicker<Date>;
+    private _customRangeLabel;
+    get customRangeLabel(): string;
+    set customRangeLabel(value: string);
+    private _ranges;
+    get ranges(): PresetRanges<moment.Moment>;
+    set ranges(value: PresetRanges<moment.Moment>);
+    private _maxRange;
+    get maxRange(): number;
+    set maxRange(value: number);
+    private get _startDate();
+    private get _endDate();
+    private get _minDate();
+    private get _maxDate();
+    constructor(_changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private _renderRanges;
+    private _loadSelectedRange;
+    private _calculateDateRange;
+    private _getValidDateOrNull;
+    private _isDateInstance;
+    private _isValid;
+    clickRange(event: MouseEvent, range: string): void;
+    isDisableRange(range: string): boolean;
+}

package/shared/gipi-components/datepicker/datepicker/datepicker.component.d.ts

@@ -0,0 +1,49 @@
+import { ChangeDetectorRef, ElementRef, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { DateFilterFn } from '../mat-datepicker/datepicker-input-base';
+import { MatDatepickerToggle } from '../mat-datepicker/datepicker-toggle';
+export declare class DatepickerComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    elementRef: ElementRef;
+    private _changeDetectorRef;
+    matDatepickerToggleRef: MatDatepickerToggle<Date>;
+    private _name;
+    id: string;
+    name: string;
+    label: string;
+    placeholder: string;
+    help: string;
+    private _minDate;
+    get minDate(): Date;
+    set minDate(value: Date);
+    private _maxDate;
+    get maxDate(): Date;
+    set maxDate(value: Date);
+    private _required;
+    get required(): boolean;
+    set required(value: boolean);
+    private _readonly;
+    get readonly(): boolean;
+    set readonly(value: boolean);
+    private _disabled;
+    get disabled(): boolean;
+    set disabled(value: boolean);
+    private _dateFilter;
+    get dateFilter(): DateFilterFn<Date>;
+    set dateFilter(value: DateFilterFn<Date>);
+    private _value;
+    get value(): Date;
+    set value(value: Date);
+    onChange: Function;
+    onTouched: Function;
+    get formattedValue(): string;
+    constructor(elementRef: ElementRef, _changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    writeValue(value: Date): void;
+    registerOnChange(fn: Function): void;
+    registerOnTouched(fn: Function): void;
+    setDisabledState?(isDisabled: boolean): void;
+    onInputContentClick(event: MouseEvent): void;
+    generatedDate(valueDate: string, keyUp: boolean): void;
+    validateMinAndMaxDate(valueDate: string): void;
+}

package/shared/gipi-components/datepicker/datepicker.module.d.ts

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

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

@@ -0,0 +1,143 @@
+/**
+ * @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 { ElementRef, EventEmitter, NgZone, OnChanges, OnDestroy, SimpleChanges } from '@angular/core';
+/** Extra CSS classes that can be associated with a calendar cell. */
+export declare type MatCalendarCellCssClasses = string | string[] | Set<string> | {
+    [key: string]: any;
+};
+/** Function that can generate the extra classes that should be added to a calendar cell. */
+export declare type MatCalendarCellClassFunction<D> = (date: D, view: 'month' | 'year' | 'multi-year') => MatCalendarCellCssClasses;
+/**
+ * An internal class that represents the data corresponding to a single calendar cell.
+ * @docs-private
+ */
+export declare class MatCalendarCell<D = any> {
+    value: number;
+    displayValue: string;
+    ariaLabel: string;
+    enabled: boolean;
+    cssClasses: MatCalendarCellCssClasses;
+    compareValue: number;
+    rawValue?: D;
+    constructor(value: number, displayValue: string, ariaLabel: string, enabled: boolean, cssClasses?: MatCalendarCellCssClasses, compareValue?: number, rawValue?: D);
+}
+/** Event emitted when a date inside the calendar is triggered as a result of a user action. */
+export interface MatCalendarUserEvent<D> {
+    value: D;
+    event: Event;
+}
+/**
+ * An internal component used to display calendar data in a table.
+ * @docs-private
+ */
+export declare class MatCalendarBody implements OnChanges, OnDestroy {
+    private _elementRef;
+    private _ngZone;
+    /**
+     * Used to skip the next focus event when rendering the preview range.
+     * We need a flag like this, because some browsers fire focus events asynchronously.
+     */
+    private _skipNextFocus;
+    /** The label for the table. (e.g. "Jan 2017"). */
+    label: string;
+    /** The cells to display in the table. */
+    rows: MatCalendarCell[][];
+    /** The value in the table that corresponds to today. */
+    todayValue: number;
+    /** Start value of the selected date range. */
+    startValue: number;
+    /** End value of the selected date range. */
+    endValue: 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;
+    /** The cell number of the active cell in the table. */
+    activeCell: number;
+    /** Whether a range is being selected. */
+    isRange: boolean;
+    /**
+     * 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;
+    /** Start of the comparison range. */
+    comparisonStart: number | null;
+    /** End of the comparison range. */
+    comparisonEnd: number | null;
+    /** Start of the preview range. */
+    previewStart: number | null;
+    /** End of the preview range. */
+    previewEnd: number | null;
+    /** Emits when a new value is selected. */
+    readonly selectedValueChange: EventEmitter<MatCalendarUserEvent<number>>;
+    /** Emits when the preview has changed as a result of a user action. */
+    previewChange: EventEmitter<MatCalendarUserEvent<MatCalendarCell<any>>>;
+    /** 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;
+    constructor(_elementRef: ElementRef<HTMLElement>, _ngZone: NgZone);
+    /** Called when a cell is clicked. */
+    _cellClicked(cell: MatCalendarCell, event: MouseEvent): void;
+    /** Returns whether a cell should be marked as selected. */
+    _isSelected(value: number): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /** Returns whether a cell is active. */
+    _isActiveCell(rowIndex: number, colIndex: number): boolean;
+    /** Focuses the active cell after the microtask queue is empty. */
+    _focusActiveCell(movePreview?: boolean): void;
+    /** Gets whether a value is the start of the main range. */
+    _isRangeStart(value: number): boolean;
+    /** Gets whether a value is the end of the main range. */
+    _isRangeEnd(value: number): boolean;
+    /** Gets whether a value is within the currently-selected range. */
+    _isInRange(value: number): boolean;
+    /** Gets whether a value is the start of the comparison range. */
+    _isComparisonStart(value: number): boolean;
+    /** Whether the cell is a start bridge cell between the main and comparison ranges. */
+    _isComparisonBridgeStart(value: number, rowIndex: number, colIndex: number): boolean;
+    /** Whether the cell is an end bridge cell between the main and comparison ranges. */
+    _isComparisonBridgeEnd(value: number, rowIndex: number, colIndex: number): boolean;
+    /** Gets whether a value is the end of the comparison range. */
+    _isComparisonEnd(value: number): boolean;
+    /** Gets whether a value is within the current comparison range. */
+    _isInComparisonRange(value: number): boolean;
+    /**
+     * Gets whether a value is the same as the start and end of the comparison range.
+     * For context, the functions that we use to determine whether something is the start/end of
+     * a range don't allow for the start and end to be on the same day, because we'd have to use
+     * much more specific CSS selectors to style them correctly in all scenarios. This is fine for
+     * the regular range, because when it happens, the selected styles take over and still show where
+     * the range would've been, however we don't have these selected styles for a comparison range.
+     * This function is used to apply a class that serves the same purpose as the one for selected
+     * dates, but it only applies in the context of a comparison range.
+     */
+    _isComparisonIdentical(value: number): boolean;
+    /** Gets whether a value is the start of the preview range. */
+    _isPreviewStart(value: number): boolean;
+    /** Gets whether a value is the end of the preview range. */
+    _isPreviewEnd(value: number): boolean;
+    /** Gets whether a value is inside the preview range. */
+    _isInPreview(value: number): boolean;
+    /**
+     * Event handler for when the user enters an element
+     * inside the calendar body (e.g. by hovering in or focus).
+     */
+    private _enterHandler;
+    /**
+     * Event handler for when the user's pointer leaves an element
+     * inside the calendar body (e.g. by hovering out or blurring).
+     */
+    private _leaveHandler;
+    /** Finds the MatCalendarCell that corresponds to a DOM node. */
+    private _getCellFromElement;
+}