@dereekb/dbx-form 12.6.21 → 13.0.0

package/types/dereekb-dbx-form-calendar.d.ts

@@ -0,0 +1,679 @@
+import * as i13 from '@dereekb/dbx-form';
+import { LabeledFieldConfig, DescriptionFieldConfig, FieldConfig, AbstractSyncFormlyFormDirective } from '@dereekb/dbx-form';
+import * as _ngx_formly_core from '@ngx-formly/core';
+import { FormlyFieldProps, FieldTypeConfig, FormlyFieldConfig } from '@ngx-formly/core';
+import * as _dereekb_dbx_form_calendar from '@dereekb/dbx-form/calendar';
+import * as _dereekb_util from '@dereekb/util';
+import { FactoryWithRequiredInput, MaybeMap, Maybe, ArrayOrValue, TimezoneString, DayOfWeek, DecisionFunction, AllOrNoneSelection, IterableOrValue, ISO8601DayString, Building, EnabledDays } from '@dereekb/util';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Injector, OnInit, OnDestroy, ElementRef, Signal, Provider } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import { AbstractControl, FormGroup, FormControl } from '@angular/forms';
+import { DbxDialogContentFooterConfig, DbxDialogContentConfig, AbstractDialogDirective, CompactContextStore, DbxPopoverService, AbstractPopoverDirective, DbxPopoverKey } from '@dereekb/dbx-web';
+import { FieldType } from '@ngx-formly/material';
+import { ObservableOrValue, ObservableOrValueGetter, IsModifiedFunction, WorkUsingObservable } from '@dereekb/rxjs';
+import * as _dereekb_date from '@dereekb/date';
+import { DateCellIndex, DateCellScheduleDateRange, DateRange, DateCellRangeWithRange, DateCellScheduleDayCode, DateCellScheduleDateFilterConfig, DateOrDateRangeOrDateCellIndexOrDateCellRange, DateTimezoneUtcNormalInstance, DateCellTimingRelativeIndexFactory, DateCellDayOfWeekFactory, DateCellTimingRelativeIndexFactoryInput, DateCellDurationSpan, DateCell, FullDateCellScheduleRangeInputDateRange } from '@dereekb/date';
+import { ComponentStore } from '@ngrx/component-store';
+import { CalendarMonthViewDay, CalendarMonthViewBeforeRenderEvent, CalendarEvent } from 'angular-calendar';
+import { MatFormFieldAppearance, MatFormFieldDefaultOptions } from '@angular/material/form-field';
+import * as _angular_material_dialog from '@angular/material/dialog';
+import { MatDialog } from '@angular/material/dialog';
+import { DbxInjectionComponentConfig, DbxButtonDisplay } from '@dereekb/dbx-core';
+import { DbxCalendarStore, DbxCalendarEvent } from '@dereekb/dbx-web/calendar';
+import { ErrorStateMatcher } from '@angular/material/core';
+import { MatDateRangePicker, DateFilterFn } from '@angular/material/datepicker';
+import { NgPopoverRef } from 'ng-overlay-container';
+
+interface CalendarScheduleSelectionValue {
+    /**
+     * Schedule range.
+     */
+    readonly dateScheduleRange: DateCellScheduleDateRange;
+    /**
+     * Min and max dates in the selection.
+     */
+    readonly minMaxRange: DateRange;
+}
+declare enum CalendarScheduleSelectionDayState {
+    NOT_APPLICABLE = 0,
+    DISABLED = 1,
+    NOT_SELECTED = 2,
+    SELECTED = 3
+}
+interface CalendarScheduleSelectionMetadata {
+    readonly state: CalendarScheduleSelectionDayState;
+    readonly i: DateCellIndex;
+}
+interface CalendarScheduleSelectionCellContent {
+    readonly icon?: string;
+    readonly text?: string;
+}
+type CalendarScheduleSelectionCellContentFactory<M extends CalendarScheduleSelectionMetadata = CalendarScheduleSelectionMetadata> = FactoryWithRequiredInput<CalendarScheduleSelectionCellContent, CalendarMonthViewDay<M>>;
+declare const defaultCalendarScheduleSelectionCellContentFactory: CalendarScheduleSelectionCellContentFactory;
+
+interface CalendarScheduleSelectionInputDateRange {
+    /**
+     * Input Start Date
+     */
+    readonly inputStart: Date;
+    /**
+     * Input End Date
+     */
+    readonly inputEnd: Date;
+}
+type PartialCalendarScheduleSelectionInputDateRange = Partial<MaybeMap<CalendarScheduleSelectionInputDateRange>>;
+/**
+ * DbxCalendarScheduleSelectionStore selection mode.
+ *
+ * When in single mode the toggle function is treated as a set that clears all values and only selects the toggle'd value.
+ */
+type DbxCalendarScheduleSelectionStoreSelectionMode = 'multiple' | 'single';
+interface CalendarScheduleSelectionState extends PartialCalendarScheduleSelectionInputDateRange {
+    /**
+     * Selection mode for this calendar. Defaults to "multiple"
+     */
+    readonly selectionMode: DbxCalendarScheduleSelectionStoreSelectionMode;
+    /**
+     * Readonly state of the view.
+     *
+     * Does not affect state changes directly, but instead acts as a flag for the parent view to set and the consuming views to update on.
+     */
+    readonly isViewReadonly?: Maybe<boolean>;
+    /**
+     * Set of the days of week that are allowed by default.
+     */
+    readonly defaultScheduleDays: Set<DateCellScheduleDayCode>;
+    /**
+     * Filters the days of the schedule to only allow selecting days in the schedule.
+     *
+     * The output will be relative to this filter, and in it's timezone unless computeSelectionResultRelativeToFilter is false.
+     *
+     * This is a copy of any set/configured input filter and will have a start date set from start or startsAt.
+     */
+    readonly filter?: Maybe<DateCellScheduleDateFilterConfig>;
+    /**
+     * Additional exclusions that may not be defined within the filter.
+     */
+    readonly inputExclusions?: Maybe<ArrayOrValue<DateOrDateRangeOrDateCellIndexOrDateCellRange>>;
+    /**
+     * The computed exclusions given the input exclusions.
+     */
+    readonly computedExclusions?: Maybe<DateCellIndex[]>;
+    /**
+     * The min/max date range. Used for restricting the min/max value. Works with the filter. The greater/lesser of the start/end dates are used if both are provided.
+     */
+    readonly minMaxDateRange?: Maybe<Partial<DateRange>>;
+    /**
+     * Start date. Is updated as the inputStart is modified or filter is provided that provides the start date.
+     *
+     * Defaults to today and the current timezone.
+     */
+    readonly start: DateCellScheduleDateRange['start'];
+    /**
+     * System Timezone. Does not change.
+     */
+    readonly systemTimezone: TimezoneString;
+    /**
+     * Timezone to use when outputting the value. Only influences the output start date.
+     */
+    readonly outputTimezone?: Maybe<TimezoneString>;
+    /**
+     * Current timezone normal with the current timezone.
+     */
+    readonly outputTimezoneNormal?: Maybe<DateTimezoneUtcNormalInstance>;
+    /**
+     * DateCellTimingRelativeIndexFactory
+     */
+    readonly indexFactory: DateCellTimingRelativeIndexFactory;
+    /**
+     * Array of manually selected dates within the picked range. This is NOT the set of all selected indexes in terms of output.
+     *
+     * Values that exist outside of the "input" range are considered toggled on, while those
+     * that are selected within the range are considered toggled off.
+     *
+     * If dates are selected, and then a range is selected, then those dates within the range that fall
+     * within the range are cleared from selection.
+     *
+     * These indexes are relative to the start date.
+     */
+    readonly toggledIndexes: Set<DateCellIndex>;
+    /**
+     * Days of the schedule that are allowed to be picked. If not defined, defaults to defaultScheduleDays.
+     */
+    readonly scheduleDays?: Maybe<Set<DateCellScheduleDayCode>>;
+    /**
+     * The current DateCellScheduleDayCode value.
+     */
+    readonly effectiveScheduleDays: Set<DateCellScheduleDayCode>;
+    /**
+     * Set of the days of week that are allowed. Derived from the current schedule days value.
+     */
+    readonly allowedDaysOfWeek: Set<DayOfWeek>;
+    /**
+     *
+     */
+    readonly indexDayOfWeek: DateCellDayOfWeekFactory;
+    /**
+     * Decision function that returns true if a value is enabled given the current filter.
+     */
+    readonly isEnabledFilterDay: DecisionFunction<DateCellTimingRelativeIndexFactoryInput>;
+    /**
+     * Decision function that returns true if a value is enabled.
+     *
+     * This function does not take the current filter into account.
+     */
+    readonly isEnabledDay: DecisionFunction<DateCellTimingRelativeIndexFactoryInput>;
+    /**
+     * CalendarScheduleSelectionCellContentFactory for the view.
+     */
+    readonly cellContentFactory: CalendarScheduleSelectionCellContentFactory;
+    /**
+     * Current selection value.
+     */
+    readonly currentSelectionValue?: Maybe<CalendarScheduleSelectionValue>;
+    /**
+     * Whether or not to use the filter as the start and end range instead of optimizing for the current index.
+     *
+     * Defaults to true.
+     */
+    readonly computeSelectionResultRelativeToFilter?: Maybe<boolean>;
+    /**
+     * The initial selection state when the calendar is reset.
+     */
+    readonly initialSelectionState?: Maybe<AllOrNoneSelection>;
+}
+declare function initialCalendarScheduleSelectionState(): CalendarScheduleSelectionState;
+declare function calendarScheduleMinAndMaxDateRange(x: Pick<CalendarScheduleSelectionState, 'filter' | 'minMaxDateRange'>): Partial<DateRange>;
+declare function calendarScheduleMinDate(x: Pick<CalendarScheduleSelectionState, 'filter' | 'minMaxDateRange'>): Maybe<Date>;
+declare function calendarScheduleMaxDate(x: Pick<CalendarScheduleSelectionState, 'filter' | 'minMaxDateRange'>): Maybe<Date>;
+declare function calendarScheduleStartBeingUsedFromFilter(x: Pick<CalendarScheduleSelectionState, 'filter' | 'computeSelectionResultRelativeToFilter'>): boolean | _dereekb_util.MaybeNot;
+declare class DbxCalendarScheduleSelectionStore extends ComponentStore<CalendarScheduleSelectionState> {
+    constructor();
+    readonly toggleSelection: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
+    readonly selectionMode$: Observable<DbxCalendarScheduleSelectionStoreSelectionMode>;
+    readonly filter$: Observable<Maybe<DateCellScheduleDateFilterConfig>>;
+    readonly minMaxDateRange$: Observable<Maybe<Partial<DateRange>>>;
+    readonly minDate$: Observable<Maybe<Date>>;
+    readonly maxDate$: Observable<Maybe<Date>>;
+    readonly hasConfiguredMinMaxRange$: Observable<boolean>;
+    readonly inputStart$: Observable<Maybe<Date>>;
+    readonly inputEnd$: Observable<Maybe<Date>>;
+    readonly currentInputRange$: Observable<Maybe<CalendarScheduleSelectionInputDateRange>>;
+    readonly inputRange$: Observable<CalendarScheduleSelectionInputDateRange>;
+    readonly isEnabledFilterDayFunction$: Observable<DecisionFunction<DateCellTimingRelativeIndexFactoryInput>>;
+    readonly isEnabledDayFunction$: Observable<DecisionFunction<DateCellTimingRelativeIndexFactoryInput>>;
+    readonly currentDateRange$: Observable<Maybe<DateRange>>;
+    readonly computeSelectionResultRelativeToFilter$: Observable<Maybe<boolean>>;
+    readonly startBeingUsedFromFilter$: Observable<Maybe<boolean>>;
+    readonly dateRange$: Observable<DateRange>;
+    readonly allowedDaysOfWeek$: Observable<Set<DayOfWeek>>;
+    readonly isInAllowedDaysOfWeekFunction$: Observable<DecisionFunction<Date | DayOfWeek> & {
+        readonly _readValue: (input: Date | DayOfWeek) => DayOfWeek;
+        readonly _set: Set<DayOfWeek>;
+    }>;
+    readonly scheduleDays$: Observable<Set<DateCellScheduleDayCode>>;
+    readonly outputTimezone$: Observable<Maybe<TimezoneString>>;
+    /**
+     * The timezone of the output values.
+     *
+     * If an outputTimezone is not specified, this defaults to the system timezone.
+     */
+    readonly effectiveOutputTimezone$: Observable<TimezoneString>;
+    /**
+     * An outputTimezoneNormal to use.
+     *
+     * If an outputTimezone is not specified, this is undefined.
+     */
+    readonly effectiveOutputTimezoneNormal$: Observable<Maybe<DateTimezoneUtcNormalInstance>>;
+    readonly currentSelectionValue$: Observable<Maybe<CalendarScheduleSelectionValue>>;
+    readonly currentSelectionValueStart$: Observable<Maybe<Date>>;
+    readonly currentSelectionValueDateCellTimingDateFactory$: Observable<_dereekb_date.DateCellTimingDateFactory<{
+        startsAt: Date;
+        timezone: string;
+    }> | undefined>;
+    readonly currentSelectionValueDateCellDurationSpanExpansion$: Observable<DateCellDurationSpan<DateCell>[]>;
+    readonly selectionValueSelectedIndexes$: Observable<Set<DateCellIndex>>;
+    readonly selectionValueSelectedDates$: Observable<Set<ISO8601DayString>>;
+    readonly selectionValue$: Observable<CalendarScheduleSelectionValue>;
+    readonly currentSelectionValueWithTimezone$: Observable<Maybe<CalendarScheduleSelectionValue>>;
+    readonly selectionValueWithTimezone$: Observable<CalendarScheduleSelectionValue>;
+    readonly selectionValueWithTimezoneDateCellDurationSpanExpansion$: Observable<DateCellDurationSpan<DateCell>[]>;
+    readonly nextToggleSelection$: Observable<Maybe<AllOrNoneSelection>>;
+    readonly currentDateCellScheduleRangeValue$: Observable<Maybe<DateCellScheduleDateRange>>;
+    readonly dateCellScheduleRangeValue$: Observable<DateCellScheduleDateRange>;
+    readonly cellContentFactory$: Observable<CalendarScheduleSelectionCellContentFactory>;
+    readonly isCustomized$: Observable<boolean>;
+    readonly isViewReadonly$: Observable<Maybe<boolean>>;
+    readonly setMinMaxDateRange: (() => void) | ((observableOrValue: Maybe<Partial<DateRange>> | Observable<Maybe<Partial<DateRange>>>) => rxjs.Subscription);
+    readonly setDefaultWeek: (() => void) | ((observableOrValue: Maybe<Partial<DateRange>> | Observable<Maybe<Partial<DateRange>>>) => rxjs.Subscription);
+    readonly setFilter: (() => void) | ((observableOrValue: Maybe<DateCellScheduleDateFilterConfig> | Observable<Maybe<DateCellScheduleDateFilterConfig>>) => rxjs.Subscription);
+    readonly setExclusions: (() => void) | ((observableOrValue: Maybe<ArrayOrValue<DateOrDateRangeOrDateCellIndexOrDateCellRange>> | Observable<Maybe<ArrayOrValue<DateOrDateRangeOrDateCellIndexOrDateCellRange>>>) => rxjs.Subscription);
+    readonly setComputeSelectionResultRelativeToFilter: (() => void) | ((observableOrValue: Maybe<boolean> | Observable<Maybe<boolean>>) => rxjs.Subscription);
+    readonly clearFilter: () => void;
+    readonly setOutputTimezone: (() => void) | ((observableOrValue: Maybe<string> | Observable<Maybe<string>>) => rxjs.Subscription);
+    /**
+     * Sets the "input" date range. This is the range that gets displayed on the date range picker.
+     */
+    readonly setInputRange: (observableOrValue: CalendarScheduleSelectionInputDateRange | Observable<CalendarScheduleSelectionInputDateRange>) => rxjs.Subscription;
+    readonly toggleSelectedDates: (observableOrValue: IterableOrValue<DateCellTimingRelativeIndexFactoryInput> | Observable<IterableOrValue<DateCellTimingRelativeIndexFactoryInput>>) => rxjs.Subscription;
+    readonly addSelectedDates: (observableOrValue: IterableOrValue<DateCellTimingRelativeIndexFactoryInput> | Observable<IterableOrValue<DateCellTimingRelativeIndexFactoryInput>>) => rxjs.Subscription;
+    readonly removeSelectedDates: (observableOrValue: IterableOrValue<DateCellTimingRelativeIndexFactoryInput> | Observable<IterableOrValue<DateCellTimingRelativeIndexFactoryInput>>) => rxjs.Subscription;
+    readonly setSelectedDates: (observableOrValue: IterableOrValue<DateCellTimingRelativeIndexFactoryInput> | Observable<IterableOrValue<DateCellTimingRelativeIndexFactoryInput>>) => rxjs.Subscription;
+    readonly selectAllDates: (observableOrValue: AllOrNoneSelection | Observable<AllOrNoneSelection>) => rxjs.Subscription;
+    readonly setSelectedIndexes: (observableOrValue: IterableOrValue<DateCellTimingRelativeIndexFactoryInput> | Observable<IterableOrValue<DateCellTimingRelativeIndexFactoryInput>>) => rxjs.Subscription;
+    readonly setInitialSelectionState: (() => void) | ((observableOrValue: Maybe<AllOrNoneSelection> | Observable<Maybe<AllOrNoneSelection>>) => rxjs.Subscription);
+    readonly setDefaultScheduleDays: (() => void) | ((observableOrValue: Maybe<Iterable<DateCellScheduleDayCode>> | Observable<Maybe<Iterable<DateCellScheduleDayCode>>>) => rxjs.Subscription);
+    readonly setScheduleDays: (() => void) | ((observableOrValue: Maybe<Iterable<DateCellScheduleDayCode>> | Observable<Maybe<Iterable<DateCellScheduleDayCode>>>) => rxjs.Subscription);
+    readonly setAllowAllScheduleDays: () => void;
+    readonly setDateScheduleRangeValue: (() => void) | ((observableOrValue: Maybe<FullDateCellScheduleRangeInputDateRange> | Observable<Maybe<FullDateCellScheduleRangeInputDateRange>>) => rxjs.Subscription);
+    readonly setCellContentFactory: (observableOrValue: CalendarScheduleSelectionCellContentFactory | Observable<CalendarScheduleSelectionCellContentFactory>) => rxjs.Subscription;
+    /**
+     * Sets the selection mode.
+     */
+    readonly setSelectionMode: (observableOrValue: DbxCalendarScheduleSelectionStoreSelectionMode | Observable<DbxCalendarScheduleSelectionStoreSelectionMode>) => rxjs.Subscription;
+    /**
+     * Used by the parent view to propogate a readonly state.
+     *
+     * Should typically not be used by the user directly with the intention of the parent synchronizing to this state.
+     */
+    readonly setViewReadonlyState: (observableOrValue: boolean | Observable<boolean>) => rxjs.Subscription;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxCalendarScheduleSelectionStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DbxCalendarScheduleSelectionStore>;
+}
+declare function updateStateWithInitialSelectionState(state: CalendarScheduleSelectionState, initialSelectionState: Maybe<AllOrNoneSelection>): CalendarScheduleSelectionState;
+declare function updateStateWithComputeSelectionResultRelativeToFilter(currentState: CalendarScheduleSelectionState, computeSelectionResultRelativeToFilter: Maybe<boolean>): CalendarScheduleSelectionState;
+declare function updateStateWithExclusions(state: CalendarScheduleSelectionState, inputExclusions: Maybe<ArrayOrValue<DateOrDateRangeOrDateCellIndexOrDateCellRange>>): CalendarScheduleSelectionState;
+declare function updateStateWithMinMaxDateRange(state: CalendarScheduleSelectionState, minMaxDateRange: Maybe<Partial<DateRange>>): CalendarScheduleSelectionState;
+declare function updateStateWithFilter(currentState: CalendarScheduleSelectionState, inputFilter: Maybe<DateCellScheduleDateFilterConfig>): CalendarScheduleSelectionState;
+declare function updateStateWithTimezoneValue(state: CalendarScheduleSelectionState, timezone: Maybe<TimezoneString>): CalendarScheduleSelectionState;
+declare function updateStateWithDateCellScheduleRangeValue(state: CalendarScheduleSelectionState, inputChange: Maybe<FullDateCellScheduleRangeInputDateRange>): CalendarScheduleSelectionState;
+declare function updateStateWithChangedDefaultScheduleDays(state: CalendarScheduleSelectionState, change: Maybe<Iterable<DateCellScheduleDayCode>>): CalendarScheduleSelectionState;
+declare function updateStateWithChangedScheduleDays(state: CalendarScheduleSelectionState, change: Maybe<Iterable<DateCellScheduleDayCode>>): CalendarScheduleSelectionState;
+declare function updateStateWithSelectionMode(state: CalendarScheduleSelectionState, selectionMode: DbxCalendarScheduleSelectionStoreSelectionMode): CalendarScheduleSelectionState;
+declare function finalizeUpdateStateWithChangedScheduleDays(previousState: CalendarScheduleSelectionState, nextState: CalendarScheduleSelectionState): CalendarScheduleSelectionState;
+interface CalendarScheduleSelectionStateDatesChange {
+    reset?: true;
+    toggle?: IterableOrValue<DateCellTimingRelativeIndexFactoryInput>;
+    add?: IterableOrValue<DateCellTimingRelativeIndexFactoryInput>;
+    remove?: IterableOrValue<DateCellTimingRelativeIndexFactoryInput>;
+    set?: IterableOrValue<DateCellTimingRelativeIndexFactoryInput>;
+    selectAll?: AllOrNoneSelection;
+    /**
+     * Inverts the set date changing behavior so that the set input is treated as items that should be retained instead of excluded.
+     *
+     * Ignored when set is not used. Ignored for selectAll.
+     */
+    invertSetBehavior?: boolean;
+}
+declare function updateStateWithChangedDates(state: CalendarScheduleSelectionState, change: CalendarScheduleSelectionStateDatesChange): CalendarScheduleSelectionState;
+declare function noSelectionCalendarScheduleSelectionState(state: CalendarScheduleSelectionState): CalendarScheduleSelectionState;
+declare function updateStateWithChangedRange(state: CalendarScheduleSelectionState, change: CalendarScheduleSelectionInputDateRange): CalendarScheduleSelectionState;
+declare function finalizeNewCalendarScheduleSelectionState(nextState: Building<CalendarScheduleSelectionState>): CalendarScheduleSelectionState;
+declare function isEnabledDayInCalendarScheduleSelectionState(state: CalendarScheduleSelectionState): DecisionFunction<DateCellTimingRelativeIndexFactoryInput>;
+declare function computeScheduleSelectionValue(state: CalendarScheduleSelectionState): Maybe<CalendarScheduleSelectionValue>;
+/**
+ * The selected date range and the corresponding cell range.
+ */
+interface CalendarScheduleSelectionRangeAndExclusion extends DateRange {
+    /**
+     * Corresponds to the start and end indexes in the date range.
+     */
+    dateCellRange: DateCellRangeWithRange;
+    /**
+     * All excluded indexes.
+     */
+    excluded: DateCellIndex[];
+}
+declare function computeScheduleSelectionRangeAndExclusion(state: CalendarScheduleSelectionState): Maybe<CalendarScheduleSelectionRangeAndExclusion>;
+declare function computeCalendarScheduleSelectionRange(state: CalendarScheduleSelectionState): Maybe<DateRange>;
+declare function computeCalendarScheduleSelectionDateCellRange(state: CalendarScheduleSelectionState): Maybe<DateCellRangeWithRange>;
+
+/**
+ * Token used to configure the default DbxScheduleSelectionCalendarDatePopupConfig for DbxScheduleSelectionCalendarDateDialogComponent.
+ */
+declare const DEFAULT_DBX_SCHEDULE_SELECTION_CALENDAR_DATE_POPUP_CONTENT_CONFIG_TOKEN: InjectionToken<unknown>;
+interface DbxScheduleSelectionCalendarDatePopupContentConfig {
+    readonly closeConfig?: DbxDialogContentFooterConfig;
+    readonly dialogConfig?: DbxDialogContentConfig;
+}
+interface DbxScheduleSelectionCalendarDatePopupConfig {
+    readonly injector: Injector;
+    readonly contentConfig?: Maybe<DbxScheduleSelectionCalendarDatePopupContentConfig>;
+}
+declare class DbxScheduleSelectionCalendarDateDialogComponent extends AbstractDialogDirective<void, DbxScheduleSelectionCalendarDatePopupConfig> {
+    get contentConfig(): Maybe<DbxScheduleSelectionCalendarDatePopupContentConfig>;
+    get closeConfig(): DbxDialogContentFooterConfig | undefined;
+    static openDialog(matDialog: MatDialog, config: DbxScheduleSelectionCalendarDatePopupConfig): _angular_material_dialog.MatDialogRef<DbxScheduleSelectionCalendarDateDialogComponent, any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDateDialogComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDateDialogComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface DbxFormCalendarDateCellScheduleRangeFieldProps extends Pick<FormlyFieldProps, 'label' | 'description' | 'readonly' | 'required'>, Pick<CalendarScheduleSelectionState, 'computeSelectionResultRelativeToFilter' | 'initialSelectionState'>, Partial<Pick<CalendarScheduleSelectionState, 'cellContentFactory'>> {
+    readonly appearance?: MatFormFieldAppearance;
+    /**
+     * Whether or not to allow inputting custom text into the picker.
+     *
+     * If false, when the input text is picked the date picker will open.
+     *
+     * Is false by default.
+     */
+    readonly allowTextInput?: boolean;
+    /**
+     * Whether or not to hide the customize button. Defaults to false.
+     */
+    readonly hideCustomize?: boolean;
+    /**
+     * Whether or not to allow customizing before picking a date range to customize.
+     *
+     * Defaults to false.
+     */
+    readonly allowCustomizeWithoutDateRange?: boolean;
+    /**
+     * (Optional) Timezone to use for the output start date.
+     *
+     * If a filter is provided, this timezone overrides the filter's timezone output.
+     */
+    readonly outputTimezone?: ObservableOrValue<Maybe<TimezoneString>>;
+    /**
+     * (Optional) Default schedule days to allow.
+     */
+    readonly defaultScheduleDays?: ObservableOrValue<Maybe<Iterable<DateCellScheduleDayCode>>>;
+    /**
+     * Optional min/max date range to filter on. Works in conjuction with the filter.
+     */
+    readonly minMaxDateRange?: ObservableOrValue<Maybe<Partial<DateRange>>>;
+    /**
+     * (Optional) Observable with a filter value to apply to the date range.
+     */
+    readonly filter?: ObservableOrValue<Maybe<DateCellScheduleDateFilterConfig>>;
+    /**
+     * (Optional) Observable with days and values to exclude from the date range.
+     */
+    readonly exclusions?: ObservableOrValue<Maybe<ArrayOrValue<DateOrDateRangeOrDateCellIndexOrDateCellRange>>>;
+    /**
+     * Custom dialog content config for the popup
+     */
+    readonly dialogContentConfig?: Maybe<DbxScheduleSelectionCalendarDatePopupContentConfig>;
+    /**
+     * Custom details config for the date range
+     */
+    readonly customDetailsConfig?: Maybe<DbxInjectionComponentConfig>;
+}
+declare class DbxFormCalendarDateScheduleRangeFieldComponent<T extends DbxFormCalendarDateCellScheduleRangeFieldProps = DbxFormCalendarDateCellScheduleRangeFieldProps> extends FieldType<FieldTypeConfig<T>> implements OnInit, OnDestroy {
+    readonly compact: CompactContextStore | null;
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    private readonly _syncSub;
+    private readonly _valueSub;
+    private readonly _timezoneSub;
+    private readonly _minMaxDateRangeSub;
+    private readonly _defaultWeekSub;
+    private readonly _filterSub;
+    private readonly _exclusionsSub;
+    private readonly _formControlObs;
+    readonly formControl$: rxjs.Observable<AbstractControl<any, any, any>>;
+    readonly value$: rxjs.Observable<any>;
+    readonly disableCustomize$: rxjs.Observable<boolean>;
+    readonly disabledSignal: _angular_core.Signal<boolean | undefined>;
+    get formGroupName(): string;
+    get formGroup(): FormGroup;
+    get label(): Maybe<string>;
+    get description(): Maybe<string>;
+    get isReadonlyOrDisabled(): boolean;
+    get openPickerOnTextClick(): boolean;
+    get allowCustomizeWithoutDateRange(): boolean;
+    get showCustomize(): boolean;
+    get defaultScheduleDays(): ObservableOrValue<Maybe<Iterable<DateCellScheduleDayCode>>>;
+    get minMaxDateRange(): ObservableOrValue<Maybe<Partial<DateRange>>>;
+    get filter(): ObservableOrValue<Maybe<DateCellScheduleDateFilterConfig>>;
+    get exclusions(): ObservableOrValue<Maybe<ArrayOrValue<DateOrDateRangeOrDateCellIndexOrDateCellRange>>>;
+    get outputTimezone(): ObservableOrValue<Maybe<string>>;
+    get initialSelectionState(): Maybe<_dereekb_util.AllOrNoneSelection>;
+    get computeSelectionResultRelativeToFilter(): Maybe<boolean>;
+    get dialogContentConfig(): Maybe<DbxScheduleSelectionCalendarDatePopupContentConfig>;
+    get customDetailsConfig(): Maybe<DbxInjectionComponentConfig<unknown>>;
+    get cellContentFactory(): _dereekb_dbx_form_calendar.CalendarScheduleSelectionCellContentFactory | undefined;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxFormCalendarDateScheduleRangeFieldComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxFormCalendarDateScheduleRangeFieldComponent<any>, "ng-component", never, {}, {}, never, never, true, never>;
+}
+
+interface DateScheduleRangeFieldConfig extends Omit<LabeledFieldConfig, 'key' | 'placeholder'>, DescriptionFieldConfig, Partial<FieldConfig>, DbxFormCalendarDateCellScheduleRangeFieldProps {
+}
+declare function dateScheduleRangeField(config?: DateScheduleRangeFieldConfig): FormlyFieldConfig;
+
+declare class DbxFormDateScheduleRangeFieldModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxFormDateScheduleRangeFieldModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DbxFormDateScheduleRangeFieldModule, never, [typeof DbxFormCalendarDateScheduleRangeFieldComponent, typeof _ngx_formly_core.FormlyModule], [typeof DbxFormCalendarDateScheduleRangeFieldComponent]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DbxFormDateScheduleRangeFieldModule>;
+}
+
+interface DbxScheduleSelectionCalendarComponentConfig {
+    /**
+     * Whether or not the selection calendar is readonly. Defaults to 'false'.
+     */
+    readonly readonly?: Maybe<ObservableOrValueGetter<Maybe<boolean>>>;
+    /**
+     * Whether or not to show the configured buttons when readonly is true. Defaults to false.
+     */
+    readonly showButtonsOnReadonly?: boolean;
+    /**
+     * Whether or not to show the clear selection button. Defaults to `true`.
+     */
+    readonly showClearSelectionButton?: boolean;
+    /**
+     * Configuration for displaying a custom selection button. When null/undefined/true is passed, will show the default DbxScheduleSelectionCalendarDatePopoverButtonComponent.
+     */
+    readonly buttonInjectionConfig?: Maybe<ObservableOrValueGetter<Maybe<DbxInjectionComponentConfig<any> | boolean>>>;
+    /**
+     * Customize day function. When a new function is piped through the calendar is refreshed.
+     */
+    readonly customizeDay?: Maybe<ObservableOrValue<Maybe<DbxScheduleSelectionCalendarBeforeMonthViewRenderModifyDayFunction>>>;
+    /**
+     * Optional full control over the beforeMonthViewRender
+     */
+    readonly beforeMonthViewRenderFunctionFactory?: Maybe<ObservableOrValue<DbxScheduleSelectionCalendarBeforeMonthViewRenderFunctionFactory>>;
+}
+type DbxScheduleSelectionCalendarBeforeMonthViewRenderModifyDayFunction = (viewDay: CalendarMonthViewDay<CalendarScheduleSelectionMetadata>, state: CalendarScheduleSelectionState) => void;
+type DbxScheduleSelectionCalendarBeforeMonthViewRenderFunction = (renderEvent: CalendarMonthViewBeforeRenderEvent) => void;
+type DbxScheduleSelectionCalendarBeforeMonthViewRenderFunctionFactory = (state: Observable<CalendarScheduleSelectionState>) => DbxScheduleSelectionCalendarBeforeMonthViewRenderFunction;
+declare function dbxScheduleSelectionCalendarBeforeMonthViewRenderFactory(inputModifyFn?: Maybe<DbxScheduleSelectionCalendarBeforeMonthViewRenderModifyDayFunction>): DbxScheduleSelectionCalendarBeforeMonthViewRenderFunctionFactory;
+declare class DbxScheduleSelectionCalendarComponent<T> implements OnInit, OnDestroy {
+    readonly calendarStore: DbxCalendarStore<T>;
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    readonly clickEvent: _angular_core.OutputEmitterRef<DbxCalendarEvent<T>>;
+    readonly config: _angular_core.InputSignal<Maybe<DbxScheduleSelectionCalendarComponentConfig>>;
+    readonly readonly: _angular_core.InputSignal<Maybe<boolean>>;
+    private readonly _centerRangeSub;
+    readonly config$: Observable<Maybe<DbxScheduleSelectionCalendarComponentConfig>>;
+    readonly readonly$: Observable<boolean>;
+    readonly showButtonsOnReadonly$: Observable<boolean>;
+    readonly showButtons$: Observable<boolean>;
+    readonly showClearSelectionButton$: Observable<boolean>;
+    readonly datePopoverButtonInjectionConfig$: Observable<Maybe<DbxInjectionComponentConfig<any>>>;
+    readonly state$: Observable<CalendarScheduleSelectionState>;
+    readonly beforeMonthViewRender$: Observable<DbxScheduleSelectionCalendarBeforeMonthViewRenderFunction>;
+    readonly refresh$: Subject<undefined>;
+    readonly events$: Observable<CalendarEvent<any>[]>;
+    readonly viewDate$: Observable<Date>;
+    readonly beforeMonthViewRenderSignal: _angular_core.Signal<DbxScheduleSelectionCalendarBeforeMonthViewRenderFunction | undefined>;
+    readonly readonlySignal: _angular_core.Signal<boolean>;
+    readonly showClearSelectionButtonSignal: _angular_core.Signal<boolean | undefined>;
+    readonly datePopoverButtonInjectionConfigSignal: _angular_core.Signal<Maybe<DbxInjectionComponentConfig<any>>>;
+    readonly eventsSignal: _angular_core.Signal<CalendarEvent<any>[]>;
+    readonly viewDateSignal: _angular_core.Signal<Date>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    dayClicked({ date }: {
+        date: Date;
+    }): void;
+    eventClicked(action: string, event: CalendarEvent<T>): void;
+    beforeMonthViewRender(renderEvent: CalendarMonthViewBeforeRenderEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarComponent<any>, "dbx-schedule-selection-calendar", never, { "config": { "alias": "config"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; }, { "clickEvent": "clickEvent"; }, never, never, true, never>;
+}
+
+type DbxScheduleSelectionCalendarDateDaysFormValue = EnabledDays;
+declare class DbxScheduleSelectionCalendarDateDaysFormComponent extends AbstractSyncFormlyFormDirective<DbxScheduleSelectionCalendarDateDaysFormValue> {
+    readonly fields: FormlyFieldConfig[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDateDaysFormComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDateDaysFormComponent, "dbx-schedule-selection-calendar-date-days-form", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxScheduleSelectionCalendarDateDaysComponent {
+    readonly dbxCalendarStore: DbxCalendarStore<any>;
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    readonly template$: Observable<DbxScheduleSelectionCalendarDateDaysFormValue>;
+    readonly isFormModified: IsModifiedFunction<DbxScheduleSelectionCalendarDateDaysFormValue>;
+    readonly updateScheduleDays: WorkUsingObservable<DbxScheduleSelectionCalendarDateDaysFormValue>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDateDaysComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDateDaysComponent, "dbx-schedule-selection-calendar-date-days", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxScheduleSelectionCalendarDateRangeComponent implements OnInit, OnDestroy {
+    readonly dbxCalendarStore: DbxCalendarStore<any>;
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    readonly matFormFieldDefaultOptions: MatFormFieldDefaultOptions | null;
+    readonly picker: _angular_core.Signal<MatDateRangePicker<Date>>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly openPickerOnTextClick: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<Maybe<string>>;
+    readonly hint: _angular_core.InputSignal<Maybe<string>>;
+    readonly disabled: _angular_core.InputSignal<Maybe<boolean>>;
+    readonly showCustomize: _angular_core.InputSignal<boolean>;
+    readonly timezone$: Observable<string>;
+    protected readonly _disabledEffect: _angular_core.EffectRef;
+    private readonly _pickerOpened;
+    private readonly _syncSub;
+    private readonly _valueSub;
+    readonly range: FormGroup<{
+        start: FormControl<Maybe<Date>>;
+        end: FormControl<Maybe<Date>>;
+    }>;
+    readonly errorStateMatcher: ErrorStateMatcher;
+    readonly minDate$: Observable<Maybe<Date>>;
+    readonly maxDate$: Observable<Maybe<Date>>;
+    readonly timezoneReleventDate$: Observable<Date>;
+    readonly isCustomized$: Observable<boolean>;
+    readonly currentErrorMessage$: Observable<string | undefined>;
+    readonly datePickerFilter$: Observable<DateFilterFn<Date>>;
+    readonly timezoneSignal: _angular_core.Signal<string | undefined>;
+    readonly timezoneReleventDateSignal: _angular_core.Signal<Date>;
+    readonly isCustomizedSignal: _angular_core.Signal<boolean>;
+    readonly showCustomLabelSignal: _angular_core.Signal<boolean>;
+    readonly currentErrorMessageSignal: _angular_core.Signal<string | undefined>;
+    readonly datePickerFilterSignal: _angular_core.Signal<DateFilterFn<Date>>;
+    protected readonly _requiredUpdateValidatorsEffect: _angular_core.EffectRef;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    clickedDateRangeInput(): void;
+    pickerOpened(): void;
+    pickerClosed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDateRangeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDateRangeComponent, "dbx-schedule-selection-calendar-date-range", never, { "required": { "alias": "required"; "required": false; "isSignal": true; }; "openPickerOnTextClick": { "alias": "openPickerOnTextClick"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showCustomize": { "alias": "showCustomize"; "required": false; "isSignal": true; }; }, {}, never, ["[customizeButton]", "*"], true, never>;
+}
+
+declare class DbxScheduleSelectionCalendarDatePopoverButtonComponent {
+    readonly injector: Injector;
+    readonly popoverService: DbxPopoverService;
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    readonly buttonPopoverOrigin: _angular_core.Signal<ElementRef<HTMLButtonElement>>;
+    readonly disabled$: rxjs.Observable<_dereekb_util.Maybe<boolean>>;
+    readonly buttonText$: rxjs.Observable<string>;
+    readonly disabledSignal: _angular_core.Signal<_dereekb_util.Maybe<boolean>>;
+    readonly buttonTextSignal: _angular_core.Signal<string>;
+    openPopover(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDatePopoverButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDatePopoverButtonComponent, "dbx-schedule-selection-calendar-date-popover-button", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxScheduleSelectionCalendarCellComponent {
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    readonly day: _angular_core.InputSignal<CalendarMonthViewDay<CalendarScheduleSelectionMetadata>>;
+    readonly day$: rxjs.Observable<CalendarMonthViewDay<CalendarScheduleSelectionMetadata>>;
+    readonly cellContent$: rxjs.Observable<CalendarScheduleSelectionCellContent>;
+    readonly contentSignal: Signal<CalendarScheduleSelectionCellContent>;
+    readonly iconSignal: Signal<string | undefined>;
+    readonly textSignal: Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarCellComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarCellComponent, "dbx-schedule-selection-calendar-cell", never, { "day": { "alias": "day"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const DEFAULT_SCHEDULE_SELECTION_CALENDAR_DATE_POPOVER_KEY = "calendarselection";
+interface DbxScheduleSelectionCalendarDatePopoverConfig {
+    origin: ElementRef;
+    injector: Injector;
+}
+declare class DbxScheduleSelectionCalendarDatePopoverComponent extends AbstractPopoverDirective<void> {
+    static openPopover(popoverService: DbxPopoverService, { origin, injector }: DbxScheduleSelectionCalendarDatePopoverConfig, popoverKey?: DbxPopoverKey): NgPopoverRef<any, number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDatePopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDatePopoverComponent, "dbx-schedule-selection-calendar-date-popover", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxScheduleSelectionCalendarDatePopoverContentComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDatePopoverContentComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDatePopoverContentComponent, "dbx-schedule-selection-calendar-date-popover-content", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Token used by provideCalendarScheduleSelectionStoreIfDoesNotExist() to prevent injecting a parent DbxCalendarScheduleSelectionStore into the child view.
+ */
+declare class DbxCalendarScheduleSelectionStoreProviderBlock {
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxCalendarScheduleSelectionStoreProviderBlock, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DbxCalendarScheduleSelectionStoreProviderBlock>;
+}
+declare class DbxCalendarScheduleSelectionStoreInjectionBlockDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxCalendarScheduleSelectionStoreInjectionBlockDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<DbxCalendarScheduleSelectionStoreInjectionBlockDirective, "[dbxCalendarScheduleSelectionStoreParentBlocker]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Creates a Provider that initializes a new DbxCalendarScheduleSelectionStore if a parent does not exist.
+ *
+ * If a DbxCalendarScheduleSelectionStoreInjectionBlock is available in the context, and references the same dbxCalendarScheduleSelectionStore that is attempting to be injected, a new DbxCalendarScheduleSelectionStore is created.
+ *
+ * @returns
+ */
+declare function provideCalendarScheduleSelectionStoreIfParentIsUnavailable(): Provider;
+
+declare class DbxScheduleSelectionCalendarDateDialogButtonComponent {
+    readonly injector: Injector;
+    readonly matDialog: MatDialog;
+    readonly buttonText: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignal<Maybe<boolean>>;
+    readonly contentConfig: _angular_core.InputSignal<Maybe<DbxScheduleSelectionCalendarDatePopupContentConfig>>;
+    clickCustomize(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarDateDialogButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarDateDialogButtonComponent, "dbx-schedule-selection-calendar-date-dialog-button", never, { "buttonText": { "alias": "buttonText"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "contentConfig": { "alias": "contentConfig"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Toggle button for selecting and clearing the current selection.
+ */
+declare class DbxScheduleSelectionCalendarSelectionToggleButtonComponent {
+    readonly disabled: _angular_core.InputSignal<Maybe<boolean>>;
+    readonly dbxCalendarScheduleSelectionStore: DbxCalendarScheduleSelectionStore;
+    readonly selectionModeSignal: _angular_core.Signal<_dereekb_dbx_form_calendar.DbxCalendarScheduleSelectionStoreSelectionMode>;
+    readonly nextToggleSelectionSignal: _angular_core.Signal<Maybe<_dereekb_util.AllOrNoneSelection>>;
+    readonly disableButtonSignal: _angular_core.Signal<boolean>;
+    readonly buttonDisplaySignal: _angular_core.Signal<DbxButtonDisplay>;
+    toggleSelection(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxScheduleSelectionCalendarSelectionToggleButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DbxScheduleSelectionCalendarSelectionToggleButtonComponent, "dbx-schedule-selection-calendar-selection-toggle-button", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class DbxFormCalendarModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DbxFormCalendarModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<DbxFormCalendarModule, never, [typeof DbxScheduleSelectionCalendarComponent, typeof DbxScheduleSelectionCalendarDateDaysComponent, typeof DbxScheduleSelectionCalendarDateDaysFormComponent, typeof DbxScheduleSelectionCalendarDateRangeComponent, typeof DbxScheduleSelectionCalendarDatePopoverButtonComponent, typeof DbxScheduleSelectionCalendarCellComponent, typeof DbxScheduleSelectionCalendarDatePopoverComponent, typeof DbxScheduleSelectionCalendarDatePopoverContentComponent, typeof DbxCalendarScheduleSelectionStoreInjectionBlockDirective, typeof DbxScheduleSelectionCalendarDateDialogComponent, typeof DbxScheduleSelectionCalendarDateDialogButtonComponent, typeof DbxScheduleSelectionCalendarSelectionToggleButtonComponent, typeof i13.DbxFormFormlyWrapperModule], [typeof DbxScheduleSelectionCalendarComponent, typeof DbxScheduleSelectionCalendarDateDaysComponent, typeof DbxScheduleSelectionCalendarDateDaysFormComponent, typeof DbxScheduleSelectionCalendarDateRangeComponent, typeof DbxScheduleSelectionCalendarDatePopoverButtonComponent, typeof DbxScheduleSelectionCalendarCellComponent, typeof DbxScheduleSelectionCalendarDatePopoverComponent, typeof DbxScheduleSelectionCalendarDatePopoverContentComponent, typeof DbxCalendarScheduleSelectionStoreInjectionBlockDirective, typeof DbxScheduleSelectionCalendarDateDialogComponent, typeof DbxScheduleSelectionCalendarDateDialogButtonComponent, typeof DbxScheduleSelectionCalendarSelectionToggleButtonComponent, typeof i13.DbxFormFormlyWrapperModule]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<DbxFormCalendarModule>;
+}
+
+declare function dbxScheduleSelectionCalendarDateDaysFormFields(): _ngx_formly_core.FormlyFieldConfig<i13.DbxFlexWrapperConfig>[];
+declare function dbxScheduleSelectionCalendarDateDaysFormDayFields(): _ngx_formly_core.FormlyFieldConfig<_ngx_formly_core.FormlyFieldProps & {
+    [additionalProperties: string]: any;
+}>[];
+
+export { CalendarScheduleSelectionDayState, DEFAULT_DBX_SCHEDULE_SELECTION_CALENDAR_DATE_POPUP_CONTENT_CONFIG_TOKEN, DEFAULT_SCHEDULE_SELECTION_CALENDAR_DATE_POPOVER_KEY, DbxCalendarScheduleSelectionStore, DbxCalendarScheduleSelectionStoreInjectionBlockDirective, DbxCalendarScheduleSelectionStoreProviderBlock, DbxFormCalendarDateScheduleRangeFieldComponent, DbxFormCalendarModule, DbxFormDateScheduleRangeFieldModule, DbxScheduleSelectionCalendarCellComponent, DbxScheduleSelectionCalendarComponent, DbxScheduleSelectionCalendarDateDaysComponent, DbxScheduleSelectionCalendarDateDaysFormComponent, DbxScheduleSelectionCalendarDateDialogButtonComponent, DbxScheduleSelectionCalendarDateDialogComponent, DbxScheduleSelectionCalendarDatePopoverButtonComponent, DbxScheduleSelectionCalendarDatePopoverComponent, DbxScheduleSelectionCalendarDatePopoverContentComponent, DbxScheduleSelectionCalendarDateRangeComponent, DbxScheduleSelectionCalendarSelectionToggleButtonComponent, calendarScheduleMaxDate, calendarScheduleMinAndMaxDateRange, calendarScheduleMinDate, calendarScheduleStartBeingUsedFromFilter, computeCalendarScheduleSelectionDateCellRange, computeCalendarScheduleSelectionRange, computeScheduleSelectionRangeAndExclusion, computeScheduleSelectionValue, dateScheduleRangeField, dbxScheduleSelectionCalendarBeforeMonthViewRenderFactory, dbxScheduleSelectionCalendarDateDaysFormDayFields, dbxScheduleSelectionCalendarDateDaysFormFields, defaultCalendarScheduleSelectionCellContentFactory, finalizeNewCalendarScheduleSelectionState, finalizeUpdateStateWithChangedScheduleDays, initialCalendarScheduleSelectionState, isEnabledDayInCalendarScheduleSelectionState, noSelectionCalendarScheduleSelectionState, provideCalendarScheduleSelectionStoreIfParentIsUnavailable, updateStateWithChangedDates, updateStateWithChangedDefaultScheduleDays, updateStateWithChangedRange, updateStateWithChangedScheduleDays, updateStateWithComputeSelectionResultRelativeToFilter, updateStateWithDateCellScheduleRangeValue, updateStateWithExclusions, updateStateWithFilter, updateStateWithInitialSelectionState, updateStateWithMinMaxDateRange, updateStateWithSelectionMode, updateStateWithTimezoneValue };
+export type { CalendarScheduleSelectionCellContent, CalendarScheduleSelectionCellContentFactory, CalendarScheduleSelectionInputDateRange, CalendarScheduleSelectionMetadata, CalendarScheduleSelectionRangeAndExclusion, CalendarScheduleSelectionState, CalendarScheduleSelectionStateDatesChange, CalendarScheduleSelectionValue, DateScheduleRangeFieldConfig, DbxCalendarScheduleSelectionStoreSelectionMode, DbxFormCalendarDateCellScheduleRangeFieldProps, DbxScheduleSelectionCalendarBeforeMonthViewRenderFunction, DbxScheduleSelectionCalendarBeforeMonthViewRenderFunctionFactory, DbxScheduleSelectionCalendarBeforeMonthViewRenderModifyDayFunction, DbxScheduleSelectionCalendarComponentConfig, DbxScheduleSelectionCalendarDateDaysFormValue, DbxScheduleSelectionCalendarDatePopoverConfig, DbxScheduleSelectionCalendarDatePopupConfig, DbxScheduleSelectionCalendarDatePopupContentConfig, PartialCalendarScheduleSelectionInputDateRange };