import * as i0 from '@angular/core'; import { OnInit, OnDestroy, EventEmitter, ElementRef, InjectionToken, OnChanges, AfterContentInit, SimpleChanges, AfterViewChecked, AfterViewInit } from '@angular/core'; import * as i1 from '@angular/cdk/portal'; import { ComponentType, Portal } from '@angular/cdk/portal'; import * as i1$1 from '@angular/cdk/a11y'; import * as i2 from '@angular/cdk/overlay'; import { ScrollStrategy, Overlay, OverlayRef } from '@angular/cdk/overlay'; import * as i1$2 from '@sbb-esta/angular/core'; import { SbbDateAdapter, TypeRef } from '@sbb-esta/angular/core'; import * as i3 from '@sbb-esta/angular/icon'; import { Subject, Observable } from 'rxjs'; import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms'; /** * An event used for date 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 SbbDateInputEvent instead. */ declare class SbbDateInputEvent { /** Reference to the date input component that emitted the event. */ target: SbbDateInput; /** Reference to the native input element associated with the date input. */ targetElement: HTMLElement; /** The new value for the target date input. */ value: D | null; constructor( /** Reference to the date input component that emitted the event. */ target: SbbDateInput, /** Reference to the native input element associated with the date input. */ targetElement: HTMLElement); } declare const SBB_DATE_VALUE_ACCESSOR: any; declare const SBB_DATE_VALIDATORS: any; declare class SbbDateInput implements ControlValueAccessor, Validator, OnInit, OnDestroy { private _elementRef; _dateAdapter: SbbDateAdapter; private _dateFormats; _datepicker: SbbDatepicker; private _formField; /** Function that can be used to filter out dates within the datepicker. */ set dateFilter(value: (date: D | null) => boolean); get dateFilter(): (date: D | null) => boolean; private _dateFilter; /** The value of the input. */ get value(): D | null; set value(value: D | null); private _value; /** 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 datepicker-input is disabled. */ get disabled(): boolean; set disabled(value: boolean); private _disabled; /** Whether the element is readonly. */ get readonly(): boolean; set readonly(value: boolean); private _readonly; /** Emits when a `change` event is fired on this ``. */ readonly dateChange: EventEmitter>; /** Emits when an `input` event is fired on this ``. */ readonly dateInput: EventEmitter>; /** Emits when the input gets blurred. */ readonly inputBlurred: EventEmitter; /** Emits when the value changes (either due to user input or programmatic change). */ valueChange: EventEmitter; /** Emits when the disabled state has changed */ disabledChange: EventEmitter; /** Emits when the readonly state has changed */ readonlyChange: EventEmitter; private _datepickerSubscription; /** Whether the last value set on the input was valid. */ private _lastValueValid; /** `View -> model callback called when date input has been touched` */ _onTouched: () => void; /** `View -> model callback called when value changes` */ _cvaOnChange: (value: any) => void; 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; constructor(...args: unknown[]); ngOnInit(): void; ngOnDestroy(): void; /** @docs-private */ registerOnValidatorChange(fn: () => void): void; /** @docs-private */ 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(isDisabled: boolean): void; _onKeydown(event: TypeRef): void; _onInput(event: Event): void; _onChange(): void; /** Handles blur events on the input. */ _onBlur(): void; /** Formats a value and sets it on the input element. */ private _formatValue; /** * @param obj The object to check. * @returns The given object if it is both a date instance and valid, otherwise null. */ private _getValidDateOrNull; /** Gets the ID of an element that should be used a description for the calendar overlay. */ getOverlayLabelId(): string | null; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵdir: i0.ɵɵDirectiveDeclaration, "input[sbbDateInput]", ["sbbDateInput"], { "dateFilter": { "alias": "dateFilter"; "required": false; }; "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "dateChange": "dateChange"; "dateInput": "dateInput"; "inputBlurred": "inputBlurred"; }, never, never, true, never>; static ngAcceptInputType_disabled: unknown; static ngAcceptInputType_readonly: unknown; } /** Injection token that determines the scroll handling while the calendar is open. */ declare const SBB_DATEPICKER_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>; /** @docs-private */ declare function SBB_DATEPICKER_SCROLL_STRATEGY_FACTORY(overlay: Overlay): () => ScrollStrategy; /** @docs-private */ declare const SBB_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER: { provide: InjectionToken<() => ScrollStrategy>; deps: (typeof Overlay)[]; useFactory: typeof SBB_DATEPICKER_SCROLL_STRATEGY_FACTORY; }; declare class SbbDatepicker implements OnDestroy { private _overlay; private _viewContainerRef; private _changeDetectorRef; private _scrollStrategy; private _dateAdapter; readonly locale: string; /** An input indicating the type of the custom header component for the calendar, if set. */ calendarHeaderComponent: ComponentType; /** The date to open the calendar to initially. */ get startAt(): D | null; set startAt(value: D | null); private _startAt; /** Whether the datepicker pop-up should be disabled. */ get disabled(): boolean; set disabled(value: boolean); private _disabled?; /** Classes to be passed to the date picker panel. */ panelClass: string | string[]; /** Second datepicker to be used in 2 datepickers use case */ set connected(value: SbbDatepicker | null); get connected(): SbbDatepicker | null; private _connected; main: SbbDatepicker | null; /** * Whether arrows are enabled, which allow navigation to the next/previous day. * They also support min and max date limits. * Defaults to false. */ arrows: boolean; /** Whether arrows should be shown. */ get arrowsVisible(): boolean; /** Whether the datepicker toggle is enabled. Defaults to true. */ toggle: boolean; /** Whether the datepicker toggle should be hidden. Defaults to false. */ set notoggle(value: boolean); /** Whether the toggle should be shown. */ get toggleVisible(): boolean; /** Emits when the datepicker has been opened. */ openedStream: EventEmitter; /** Emits when the datepicker has been closed. */ closedStream: EventEmitter; /** Whether the calendar is open. */ get opened(): boolean; set opened(value: boolean); private _opened; /** The id for the datepicker calendar. */ id: string; /** The currently selected date. */ get selected(): D | null; set selected(value: D | null); private _validSelected; /** The minimum selectable date. */ get minDate(): D | null; /** The maximum selectable date. */ get maxDate(): D | null; /** Currently active date filter function. */ get dateFilter(): (date: D | null) => boolean; /** Whether the previous day is reachable and therefore next buttons should be shown or not. */ get prevDayActive(): boolean; /** Whether the next day is reachable and therefore next buttons should be shown or not. */ get nextDayActive(): boolean; /** The next day button's aria-label */ nextDayAriaLabel: string; /** The previous day button's aria-label */ prevDayAriaLabel: string; /** A reference to the overlay when the calendar is opened as a popup. */ popupRef: OverlayRef; /** A portal containing the calendar for this datepicker. */ private _calendarPortal; /** Reference to the component instantiated in popup mode. */ private _popupComponentRef; /** The element that was focused before the datepicker was opened. */ private _focusedElementBeforeOpen; /** Subscription to value changes in the associated input element. */ private _inputSubscription; private _inputChangeSubscription; private _connectedDatepickerSubscription; private _posStrategySubscription; private _mainDatepickerSubscription?; /** The input element this datepicker is associated with. */ datepickerInput: SbbDateInput; /** Emits when the datepicker is disabled. */ readonly disabledChange: Subject; /** Emits new selected date when selected date changes. */ readonly selectedChanged: Subject; private _injector; constructor(...args: unknown[]); ngOnDestroy(): void; /** Selects the given date */ select(date: D): void; /** Set next day as selected. */ nextDay(): void; /** Set previous day as selected. */ prevDay(): void; /** * Register an input with this datepicker. * @param input The datepicker input to register with this datepicker. */ registerInput(input: SbbDateInput): void; /** Open the calendar. */ open(): void; /** Close the calendar. */ close(): void; private _getPanelClasses; /** Open the calendar as a popup. */ private _openAsPopup; /** Create the popup. */ private _createPopup; /** Create the popup PositionStrategy. */ private _createPopupPositionStrategy; /** * @param obj The object to check. * @returns The given object if it is both a date instance and valid, otherwise null. */ private _getValidDateOrNull; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵcmp: i0.ɵɵComponentDeclaration, "sbb-datepicker", ["sbbDatepicker"], { "calendarHeaderComponent": { "alias": "calendarHeaderComponent"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "connected": { "alias": "connected"; "required": false; }; "arrows": { "alias": "arrows"; "required": false; }; "toggle": { "alias": "toggle"; "required": false; }; "notoggle": { "alias": "notoggle"; "required": false; }; "opened": { "alias": "opened"; "required": false; }; "nextDayAriaLabel": { "alias": "nextDayAriaLabel"; "required": false; }; "prevDayAriaLabel": { "alias": "prevDayAriaLabel"; "required": false; }; }, { "openedStream": "opened"; "closedStream": "closed"; }, never, ["*"], true, never>; static ngAcceptInputType_disabled: unknown; static ngAcceptInputType_arrows: unknown; static ngAcceptInputType_toggle: unknown; static ngAcceptInputType_notoggle: unknown; static ngAcceptInputType_opened: unknown; } declare class SbbDatepickerToggle implements OnDestroy, OnChanges, AfterContentInit { private _changeDetectorRef; _datepicker: SbbDatepicker; _labelShowCalendar: string; private _stateChanges; /** Tabindex for the toggle. */ tabIndex: number | null; /** Whether the toggle button is disabled. */ get disabled(): boolean; set disabled(value: boolean); private _disabled?; constructor(...args: unknown[]); ngOnChanges(changes: SimpleChanges): void; ngOnDestroy(): void; ngAfterContentInit(): void; /** Open datepicker calendar. */ open(event: Event): void; private _watchStateChanges; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵcmp: i0.ɵɵComponentDeclaration, "sbb-datepicker-toggle", never, { "tabIndex": { "alias": "tabIndex"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>; static ngAcceptInputType_disabled: unknown; } /** Extra CSS classes that can be associated with a calendar cell. */ type SbbCalendarCellCssClasses = string | string[] | Set | { [key: string]: any; }; /** Function that can generate the extra classes that should be added to a calendar cell. */ type SbbCalendarCellClassFunction = (date: D) => SbbCalendarCellCssClasses; /** * An internal class that represents the data corresponding to a single calendar cell. * @docs-private */ declare class SbbCalendarCell { value: number; displayValue: string; ariaLabel: string; enabled: boolean; rangeBackground?: string | null | undefined; cssClasses: SbbCalendarCellCssClasses; readonly id: number; constructor(value: number, displayValue: string, ariaLabel: string, enabled: boolean, rangeBackground?: string | null | undefined, cssClasses?: SbbCalendarCellCssClasses); } declare class SbbCalendarBody implements AfterViewChecked { private _elementRef; private _changeDetectorRef; /** * Used to focus the active cell after change detection has run. */ private _focusActiveCellAfterViewChecked; /** The label for the table. (e.g. "Jan 2017"). */ label: string; /** The cells to display in the table. */ set rows(rows: SbbCalendarCell[][]); get rows(): SbbCalendarCell[][]; private _rows; /** Week of year for each row. */ weeksInMonth: number[]; /** 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; /** Whether the week can be selected. */ isWeekSelectable: boolean; /** Whether the weekday can be selected. */ isWeekdaySelectable: boolean; /** Emits when a new value is selected. */ readonly selectedValueChange: EventEmitter; /** Emits when a week is selected */ readonly selectedWeekChange: EventEmitter; readonly activeDateChange: EventEmitter; private _injector; /** * Tracking function for rows based on their identity. Ideally we would use some sort of * key on the row, but that would require a breaking change for the `rows` input. We don't * use the built-in identity tracking, because it logs warnings. */ _trackRow: (row: SbbCalendarCell[]) => SbbCalendarCell[]; constructor(...args: unknown[]); ngAfterViewChecked(): void; cellClicked(cell: SbbCalendarCell): void; onWeekClicked(week: number): void; _emitActiveDateChange(cell: SbbCalendarCell, event: FocusEvent): void; /** The number of blank cells to put at the beginning for the first row. */ get firstRowOffset(): number; isActiveCell(rowIndex: number, colIndex: number): boolean; /** * Focuses the active cell after the microtask queue is empty. * * Adding a 0ms setTimeout seems to fix Voiceover losing focus when pressing PageUp/PageDown * (issue angular/components#24330). * * Determined a 0ms by gradually increasing duration from 0 and testing two use cases with screen * reader enabled: * * 1. Pressing PageUp/PageDown repeatedly with pausing between each key press. * 2. Pressing and holding the PageDown key with repeated keys enabled. * * Test 1 worked roughly 95-99% of the time with 0ms and got a little bit better as the duration * increased. Test 2 got slightly better until the duration was long enough to interfere with * repeated keys. If the repeated key speed was faster than the timeout duration, then pressing * and holding pagedown caused the entire page to scroll. * * Since repeated key speed can verify across machines, determined that any duration could * potentially interfere with repeated keys. 0ms would be best because it almost entirely * eliminates the focus being lost in Voiceover without causing unintended side effects. * Adding delay also complicates writing tests. */ focusActiveCell(): void; /** Focuses the active cell after change detection has run and the microtask queue is empty. */ _scheduleFocusActiveCellAfterViewChecked(): void; static ɵfac: i0.ɵɵFactoryDeclaration; static ɵcmp: i0.ɵɵComponentDeclaration; } declare class SbbDateRange { readonly start: D; readonly end: D; constructor(start: D, end: D); } declare class SbbMonthView implements AfterContentInit { _dateAdapter: SbbDateAdapter; readonly locale: string; private _changeDetectorRef; private _dateFormats; /** The date to display in this month view (everything other than the month and year is ignored). */ get activeDate(): D; set activeDate(value: D); private _activeDate; /** The currently selected date. */ get selected(): D | null; set selected(value: 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; /** A function used to filter which dates are selectable. */ dateFilter: (date: D) => boolean; /** Function that can be used to add custDom CSS classes to dates. */ get dateClass(): SbbCalendarCellClassFunction | null; set dateClass(dateClass: SbbCalendarCellClassFunction | null); _dateClass: SbbCalendarCellClassFunction | null; /** Whether to display the week number. */ showWeekNumbers: boolean; /** Whether the week can be selected. */ isWeekSelectable: boolean; /** Whether the weekday can be selected. */ isWeekdaySelectable: boolean; /** Emits when a new date is selected. */ readonly selectedChange: EventEmitter; /** Emits when a new week is selected. */ readonly selectedWeekChange: EventEmitter<{ week: number; rangeInMonth: SbbDateRange; } | null>; /** Emits when a weekday is selected. */ readonly selectedWeekdayChange: EventEmitter; /** Emits when any date is selected. */ readonly userSelection: EventEmitter; /** Emits when any date is activated. */ readonly activeDateChange: EventEmitter; /** The body of calendar table */ sbbCalendarBody: SbbCalendarBody; /** The label for this month (e.g. "January 2017"). */ monthLabel: string; /** Grid of calendar cells representing the dates of the month. */ weeks: SbbCalendarCell[][]; /** Week of year for each row. */ weeksInMonth: number[]; /** 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 weekday that is currently selected. */ selectedWeekday: 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; index: number; }[]; /** Currently active date range. */ get dateRange(): SbbDateRange | null; set dateRange(dateRange: SbbDateRange | null); private _dateRange; private _datePicker; constructor(...args: unknown[]); ngAfterContentInit(): void; /** Handles when a new date is selected. */ dateSelected(date: number): void; /** Handles week selection */ weekSelected(week: number): void; /** Handles weekday selection. */ weekdaySelected(weekday: number): void; /** * Takes the index of a calendar body cell wrapped in an event as argument. For the date that * corresponds to the given cell, set `activeDate` to that date and fire `activeDateChange` with * that date. * * This function is used to match each component's model of the active date with the calendar * body cell that was focused. It updates its value of `activeDate` synchronously and updates the * parent's value asynchronously via the `activeDateChange` event. The child component receives an * updated value asynchronously via the `activeCell` Input. */ _updateActiveDate(month: number): void; /** Handles keydown events on the calendar body when calendar is in month view. */ handleCalendarBodyKeydown(event: KeyboardEvent): void; /** Initializes this month view. */ init(): void; /** Focuses the active cell after the microtask queue is empty. */ focusActiveCell(): void; /** Focuses the active cell after change detection has run and the microtask queue is empty. */ _focusActiveCellAfterViewChecked(): void; /** * Takes a day of the month and returns a new date in the same month and year as the currently * active date. The returned date will have the same day of the month as the argument date. */ private _getDateFromDayOfMonth; /** Creates MatCalendarCells for the dates in this month. */ private _createWeekCells; private _updateDateClasses; private _updateRangeBackground; private _shouldApplyRangeBackground; private _isRangeLimit; /** Date filter for the month */ private _shouldEnableDate; /** * Gets the date in this month that the given Date falls on. * Returns null if the given Date is in another month. */ private _getDateInCurrentMonth; /** Checks whether the 2 dates are non-null and fall within the same month of the same year. */ private _hasSameMonthAndYear; /** * @param obj The object to check. * @returns The given object if it is both a date instance and valid, otherwise null. */ private _getValidDateOrNull; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵcmp: i0.ɵɵComponentDeclaration, "sbb-month-view", ["sbbMonthView"], { "activeDate": { "alias": "activeDate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "dateClass": { "alias": "dateClass"; "required": false; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; }; "isWeekSelectable": { "alias": "isWeekSelectable"; "required": false; }; "isWeekdaySelectable": { "alias": "isWeekdaySelectable"; "required": false; }; "dateRange": { "alias": "dateRange"; "required": false; }; }, { "selectedChange": "selectedChange"; "selectedWeekChange": "selectedWeekChange"; "selectedWeekdayChange": "selectedWeekdayChange"; "userSelection": "userSelection"; "activeDateChange": "activeDateChange"; }, never, never, true, never>; } declare class SbbCalendarHeader { private _dateAdapter; _labelSwitchToPreviousMonth: string; _labelSwitchToNextMonth: string; _labelSwitchToPreviousYear: string; _labelSwitchToNextYear: string; calendar: SbbCalendar; constructor(...args: unknown[]); /** The label for the current calendar view. */ get monthText(): string; /** The label for the current calendar view. */ get yearText(): string; /** Handles user clicks on the previous button. */ previousMonthClicked(): void; /** Handles user clicks on the next button. */ nextMonthClicked(): void; /** Whether the previous period button is enabled. */ previousMonthEnabled(): boolean; /** Whether the next period button is enabled. */ nextMonthEnabled(): boolean; /** Whether the two dates represent the same month. */ private _isSameMonthView; /** Handles user clicks on the previous button. */ previousYearClicked(): void; /** Handles user clicks on the next button. */ nextYearClicked(): void; /** Whether the previous period button is enabled. */ previousYearEnabled(): boolean; /** Whether the next period button is enabled. */ nextYearEnabled(): boolean; /** Whether the two dates represent the same month. */ private _isSameYearView; private _assignActiveDate; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵcmp: i0.ɵɵComponentDeclaration, "sbb-calendar-header", ["sbbCalendarHeader"], {}, {}, never, never, true, never>; } /** * A calendar that is used as part of the datepicker. */ declare class SbbCalendar implements AfterContentInit, AfterViewChecked, OnDestroy, OnChanges { private _dateAdapter; private _dateFormats; private _changeDetectorRef; /** An input indicating the type of the header component, if set. */ headerComponent: ComponentType; /** A portal containing the header component type for this calendar. */ calendarHeaderPortal: Portal; /** * 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; /** The currently selected date. */ get selected(): D | null; set selected(value: 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; /** Whether to display the week number. */ showWeekNumbers: boolean; /** Currently active date range. */ dateRange: SbbDateRange | null; /** A function used to filter which dates are selectable. */ dateFilter: (date: D) => boolean; /** Function or observable of function that can be used to add custom CSS classes to dates. */ dateClass: SbbCalendarCellClassFunction | Observable>; /** Observable of `dateClass` function. */ _dateClassObservable: Observable>; /** Emits when the currently selected date changes. */ readonly selectedChange: EventEmitter; /** Emits when the currently selected week changes. */ readonly selectedWeekChange: EventEmitter<{ week: number; start: D; end: D; } | null>; /** Emits when the currently selected weekday changes. */ readonly selectedWeekdayChange: EventEmitter; /** Emits when any date is selected. */ readonly userSelection: EventEmitter; /** Reference to the current month view component. */ monthView: SbbMonthView; /** * 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; /** Emits whenever there is a state change that the header may need to respond to. */ stateChanges: Subject; constructor(...args: unknown[]); ngAfterContentInit(): void; ngAfterViewChecked(): void; ngOnDestroy(): void; ngOnChanges(changes: SimpleChanges): void; focusActiveCell(): void; /** Handles date selection in the month view. */ dateSelected(date: D | null): void; /** Handles week selection in the month view. */ weekSelected(week: { week: number; rangeInMonth: SbbDateRange; } | null): void; /** Handles weekday selection in the month view. */ weekdaySelected(weekday: number): void; userSelected(): void; /** * @param obj The object to check. * @returns The given object if it is both a date instance and valid, otherwise null. */ private _getValidDateOrNull; /** Returns the component instance that corresponds to the current calendar view. */ private _getCurrentViewComponent; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵcmp: i0.ɵɵComponentDeclaration, "sbb-calendar", ["sbbCalendar"], { "headerComponent": { "alias": "headerComponent"; "required": false; }; "startAt": { "alias": "startAt"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "showWeekNumbers": { "alias": "showWeekNumbers"; "required": false; }; "dateRange": { "alias": "dateRange"; "required": false; }; "dateFilter": { "alias": "dateFilter"; "required": false; }; "dateClass": { "alias": "dateClass"; "required": false; }; }, { "selectedChange": "selectedChange"; "selectedWeekChange": "selectedWeekChange"; "selectedWeekdayChange": "selectedWeekdayChange"; "userSelection": "userSelection"; }, never, never, true, never>; } /** * Component used as the content for the datepicker dialog and popup. We use this instead of using * SbbCalendar 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 */ declare class SbbDatepickerContent implements AfterViewInit { /** Reference to the internal calendar component. */ calendar: SbbCalendar; /** Reference to the datepicker that created the overlay. */ datepicker: SbbDatepicker; /** Whether the datepicker is above or below the input. */ isAbove: boolean; /** Id of the label for the `role="dialog"` element. */ _dialogLabelId: string | null; ngAfterViewInit(): void; static ɵfac: i0.ɵɵFactoryDeclaration, never>; static ɵcmp: i0.ɵɵComponentDeclaration, "sbb-datepicker-content", ["sbbDatepickerContent"], {}, {}, never, never, true, never>; } declare class SbbDatepickerModule { static ɵfac: i0.ɵɵFactoryDeclaration; static ɵmod: i0.ɵɵNgModuleDeclaration; static ɵinj: i0.ɵɵInjectorDeclaration; } declare const SBB_DATEPICKER: InjectionToken; export { SBB_DATEPICKER, SBB_DATEPICKER_SCROLL_STRATEGY, SBB_DATEPICKER_SCROLL_STRATEGY_FACTORY, SBB_DATEPICKER_SCROLL_STRATEGY_FACTORY_PROVIDER, SBB_DATE_VALIDATORS, SBB_DATE_VALUE_ACCESSOR, SbbCalendar, SbbCalendarBody, SbbCalendarCell, SbbCalendarHeader, SbbDateInput, SbbDateInputEvent, SbbDatepicker, SbbDatepickerContent, SbbDatepickerModule, SbbDatepickerToggle, SbbMonthView }; export type { SbbCalendarCellClassFunction, SbbCalendarCellCssClasses };