@dereekb/dbx-form 9.17.3 → 9.18.1

package/fesm2020/dereekb-dbx-form-calendar.mjs

@@ -0,0 +1,1055 @@
+import * as i4 from '@dereekb/dbx-form';
+import { formlyField, propsAndConfigForFieldConfig, flexLayoutWrapper, toggleField, AbstractSyncFormlyFormDirective, provideFormlyContext, DbxFormModule, DbxFormlyModule } from '@dereekb/dbx-form';
+import * as i1$1 from '@dereekb/dbx-web';
+import { AbstractPopoverDirective, AbstractDialogDirective, DbxActionModule, DbxButtonModule, DbxDialogInteractionModule, DbxPopoverInteractionModule, DbxTextModule } from '@dereekb/dbx-web';
+import * as i0 from '@angular/core';
+import { Injectable, SkipSelf, Directive, Injector, Optional, Component, Input, ElementRef, ViewChild, ChangeDetectionStrategy, EventEmitter, Output, NgModule } from '@angular/core';
+import { FieldType } from '@ngx-formly/material';
+import { map, distinctUntilChanged, shareReplay, BehaviorSubject, of, startWith, filter, first, throttleTime as throttleTime$1, switchMap as switchMap$1 } from 'rxjs';
+import { filterMaybe, SubscriptionObject, asObservable } from '@dereekb/rxjs';
+import { DateScheduleDayCode, expandDateScheduleDayCodesToDayOfWeekSet, dateTimingRelativeIndexFactory, dateBlockDayOfWeekFactory, isSameDate, isSameDateRange, isSameDateScheduleRange, findMaxDate, isSameDateDay, findMinDate, dateScheduleDateFilter, dateScheduleDayCodes, isDateInDateRangeFunction, isDateWithinDateBlockRangeFunction, dateScheduleEncodedWeek, dateBlockTimingDateFactory, enabledDaysFromDateScheduleDayCodes, dateScheduleDayCodesFromEnabledDays, formatToMonthDayString } from '@dereekb/date';
+import { setsAreEquivalent, iterableToArray, toggleInSet, addToSet, isIndexNumberInIndexRangeFunction, range, minAndMaxNumber, randomNumberFactory, getDaysOfWeekNames } from '@dereekb/util';
+import { ComponentStore } from '@ngrx/component-store';
+import { startOfDay, startOfYear, addYears } from 'date-fns';
+import { switchMap, throttleTime } from 'rxjs/operators';
+import * as i1 from '@dereekb/dbx-web/calendar';
+import { prepareAndSortCalendarEvents, DbxCalendarStore, DbxCalendarModule } from '@dereekb/dbx-web/calendar';
+import * as i3 from '@angular/forms';
+import { FormGroup, FormControl, FormsModule, ReactiveFormsModule } from '@angular/forms';
+import * as i3$1 from '@angular/common';
+import { CommonModule } from '@angular/common';
+import * as i5 from '@angular/material/form-field';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import * as i7 from '@angular/material/datepicker';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import * as i1$2 from '@angular/material/dialog';
+import * as i4$1 from 'angular-calendar';
+import { CalendarModule, CalendarDayModule, CalendarWeekModule } from 'angular-calendar';
+import * as i3$2 from '@dereekb/dbx-core';
+import * as i3$3 from '@angular/material/icon';
+import { MatIconModule } from '@angular/material/icon';
+import * as i2 from '@angular/material/button';
+import { MatButtonModule } from '@angular/material/button';
+import * as i1$3 from '@ngx-formly/core';
+import { FormlyModule } from '@ngx-formly/core';
+import { MatInputModule } from '@angular/material/input';
+import { MatButtonToggleModule } from '@angular/material/button-toggle';
+import { FlexLayoutModule } from '@angular/flex-layout';
+
+function dateScheduleRangeField(config = {}) {
+    const { key = 'schedule', filter } = config;
+    const fieldConfig = {
+        ...formlyField({
+            key,
+            type: 'date-schedule-range',
+            ...propsAndConfigForFieldConfig(config, {
+                label: config.label ?? 'Schedule',
+                filter
+            })
+        })
+    };
+    return fieldConfig;
+}
+
+var CalendarScheduleSelectionDayState;
+(function (CalendarScheduleSelectionDayState) {
+    CalendarScheduleSelectionDayState[CalendarScheduleSelectionDayState["NOT_APPLICABLE"] = 0] = "NOT_APPLICABLE";
+    CalendarScheduleSelectionDayState[CalendarScheduleSelectionDayState["DISABLED"] = 1] = "DISABLED";
+    CalendarScheduleSelectionDayState[CalendarScheduleSelectionDayState["NOT_SELECTED"] = 2] = "NOT_SELECTED";
+    CalendarScheduleSelectionDayState[CalendarScheduleSelectionDayState["SELECTED"] = 3] = "SELECTED";
+})(CalendarScheduleSelectionDayState || (CalendarScheduleSelectionDayState = {}));
+const defaultCalendarScheduleSelectionCellContentFactory = (day) => {
+    let icon;
+    let text;
+    switch (day.meta?.state) {
+        case CalendarScheduleSelectionDayState.SELECTED:
+            icon = 'check_box';
+            break;
+        case CalendarScheduleSelectionDayState.DISABLED:
+            icon = 'block';
+            break;
+        case CalendarScheduleSelectionDayState.NOT_APPLICABLE:
+            break;
+        case CalendarScheduleSelectionDayState.NOT_SELECTED:
+            icon = 'check_box_outline_blank';
+            text = 'Add';
+            break;
+    }
+    return {
+        icon,
+        text
+    };
+};
+
+function initialCalendarScheduleSelectionState() {
+    const start = startOfDay(new Date());
+    const scheduleDays = new Set([DateScheduleDayCode.WEEKDAY, DateScheduleDayCode.WEEKEND]);
+    const allowedDaysOfWeek = expandDateScheduleDayCodesToDayOfWeekSet(Array.from(scheduleDays));
+    const indexFactory = dateTimingRelativeIndexFactory({ start });
+    const indexDayOfWeek = dateBlockDayOfWeekFactory(start);
+    return {
+        start,
+        indexFactory,
+        selectedIndexes: new Set(),
+        scheduleDays,
+        allowedDaysOfWeek,
+        indexDayOfWeek,
+        isEnabledFilterDay: () => true,
+        isEnabledDay: () => false,
+        minDate: new Date(0),
+        maxDate: startOfYear(addYears(new Date(), 100)),
+        cellContentFactory: defaultCalendarScheduleSelectionCellContentFactory
+    };
+}
+class DbxCalendarScheduleSelectionStore extends ComponentStore {
+    constructor() {
+        super(initialCalendarScheduleSelectionState());
+        // MARK: Accessors
+        this.filter$ = this.state$.pipe(map((x) => x.filter), distinctUntilChanged(), shareReplay(1));
+        this.inputStart$ = this.state$.pipe(map((x) => x.inputStart), distinctUntilChanged(isSameDate), shareReplay(1));
+        this.inputEnd$ = this.state$.pipe(map((x) => x.inputEnd), distinctUntilChanged(isSameDate), shareReplay(1));
+        this.currentInputRange$ = this.state$.pipe(map(({ inputStart, inputEnd }) => ({ inputStart, inputEnd })), distinctUntilChanged((a, b) => isSameDate(a.inputStart, b.inputStart) && isSameDate(a.inputEnd, b.inputEnd)), map((x) => {
+            if (x.inputStart && x.inputEnd) {
+                return x;
+            }
+            else {
+                return undefined;
+            }
+        }), shareReplay(1));
+        this.inputRange$ = this.currentInputRange$.pipe(filterMaybe(), shareReplay(1));
+        this.selectedDates$ = this.state$.pipe(map((x) => x.selectedIndexes), distinctUntilChanged(), shareReplay(1));
+        this.isEnabledFilterDayFunction$ = this.state$.pipe(map((x) => x.isEnabledFilterDay), shareReplay(1));
+        this.isEnabledDayFunction$ = this.state$.pipe(map((x) => x.isEnabledDay), shareReplay(1));
+        this.currentDateRange$ = this.state$.pipe(map(computeCalendarScheduleSelectionRange), distinctUntilChanged((a, b) => isSameDateRange(a, b)), shareReplay(1));
+        this.dateRange$ = this.currentDateRange$.pipe(filterMaybe(), shareReplay(1));
+        this.scheduleDays$ = this.state$.pipe(map((x) => x.scheduleDays), distinctUntilChanged(setsAreEquivalent), shareReplay(1));
+        this.currentSelectionValue$ = this.state$.pipe(map((x) => x.currentSelectionValue), shareReplay(1));
+        this.selectionValue$ = this.currentSelectionValue$.pipe(filterMaybe(), shareReplay(1));
+        this.currentDateScheduleRangeValue$ = this.currentSelectionValue$.pipe(map((x) => x?.dateScheduleRange), distinctUntilChanged(isSameDateScheduleRange), shareReplay(1));
+        this.dateScheduleRangeValue$ = this.currentDateScheduleRangeValue$.pipe(filterMaybe(), shareReplay(1));
+        this.minDate$ = this.state$.pipe(map((x) => findMaxDate([x.filter?.start, x.minDate])), distinctUntilChanged(isSameDateDay), shareReplay(1));
+        this.maxDate$ = this.state$.pipe(map((x) => findMinDate([x.filter?.end, x.maxDate])), distinctUntilChanged(isSameDateDay), shareReplay(1));
+        this.cellContentFactory$ = this.state$.pipe(map((x) => x.cellContentFactory), distinctUntilChanged(), shareReplay(1));
+        this.isCustomized$ = this.state$.pipe(map((x) => x.selectedIndexes.size > 0), distinctUntilChanged(), shareReplay(1));
+        // MARK: State Changes
+        this.setFilter = this.updater((state, filter) => updateStateWithFilter(state, filter));
+        this.clearFilter = this.updater((state) => updateStateWithFilter(state, undefined));
+        this.setTimezone = this.updater((state, timezone) => ({ ...state, timezone }));
+        this.setInputRange = this.updater((state, range) => updateStateWithChangedRange(state, range));
+        this.toggleSelectedDates = this.updater((state, toggle) => updateStateWithChangedDates(state, { toggle }));
+        this.addSelectedDates = this.updater((state, add) => updateStateWithChangedDates(state, { add }));
+        this.removeSelectedDates = this.updater((state, remove) => updateStateWithChangedDates(state, { remove }));
+        this.setSelectedDates = this.updater((state, set) => updateStateWithChangedDates(state, { set }));
+        this.setScheduleDays = this.updater((state, scheduleDays) => updateStateWithChangedScheduleDays(state, scheduleDays));
+        this.setAllowAllScheduleDays = this.updater((state) => updateStateWithChangedScheduleDays(state, null));
+        this.setDateScheduleRangeValue = this.updater((state, value) => updateStateWithDateScheduleRangeValue(state, value));
+        this.setCellContentFactory = this.updater((state, cellContentFactory) => ({ ...state, cellContentFactory }));
+    }
+}
+DbxCalendarScheduleSelectionStore.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStore, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DbxCalendarScheduleSelectionStore.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStore });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStore, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+function updateStateWithFilter(state, filter) {
+    let isEnabledFilterDay = () => true;
+    if (filter) {
+        isEnabledFilterDay = dateScheduleDateFilter(filter);
+    }
+    return { ...state, filter, isEnabledFilterDay };
+}
+function updateStateWithDateScheduleRangeValue(state, change) {
+    const isSameValue = isSameDateScheduleRange(state.currentSelectionValue?.dateScheduleRange, change);
+    if (isSameValue) {
+        return state;
+    }
+    else {
+        if (change != null) {
+            const nextState = { ...state, inputStart: change.start, inputEnd: change.end, selectedIndexes: new Set(change.ex) };
+            return updateStateWithChangedScheduleDays(finalizeNewCalendarScheduleSelectionState(nextState), dateScheduleDayCodes(change.w));
+        }
+        else {
+            return noSelectionCalendarScheduleSelectionState(state); // clear selection, retain disabled days
+        }
+    }
+}
+function updateStateWithChangedScheduleDays(state, change) {
+    const { scheduleDays: currentScheduleDays } = state;
+    const scheduleDays = new Set(change || [DateScheduleDayCode.WEEKDAY, DateScheduleDayCode.WEEKEND]);
+    if (setsAreEquivalent(currentScheduleDays, scheduleDays)) {
+        return state; // no change
+    }
+    else {
+        const allowedDaysOfWeek = expandDateScheduleDayCodesToDayOfWeekSet(Array.from(scheduleDays));
+        const nextState = { ...state, scheduleDays, allowedDaysOfWeek };
+        return finalizeNewCalendarScheduleSelectionState(nextState);
+    }
+}
+function updateStateWithChangedDates(state, change) {
+    const { indexFactory, allowedDaysOfWeek, indexDayOfWeek } = state;
+    let selectedIndexes;
+    if (change.set) {
+        selectedIndexes = new Set(iterableToArray(change.set).map(indexFactory));
+    }
+    else {
+        selectedIndexes = new Set(state.selectedIndexes);
+        if (change.toggle) {
+            const allowedToToggle = iterableToArray(change.toggle)
+                .map(indexFactory)
+                .filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
+            toggleInSet(selectedIndexes, allowedToToggle);
+        }
+        if (change.add) {
+            addToSet(selectedIndexes, iterableToArray(change.add).map(indexFactory));
+        }
+        if (change.remove) {
+            addToSet(selectedIndexes, iterableToArray(change.remove).map(indexFactory));
+        }
+    }
+    const nextState = { ...state, selectedIndexes };
+    nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
+    // Recalculate the range and simplified to exclusions
+    const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(nextState);
+    if (rangeAndExclusion) {
+        return finalizeNewCalendarScheduleSelectionState({ ...nextState, selectedIndexes: new Set(rangeAndExclusion.excluded), inputStart: rangeAndExclusion.start, inputEnd: rangeAndExclusion.end });
+    }
+    else {
+        // no selected days
+        return noSelectionCalendarScheduleSelectionState(state);
+    }
+}
+function noSelectionCalendarScheduleSelectionState(state) {
+    return finalizeNewCalendarScheduleSelectionState({ ...state, selectedIndexes: new Set(), inputStart: null, inputEnd: null });
+}
+function updateStateWithChangedRange(state, change) {
+    const { inputStart: currentInputStart, inputEnd: currentInputEnd, indexFactory, minDate, maxDate } = state;
+    const inputStart = startOfDay(change.inputStart);
+    const inputEnd = startOfDay(change.inputEnd);
+    const isValidRange = minDate != null || maxDate != null ? isDateInDateRangeFunction({ start: minDate ?? undefined, end: maxDate ?? undefined }) : () => true;
+    if (!isValidRange(inputStart) || !isValidRange(inputEnd) || (isSameDateDay(inputStart, currentInputStart) && isSameDateDay(inputEnd, currentInputEnd))) {
+        return state; // if no change, return the current state.
+    }
+    // retain all indexes that are within the new range
+    const minIndex = indexFactory(inputStart);
+    const maxIndex = indexFactory(inputEnd) + 1;
+    const currentIndexes = Array.from(state.selectedIndexes);
+    const isInCurrentRange = isIndexNumberInIndexRangeFunction({ minIndex, maxIndex });
+    const excludedIndexesInNewRange = currentIndexes.filter(isInCurrentRange);
+    const nextState = { ...state, excludedIndexesInNewRange, inputStart, inputEnd };
+    return finalizeNewCalendarScheduleSelectionState(nextState);
+}
+function finalizeNewCalendarScheduleSelectionState(nextState) {
+    nextState.isEnabledDay = isEnabledDayInCalendarScheduleSelectionState(nextState);
+    nextState.currentSelectionValue = computeScheduleSelectionValue(nextState);
+    return nextState;
+}
+function isEnabledDayInCalendarScheduleSelectionState(state) {
+    const { indexFactory, inputStart, inputEnd, indexDayOfWeek, allowedDaysOfWeek } = state;
+    let isInStartAndEndRange;
+    if (inputStart && inputEnd) {
+        isInStartAndEndRange = isDateWithinDateBlockRangeFunction({ start: state.start, range: { start: inputStart, end: inputEnd } });
+    }
+    else {
+        isInStartAndEndRange = () => false;
+    }
+    return (input) => {
+        const index = indexFactory(input);
+        const dayOfWeek = indexDayOfWeek(index);
+        const isInSelectedRange = isInStartAndEndRange(input);
+        const isSelected = state.selectedIndexes.has(index);
+        const isAllowedDayOfWeek = allowedDaysOfWeek.has(dayOfWeek);
+        const result = isAllowedDayOfWeek && ((isInSelectedRange && !isSelected) || (isSelected && !isInSelectedRange));
+        return result;
+    };
+}
+function computeScheduleSelectionValue(state) {
+    const { scheduleDays, allowedDaysOfWeek, indexDayOfWeek } = state;
+    const rangeAndExclusion = computeScheduleSelectionRangeAndExclusion(state);
+    if (rangeAndExclusion == null) {
+        return null;
+    }
+    const { start, end, excluded, dateBlockRange } = rangeAndExclusion;
+    const indexOffset = dateBlockRange.i;
+    const ex = excluded
+        .filter((x) => {
+        const isExcludedIndex = allowedDaysOfWeek.has(indexDayOfWeek(x));
+        return isExcludedIndex;
+    })
+        .map((x) => x - indexOffset); // set to the proper offset
+    const w = dateScheduleEncodedWeek(scheduleDays);
+    const d = []; // "included" blocks are never used/calculated.
+    const dateScheduleRange = {
+        start,
+        end,
+        w,
+        d,
+        ex
+    };
+    return {
+        dateScheduleRange,
+        minMaxRange: { start, end }
+    };
+}
+function computeScheduleSelectionRangeAndExclusion(state) {
+    const { isEnabledDay } = state;
+    const dateFactory = dateBlockTimingDateFactory(state);
+    const dateBlockRange = computeCalendarScheduleSelectionDateBlockRange(state);
+    if (dateBlockRange == null) {
+        return null; // returns null if no items are selected.
+    }
+    const start = dateFactory(dateBlockRange.i);
+    const end = dateFactory(dateBlockRange.to);
+    const excluded = range(dateBlockRange.i, dateBlockRange.to + 1).filter((x) => {
+        const isExcludedIndex = !isEnabledDay(x);
+        return isExcludedIndex;
+    });
+    const result = {
+        dateBlockRange,
+        start,
+        end,
+        excluded
+    };
+    return result;
+}
+function computeCalendarScheduleSelectionRange(state) {
+    const dateFactory = dateBlockTimingDateFactory(state);
+    const dateBlockRange = computeCalendarScheduleSelectionDateBlockRange(state);
+    if (dateBlockRange != null) {
+        return { start: dateFactory(dateBlockRange.i), end: dateFactory(dateBlockRange.to) };
+    }
+    else {
+        return undefined;
+    }
+}
+function computeCalendarScheduleSelectionDateBlockRange(state) {
+    const { indexFactory, inputStart, inputEnd, allowedDaysOfWeek, indexDayOfWeek, isEnabledDay, isEnabledFilterDay } = state;
+    const enabledSelectedIndexes = Array.from(state.selectedIndexes).filter((i) => allowedDaysOfWeek.has(indexDayOfWeek(i)));
+    const minAndMaxSelectedValues = minAndMaxNumber(enabledSelectedIndexes);
+    let startRange;
+    let endRange;
+    if (minAndMaxSelectedValues) {
+        startRange = minAndMaxSelectedValues.min;
+        endRange = minAndMaxSelectedValues.max;
+    }
+    if (inputStart != null && inputEnd != null) {
+        const inputStartIndex = indexFactory(inputStart);
+        const inputEndIndex = indexFactory(inputEnd);
+        startRange = startRange != null ? Math.min(inputStartIndex, startRange) : inputStartIndex;
+        endRange = endRange != null ? Math.max(inputEndIndex, endRange) : inputEndIndex;
+    }
+    if (startRange != null && endRange != null) {
+        const scanStartIndex = startRange;
+        const scanEndIndex = endRange;
+        // clear start and end
+        startRange = undefined;
+        endRange = undefined;
+        // if the min is equal to the start index, then we are in the range and need to iterate dates until we find one that is not selected/excluded.
+        for (let i = scanStartIndex; i <= scanEndIndex; i += 1) {
+            if (isEnabledFilterDay(i) && isEnabledDay(i)) {
+                startRange = i;
+                break;
+            }
+        }
+        // same with the max
+        for (let i = scanEndIndex; i >= scanStartIndex; i -= 1) {
+            if (isEnabledFilterDay(i) && isEnabledDay(i)) {
+                endRange = i;
+                break;
+            }
+        }
+    }
+    if (startRange != null && endRange != null) {
+        return { i: startRange, to: endRange };
+    }
+    else {
+        return undefined;
+    }
+}
+
+/**
+ * Token used by provideCalendarScheduleSelectionStoreIfDoesNotExist() to prevent injecting a parent DbxCalendarScheduleSelectionStore into the child view.
+ */
+class DbxCalendarScheduleSelectionStoreProviderBlock {
+    constructor(dbxCalendarScheduleSelectionStore) {
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+    }
+}
+DbxCalendarScheduleSelectionStoreProviderBlock.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStoreProviderBlock, deps: [{ token: DbxCalendarScheduleSelectionStore, skipSelf: true }], target: i0.ɵɵFactoryTarget.Injectable });
+DbxCalendarScheduleSelectionStoreProviderBlock.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStoreProviderBlock });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStoreProviderBlock, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: DbxCalendarScheduleSelectionStore, decorators: [{
+                    type: SkipSelf
+                }] }]; } });
+class DbxCalendarScheduleSelectionStoreInjectionBlockDirective {
+}
+DbxCalendarScheduleSelectionStoreInjectionBlockDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStoreInjectionBlockDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DbxCalendarScheduleSelectionStoreInjectionBlockDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.12", type: DbxCalendarScheduleSelectionStoreInjectionBlockDirective, selector: "[dbxCalendarScheduleSelectionStoreParentBlocker]", providers: [DbxCalendarScheduleSelectionStoreProviderBlock], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxCalendarScheduleSelectionStoreInjectionBlockDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dbxCalendarScheduleSelectionStoreParentBlocker]',
+                    providers: [DbxCalendarScheduleSelectionStoreProviderBlock]
+                }]
+        }] });
+/**
+ * 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
+ */
+function provideCalendarScheduleSelectionStoreIfParentIsUnavailable() {
+    return {
+        provide: DbxCalendarScheduleSelectionStore,
+        useFactory: (parentInjector, dbxCalendarScheduleSelectionStoreInjectionBlock, dbxCalendarScheduleSelectionStore) => {
+            if (!dbxCalendarScheduleSelectionStore || (dbxCalendarScheduleSelectionStore && dbxCalendarScheduleSelectionStoreInjectionBlock != null && dbxCalendarScheduleSelectionStoreInjectionBlock.dbxCalendarScheduleSelectionStore === dbxCalendarScheduleSelectionStore)) {
+                // create a new dbxCalendarScheduleSelectionStore to use
+                const injector = Injector.create({ providers: [{ provide: DbxCalendarScheduleSelectionStore }], parent: parentInjector });
+                dbxCalendarScheduleSelectionStore = injector.get(DbxCalendarScheduleSelectionStore);
+            }
+            return dbxCalendarScheduleSelectionStore;
+        },
+        deps: [Injector, [new Optional(), DbxCalendarScheduleSelectionStoreProviderBlock], [new Optional(), new SkipSelf(), DbxCalendarScheduleSelectionStore]]
+    };
+}
+
+class DbxScheduleSelectionCalendarDateRangeComponent {
+    constructor(dbxCalendarStore, dbxCalendarScheduleSelectionStore) {
+        this.dbxCalendarStore = dbxCalendarStore;
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+        this.appearance = 'fill';
+        this.label = 'Enter a date range';
+        this.showCustomize = false;
+        this.random = randomNumberFactory(10000)();
+        this._pickerOpened = new BehaviorSubject(false);
+        this._syncSub = new SubscriptionObject();
+        this._valueSub = new SubscriptionObject();
+        this.range = new FormGroup({
+            start: new FormControl(null),
+            end: new FormControl(null)
+        });
+        this.minDate$ = this.dbxCalendarScheduleSelectionStore.minDate$;
+        this.maxDate$ = this.dbxCalendarScheduleSelectionStore.maxDate$;
+        this.isCustomized$ = this.dbxCalendarScheduleSelectionStore.isCustomized$;
+        this.pickerOpened$ = this._pickerOpened.asObservable();
+    }
+    set disabled(disabled) {
+        if (disabled) {
+            this.range.disable();
+        }
+        else {
+            this.range.enable();
+        }
+    }
+    ngOnInit() {
+        this._syncSub.subscription = this.dbxCalendarScheduleSelectionStore.inputRange$.subscribe((x) => {
+            this.range.setValue({
+                start: x.inputStart ?? null,
+                end: x.inputEnd ?? null
+            });
+        });
+        this._valueSub.subscription = this._pickerOpened
+            .pipe(distinctUntilChanged(), switchMap((opened) => {
+            let obs;
+            if (opened) {
+                obs = of({});
+            }
+            else {
+                obs = this.range.valueChanges.pipe(startWith(this.range.value));
+            }
+            return obs;
+        }), filter((x) => Boolean(x.start && x.end)), distinctUntilChanged((a, b) => isSameDateDay(a.start, b.start) && isSameDateDay(a.end, b.end)), throttleTime(100, undefined, { trailing: true }))
+            .subscribe((x) => {
+            if (x.start && x.end) {
+                this.dbxCalendarScheduleSelectionStore.setInputRange({ inputStart: x.start, inputEnd: x.end });
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._syncSub.destroy();
+        this._valueSub.destroy();
+    }
+    pickerOpened() {
+        this._pickerOpened.next(true);
+    }
+    pickerClosed() {
+        this._pickerOpened.next(false);
+    }
+}
+DbxScheduleSelectionCalendarDateRangeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateRangeComponent, deps: [{ token: i1.DbxCalendarStore }, { token: DbxCalendarScheduleSelectionStore }], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDateRangeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDateRangeComponent, selector: "dbx-schedule-selection-calendar-date-range", inputs: { required: "required", appearance: "appearance", label: "label", hint: "hint", disabled: "disabled", showCustomize: "showCustomize" }, ngImport: i0, template: "<mat-form-field class=\"dbx-schedule-selection-calendar-date-range-field\" [appearance]=\"appearance\">\n  <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n  <div *ngIf=\"showCustomize && (isCustomized$ | async)\" class=\"date-range-field-customized\">\n    <span class=\"dbx-accent-bg date-range-field-customized-text\">Custom</span>\n  </div>\n  <mat-date-range-input [required]=\"required\" [min]=\"minDate$ | async\" [max]=\"maxDate$ | async\" [formGroup]=\"range\" [rangePicker]=\"picker\">\n    <input matStartDate formControlName=\"start\" placeholder=\"Start date\" />\n    <input matEndDate formControlName=\"end\" placeholder=\"End date\" />\n  </mat-date-range-input>\n  <mat-datepicker-toggle matIconSuffix [for]=\"picker\"></mat-datepicker-toggle>\n  <div *ngIf=\"showCustomize\">\n    <dbx-button-spacer></dbx-button-spacer>\n    <ng-content select=\"[customizeButton]\"></ng-content>\n  </div>\n  <mat-date-range-picker #picker (opened)=\"pickerOpened()\" (closed)=\"pickerClosed()\"></mat-date-range-picker>\n  <mat-error *ngIf=\"range.controls.start.hasError('matStartDateInvalid')\">Invalid start date</mat-error>\n  <mat-error *ngIf=\"range.controls.end.hasError('matEndDateInvalid')\">Invalid end date</mat-error>\n</mat-form-field>\n", dependencies: [{ kind: "directive", type: i3.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i3.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i3.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i3.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "directive", type: i3$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i5.MatError, selector: "mat-error", inputs: ["id"] }, { kind: "component", type: i5.MatFormField, selector: "mat-form-field", inputs: ["color", "appearance", "hideRequiredMarker", "hintLabel", "floatLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i5.MatLabel, selector: "mat-label" }, { kind: "directive", type: i1$1.DbxButtonSpacerDirective, selector: "dbx-button-spacer,[dbxButtonSpacer]" }, { kind: "component", type: i7.MatDatepickerToggle, selector: "mat-datepicker-toggle", inputs: ["for", "tabIndex", "aria-label", "disabled", "disableRipple"], exportAs: ["matDatepickerToggle"] }, { kind: "component", type: i7.MatDateRangeInput, selector: "mat-date-range-input", inputs: ["rangePicker", "required", "dateFilter", "min", "max", "disabled", "separator", "comparisonStart", "comparisonEnd"], exportAs: ["matDateRangeInput"] }, { kind: "directive", type: i7.MatStartDate, selector: "input[matStartDate]", inputs: ["errorStateMatcher"], outputs: ["dateChange", "dateInput"] }, { kind: "directive", type: i7.MatEndDate, selector: "input[matEndDate]", inputs: ["errorStateMatcher"], outputs: ["dateChange", "dateInput"] }, { kind: "component", type: i7.MatDateRangePicker, selector: "mat-date-range-picker", exportAs: ["matDateRangePicker"] }, { kind: "pipe", type: i3$1.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateRangeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dbx-schedule-selection-calendar-date-range', template: "<mat-form-field class=\"dbx-schedule-selection-calendar-date-range-field\" [appearance]=\"appearance\">\n  <mat-label *ngIf=\"label\">{{ label }}</mat-label>\n  <div *ngIf=\"showCustomize && (isCustomized$ | async)\" class=\"date-range-field-customized\">\n    <span class=\"dbx-accent-bg date-range-field-customized-text\">Custom</span>\n  </div>\n  <mat-date-range-input [required]=\"required\" [min]=\"minDate$ | async\" [max]=\"maxDate$ | async\" [formGroup]=\"range\" [rangePicker]=\"picker\">\n    <input matStartDate formControlName=\"start\" placeholder=\"Start date\" />\n    <input matEndDate formControlName=\"end\" placeholder=\"End date\" />\n  </mat-date-range-input>\n  <mat-datepicker-toggle matIconSuffix [for]=\"picker\"></mat-datepicker-toggle>\n  <div *ngIf=\"showCustomize\">\n    <dbx-button-spacer></dbx-button-spacer>\n    <ng-content select=\"[customizeButton]\"></ng-content>\n  </div>\n  <mat-date-range-picker #picker (opened)=\"pickerOpened()\" (closed)=\"pickerClosed()\"></mat-date-range-picker>\n  <mat-error *ngIf=\"range.controls.start.hasError('matStartDateInvalid')\">Invalid start date</mat-error>\n  <mat-error *ngIf=\"range.controls.end.hasError('matEndDateInvalid')\">Invalid end date</mat-error>\n</mat-form-field>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.DbxCalendarStore }, { type: DbxCalendarScheduleSelectionStore }]; }, propDecorators: { required: [{
+                type: Input
+            }], appearance: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], hint: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], showCustomize: [{
+                type: Input
+            }] } });
+
+function dbxScheduleSelectionCalendarDateDaysFormFields() {
+    const fields = dbxScheduleSelectionCalendarDateDaysFormDayFields();
+    return [flexLayoutWrapper(fields, { relative: true, size: 3 })];
+}
+function dbxScheduleSelectionCalendarDateDaysFormDayFields() {
+    return getDaysOfWeekNames(false).map((dayOfWeekName) => {
+        return toggleField({
+            key: dayOfWeekName.toLowerCase(),
+            label: dayOfWeekName
+        });
+    });
+}
+
+class DbxScheduleSelectionCalendarDateDaysFormComponent extends AbstractSyncFormlyFormDirective {
+    constructor() {
+        super(...arguments);
+        this.fields = dbxScheduleSelectionCalendarDateDaysFormFields();
+    }
+}
+DbxScheduleSelectionCalendarDateDaysFormComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDaysFormComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDateDaysFormComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDateDaysFormComponent, selector: "dbx-schedule-selection-calendar-date-days-form", providers: [provideFormlyContext()], usesInheritance: true, ngImport: i0, template: `
+    <dbx-formly></dbx-formly>
+  `, isInline: true, dependencies: [{ kind: "component", type: i4.DbxFormlyFormComponent, selector: "dbx-formly", exportAs: ["formly"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDaysFormComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <dbx-formly></dbx-formly>
+  `,
+                    selector: 'dbx-schedule-selection-calendar-date-days-form',
+                    providers: [provideFormlyContext()]
+                }]
+        }] });
+
+class DbxScheduleSelectionCalendarDateDaysComponent {
+    constructor(dbxCalendarStore, dbxCalendarScheduleSelectionStore) {
+        this.dbxCalendarStore = dbxCalendarStore;
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+        this.template$ = this.dbxCalendarScheduleSelectionStore.scheduleDays$.pipe(map(enabledDaysFromDateScheduleDayCodes), shareReplay());
+        this.isFormModified = (value) => {
+            const newSetValue = new Set(dateScheduleDayCodesFromEnabledDays(value));
+            return this.dbxCalendarScheduleSelectionStore.scheduleDays$.pipe(map((currentSet) => !setsAreEquivalent(currentSet, newSetValue)));
+        };
+        this.updateScheduleDays = (value) => {
+            this.dbxCalendarScheduleSelectionStore.setScheduleDays(new Set(dateScheduleDayCodesFromEnabledDays(value)));
+            return of(true);
+        };
+    }
+}
+DbxScheduleSelectionCalendarDateDaysComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDaysComponent, deps: [{ token: i1.DbxCalendarStore }, { token: DbxCalendarScheduleSelectionStore }], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDateDaysComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDateDaysComponent, selector: "dbx-schedule-selection-calendar-date-days", ngImport: i0, template: `
+    <div class="dbx-schedule-selection-calendar-date-days" dbxAction dbxActionAutoTrigger dbxActionEnforceModified [instantTrigger]="true" [dbxActionHandler]="updateScheduleDays">
+      <dbx-schedule-selection-calendar-date-days-form dbxActionForm [dbxFormSource]="template$" [dbxActionFormModified]="isFormModified"></dbx-schedule-selection-calendar-date-days-form>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i3$2.DbxActionDirective, selector: "dbx-action,[dbxAction],dbx-action-context,[dbxActionContext]", exportAs: ["action", "dbxAction"] }, { kind: "directive", type: i3$2.DbxActionHandlerDirective, selector: "[dbxActionHandler]", inputs: ["dbxActionHandler"] }, { kind: "directive", type: i3$2.DbxActionEnforceModifiedDirective, selector: "[dbxActionEnforceModified]", inputs: ["dbxActionEnforceModified"] }, { kind: "directive", type: i3$2.DbxActionAutoTriggerDirective, selector: "dbxActionAutoTrigger, [dbxActionAutoTrigger]", inputs: ["dbxActionAutoTrigger", "triggerDebounce", "triggerThrottle", "triggerErrorThrottle", "fastTrigger", "instantTrigger", "triggerLimit"] }, { kind: "directive", type: i4.DbxActionFormDirective, selector: "[dbxActionForm]", inputs: ["dbxActionFormValidator", "dbxActionFormModified", "formDisabledOnWorking"] }, { kind: "directive", type: i4.DbxFormSourceDirective, selector: "[dbxFormSource]", inputs: ["dbxFormSourceMode", "dbxFormSource"] }, { kind: "component", type: DbxScheduleSelectionCalendarDateDaysFormComponent, selector: "dbx-schedule-selection-calendar-date-days-form" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDaysComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-schedule-selection-calendar-date-days',
+                    template: `
+    <div class="dbx-schedule-selection-calendar-date-days" dbxAction dbxActionAutoTrigger dbxActionEnforceModified [instantTrigger]="true" [dbxActionHandler]="updateScheduleDays">
+      <dbx-schedule-selection-calendar-date-days-form dbxActionForm [dbxFormSource]="template$" [dbxActionFormModified]="isFormModified"></dbx-schedule-selection-calendar-date-days-form>
+    </div>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: i1.DbxCalendarStore }, { type: DbxCalendarScheduleSelectionStore }]; } });
+
+class DbxScheduleSelectionCalendarDatePopoverContentComponent {
+    ngOnDestroy() { }
+}
+DbxScheduleSelectionCalendarDatePopoverContentComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverContentComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDatePopoverContentComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDatePopoverContentComponent, selector: "dbx-schedule-selection-calendar-date-popover-content", ngImport: i0, template: `
+    <div>
+      <dbx-schedule-selection-calendar-date-range></dbx-schedule-selection-calendar-date-range>
+      <dbx-schedule-selection-calendar-date-days></dbx-schedule-selection-calendar-date-days>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "component", type: DbxScheduleSelectionCalendarDateDaysComponent, selector: "dbx-schedule-selection-calendar-date-days" }, { kind: "component", type: DbxScheduleSelectionCalendarDateRangeComponent, selector: "dbx-schedule-selection-calendar-date-range", inputs: ["required", "appearance", "label", "hint", "disabled", "showCustomize"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverContentComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-schedule-selection-calendar-date-popover-content',
+                    template: `
+    <div>
+      <dbx-schedule-selection-calendar-date-range></dbx-schedule-selection-calendar-date-range>
+      <dbx-schedule-selection-calendar-date-days></dbx-schedule-selection-calendar-date-days>
+    </div>
+  `
+                }]
+        }] });
+
+const DEFAULT_SCHEDULE_SELECTION_CALENDAR_DATE_POPOVER_KEY = 'calendarselection';
+class DbxScheduleSelectionCalendarDatePopoverComponent extends AbstractPopoverDirective {
+    static openPopover(popoverService, { origin, injector }, popoverKey) {
+        return popoverService.open({
+            key: popoverKey ?? DEFAULT_SCHEDULE_SELECTION_CALENDAR_DATE_POPOVER_KEY,
+            origin,
+            componentClass: DbxScheduleSelectionCalendarDatePopoverComponent,
+            injector
+        });
+    }
+}
+DbxScheduleSelectionCalendarDatePopoverComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDatePopoverComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDatePopoverComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <dbx-popover-content>
+      <dbx-popover-scroll-content>
+        <dbx-schedule-selection-calendar-date-popover-content (close)="close()"></dbx-schedule-selection-calendar-date-popover-content>
+      </dbx-popover-scroll-content>
+    </dbx-popover-content>
+  `, isInline: true, dependencies: [{ kind: "component", type: i1$1.DbxPopoverContentComponent, selector: "dbx-popover-content" }, { kind: "component", type: i1$1.DbxPopoverScrollContentComponent, selector: "dbx-popover-scroll-content" }, { kind: "component", type: DbxScheduleSelectionCalendarDatePopoverContentComponent, selector: "dbx-schedule-selection-calendar-date-popover-content" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <dbx-popover-content>
+      <dbx-popover-scroll-content>
+        <dbx-schedule-selection-calendar-date-popover-content (close)="close()"></dbx-schedule-selection-calendar-date-popover-content>
+      </dbx-popover-scroll-content>
+    </dbx-popover-content>
+  `
+                }]
+        }] });
+
+class DbxScheduleSelectionCalendarDatePopoverButtonComponent {
+    constructor(popoverService, dbxCalendarScheduleSelectionStore, injector) {
+        this.popoverService = popoverService;
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+        this.injector = injector;
+        this.buttonText$ = this.dbxCalendarScheduleSelectionStore.currentDateRange$.pipe(map((x) => {
+            if (x?.start && x.end) {
+                return `${formatToMonthDayString(x.start)} - ${formatToMonthDayString(x.end)}`;
+            }
+            else {
+                return 'Pick a Date Range';
+            }
+        }), shareReplay(1));
+    }
+    openPopover() {
+        DbxScheduleSelectionCalendarDatePopoverComponent.openPopover(this.popoverService, { origin: this.buttonPopoverOrigin, injector: this.injector });
+    }
+}
+DbxScheduleSelectionCalendarDatePopoverButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverButtonComponent, deps: [{ token: i1$1.DbxPopoverService }, { token: DbxCalendarScheduleSelectionStore }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDatePopoverButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDatePopoverButtonComponent, selector: "dbx-schedule-selection-calendar-date-popover-button", viewQueries: [{ propertyName: "buttonPopoverOrigin", first: true, predicate: ["buttonPopoverOrigin"], descendants: true, read: ElementRef }], ngImport: i0, template: `
+    <dbx-button #buttonPopoverOrigin icon="date_range" [raised]="true" color="accent" [text]="buttonText$ | async" (buttonClick)="openPopover()"></dbx-button>
+  `, isInline: true, dependencies: [{ kind: "component", type: i1$1.DbxButtonComponent, selector: "dbx-button", inputs: ["type", "raised", "stroked", "flat", "color", "customButtonColor", "customTextColor", "customSpinnerColor"] }, { kind: "pipe", type: i3$1.AsyncPipe, name: "async" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDatePopoverButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-schedule-selection-calendar-date-popover-button',
+                    template: `
+    <dbx-button #buttonPopoverOrigin icon="date_range" [raised]="true" color="accent" [text]="buttonText$ | async" (buttonClick)="openPopover()"></dbx-button>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.DbxPopoverService }, { type: DbxCalendarScheduleSelectionStore }, { type: i0.Injector }]; }, propDecorators: { buttonPopoverOrigin: [{
+                type: ViewChild,
+                args: ['buttonPopoverOrigin', { read: ElementRef }]
+            }] } });
+
+class DbxScheduleSelectionCalendarCellComponent {
+    constructor(dbxCalendarScheduleSelectionStore) {
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+        this.content = {};
+    }
+    get icon() {
+        return this.content.icon;
+    }
+    get text() {
+        return this.content.text;
+    }
+    set day(day) {
+        this.dbxCalendarScheduleSelectionStore.cellContentFactory$.pipe(first()).subscribe((fn) => {
+            this.content = fn(day);
+        });
+    }
+}
+DbxScheduleSelectionCalendarCellComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarCellComponent, deps: [{ token: DbxCalendarScheduleSelectionStore }], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarCellComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarCellComponent, selector: "dbx-schedule-selection-calendar-cell", inputs: { day: "day" }, host: { classAttribute: "dbx-schedule-selection-calendar-cell" }, ngImport: i0, template: `
+    <mat-icon *ngIf="icon">{{ icon }}</mat-icon>
+    <span>{{ text }}</span>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i3$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i3$3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarCellComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-schedule-selection-calendar-cell',
+                    template: `
+    <mat-icon *ngIf="icon">{{ icon }}</mat-icon>
+    <span>{{ text }}</span>
+  `,
+                    host: {
+                        class: 'dbx-schedule-selection-calendar-cell'
+                    },
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: DbxCalendarScheduleSelectionStore }]; }, propDecorators: { day: [{
+                type: Input
+            }] } });
+
+class DbxScheduleSelectionCalendarComponent {
+    constructor(calendarStore, dbxCalendarScheduleSelectionStore) {
+        this.calendarStore = calendarStore;
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+        this.clickEvent = new EventEmitter();
+        // refresh any time the selected day function updates
+        this.state$ = this.dbxCalendarScheduleSelectionStore.state$;
+        this.refresh$ = this.state$.pipe(throttleTime$1(100), map(() => undefined));
+        this.events$ = this.calendarStore.visibleEvents$.pipe(map(prepareAndSortCalendarEvents), shareReplay(1));
+        this.viewDate$ = this.calendarStore.date$;
+    }
+    dayClicked({ date }) {
+        this.dbxCalendarScheduleSelectionStore.toggleSelectedDates(date);
+    }
+    eventClicked(action, event) {
+        this.clickEvent.emit({ action, event });
+    }
+    beforeMonthViewRender({ body }) {
+        this.state$.pipe(first()).subscribe(({ isEnabledDay, indexFactory, isEnabledFilterDay, allowedDaysOfWeek }) => {
+            body.forEach((viewDay) => {
+                const { date } = viewDay;
+                const i = indexFactory(date);
+                const day = date.getDay();
+                let state;
+                if (!isEnabledFilterDay(i)) {
+                    viewDay.cssClass = 'cal-day-not-applicable';
+                    state = CalendarScheduleSelectionDayState.NOT_APPLICABLE;
+                }
+                else if (!allowedDaysOfWeek.has(day)) {
+                    viewDay.cssClass = 'cal-day-disabled';
+                    state = CalendarScheduleSelectionDayState.DISABLED;
+                }
+                else if (isEnabledDay(i)) {
+                    viewDay.cssClass = 'cal-day-selected';
+                    state = CalendarScheduleSelectionDayState.SELECTED;
+                }
+                else {
+                    viewDay.cssClass = 'cal-day-not-selected';
+                    state = CalendarScheduleSelectionDayState.NOT_SELECTED;
+                }
+                viewDay.meta = {
+                    state,
+                    i
+                };
+            });
+        });
+    }
+    ngOnDestroy() {
+        this.clickEvent.complete();
+    }
+}
+DbxScheduleSelectionCalendarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarComponent, deps: [{ token: i1.DbxCalendarStore }, { token: DbxCalendarScheduleSelectionStore }], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarComponent, selector: "dbx-schedule-selection-calendar", outputs: { clickEvent: "clickEvent" }, providers: [DbxCalendarStore], ngImport: i0, template: "<dbx-calendar-base class=\"dbx-schedule-selection-calendar\">\n  <ng-container controls>\n    <dbx-schedule-selection-calendar-date-popover-button></dbx-schedule-selection-calendar-date-popover-button>\n  </ng-container>\n  <div class=\"dbx-calendar-content dbx-calendar-content-month\">\n    <mwl-calendar-month-view [refresh]=\"refresh$\" [viewDate]=\"(viewDate$ | async)!\" [events]=\"(events$ | async)!\" (dayClicked)=\"dayClicked($event.day)\" (eventClicked)=\"eventClicked('Clicked', $event.event)\" (beforeViewRender)=\"beforeMonthViewRender($event)\" [cellTemplate]=\"monthDayCellTemplate\"></mwl-calendar-month-view>\n  </div>\n</dbx-calendar-base>\n\n<!-- Cell -->\n<ng-template #monthDayCellTemplate let-day=\"day\" let-locale=\"locale\">\n  <div class=\"cal-cell-top\">\n    <span class=\"cal-day-badge\" *ngIf=\"day.badgeTotal > 0\">{{ day.badgeTotal }}</span>\n    <span class=\"cal-day-number\">{{ day.date | calendarDate: 'monthViewDayNumber':locale }}</span>\n  </div>\n  <dbx-schedule-selection-calendar-cell [day]=\"day\"></dbx-schedule-selection-calendar-cell>\n</ng-template>\n", dependencies: [{ kind: "component", type: i1.DbxCalendarBaseComponent, selector: "dbx-calendar-base" }, { kind: "directive", type: i3$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i4$1.CalendarMonthViewComponent, selector: "mwl-calendar-month-view", inputs: ["viewDate", "events", "excludeDays", "activeDayIsOpen", "activeDay", "refresh", "locale", "tooltipPlacement", "tooltipTemplate", "tooltipAppendToBody", "tooltipDelay", "weekStartsOn", "headerTemplate", "cellTemplate", "openDayEventsTemplate", "eventTitleTemplate", "eventActionsTemplate", "weekendDays"], outputs: ["beforeViewRender", "dayClicked", "eventClicked", "columnHeaderClicked", "eventTimesChanged"] }, { kind: "component", type: DbxScheduleSelectionCalendarDatePopoverButtonComponent, selector: "dbx-schedule-selection-calendar-date-popover-button" }, { kind: "component", type: DbxScheduleSelectionCalendarCellComponent, selector: "dbx-schedule-selection-calendar-cell", inputs: ["day"] }, { kind: "pipe", type: i3$1.AsyncPipe, name: "async" }, { kind: "pipe", type: i4$1.ɵCalendarDatePipe, name: "calendarDate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'dbx-schedule-selection-calendar', providers: [DbxCalendarStore], template: "<dbx-calendar-base class=\"dbx-schedule-selection-calendar\">\n  <ng-container controls>\n    <dbx-schedule-selection-calendar-date-popover-button></dbx-schedule-selection-calendar-date-popover-button>\n  </ng-container>\n  <div class=\"dbx-calendar-content dbx-calendar-content-month\">\n    <mwl-calendar-month-view [refresh]=\"refresh$\" [viewDate]=\"(viewDate$ | async)!\" [events]=\"(events$ | async)!\" (dayClicked)=\"dayClicked($event.day)\" (eventClicked)=\"eventClicked('Clicked', $event.event)\" (beforeViewRender)=\"beforeMonthViewRender($event)\" [cellTemplate]=\"monthDayCellTemplate\"></mwl-calendar-month-view>\n  </div>\n</dbx-calendar-base>\n\n<!-- Cell -->\n<ng-template #monthDayCellTemplate let-day=\"day\" let-locale=\"locale\">\n  <div class=\"cal-cell-top\">\n    <span class=\"cal-day-badge\" *ngIf=\"day.badgeTotal > 0\">{{ day.badgeTotal }}</span>\n    <span class=\"cal-day-number\">{{ day.date | calendarDate: 'monthViewDayNumber':locale }}</span>\n  </div>\n  <dbx-schedule-selection-calendar-cell [day]=\"day\"></dbx-schedule-selection-calendar-cell>\n</ng-template>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.DbxCalendarStore }, { type: DbxCalendarScheduleSelectionStore }]; }, propDecorators: { clickEvent: [{
+                type: Output
+            }] } });
+
+class DbxScheduleSelectionCalendarDateDialogComponent extends AbstractDialogDirective {
+    static openDialog(matDialog, { injector }) {
+        return matDialog.open(DbxScheduleSelectionCalendarDateDialogComponent, {
+            injector,
+            width: '80vw',
+            minWidth: 460
+        });
+    }
+}
+DbxScheduleSelectionCalendarDateDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDialogComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDateDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDateDialogComponent, selector: "ng-component", usesInheritance: true, ngImport: i0, template: `
+    <dbx-dialog-content>
+      <dbx-dialog-content-close (close)="close()"></dbx-dialog-content-close>
+      <dbx-schedule-selection-calendar></dbx-schedule-selection-calendar>
+      <dbx-dialog-content-footer closeText="Close Calendar" (close)="close()"></dbx-dialog-content-footer>
+    </dbx-dialog-content>
+  `, isInline: true, dependencies: [{ kind: "directive", type: i1$1.DbxDialogContentDirective, selector: "dbx-dialog-content,[dbxDialogContent].dbx-dialog-content", inputs: ["width"] }, { kind: "component", type: i1$1.DbxDialogContentFooterComponent, selector: "dbx-dialog-content-footer", inputs: ["closeText"], outputs: ["close"] }, { kind: "component", type: i1$1.DbxDialogContentCloseComponent, selector: "dbx-dialog-content-close", outputs: ["close"] }, { kind: "component", type: DbxScheduleSelectionCalendarComponent, selector: "dbx-schedule-selection-calendar", outputs: ["clickEvent"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDialogComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <dbx-dialog-content>
+      <dbx-dialog-content-close (close)="close()"></dbx-dialog-content-close>
+      <dbx-schedule-selection-calendar></dbx-schedule-selection-calendar>
+      <dbx-dialog-content-footer closeText="Close Calendar" (close)="close()"></dbx-dialog-content-footer>
+    </dbx-dialog-content>
+  `
+                }]
+        }] });
+
+class DbxScheduleSelectionCalendarDateDialogButtonComponent {
+    constructor(matDialog, injector) {
+        this.matDialog = matDialog;
+        this.injector = injector;
+        this.buttonText = 'Customize';
+    }
+    clickCustomize() {
+        DbxScheduleSelectionCalendarDateDialogComponent.openDialog(this.matDialog, { injector: this.injector });
+    }
+}
+DbxScheduleSelectionCalendarDateDialogButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDialogButtonComponent, deps: [{ token: i1$2.MatDialog }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+DbxScheduleSelectionCalendarDateDialogButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxScheduleSelectionCalendarDateDialogButtonComponent, selector: "dbx-schedule-selection-calendar-date-dialog-button", inputs: { buttonText: "buttonText" }, ngImport: i0, template: `
+    <button mat-raised-button color="accent" (click)="clickCustomize()">{{ buttonText }}</button>
+  `, isInline: true, dependencies: [{ kind: "component", type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxScheduleSelectionCalendarDateDialogButtonComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dbx-schedule-selection-calendar-date-dialog-button',
+                    template: `
+    <button mat-raised-button color="accent" (click)="clickCustomize()">{{ buttonText }}</button>
+  `
+                }]
+        }], ctorParameters: function () { return [{ type: i1$2.MatDialog }, { type: i0.Injector }]; }, propDecorators: { buttonText: [{
+                type: Input
+            }] } });
+
+class DbxFormCalendarDateScheduleRangeFieldComponent extends FieldType {
+    constructor(compact, dbxCalendarScheduleSelectionStore, ngZone) {
+        super();
+        this.compact = compact;
+        this.dbxCalendarScheduleSelectionStore = dbxCalendarScheduleSelectionStore;
+        this.ngZone = ngZone;
+        this._syncSub = new SubscriptionObject();
+        this._valueSub = new SubscriptionObject();
+        this._filterSub = new SubscriptionObject();
+        this._formControlObs = new BehaviorSubject(undefined);
+        this.formControl$ = this._formControlObs.pipe(filterMaybe());
+        this.value$ = this.formControl$.pipe(switchMap$1((control) => control.valueChanges.pipe(startWith(control.value))), shareReplay(1));
+    }
+    get formGroupName() {
+        return this.field.key;
+    }
+    get formGroup() {
+        return this.form;
+    }
+    get appearance() {
+        return this.props.appearance ?? 'standard';
+    }
+    get label() {
+        return this.field.props?.label;
+    }
+    get description() {
+        return this.props.description;
+    }
+    get isReadonlyOrDisabled() {
+        return this.props.readonly || this.disabled;
+    }
+    get showCustomize() {
+        return !this.props.hideCustomize;
+    }
+    get filter() {
+        return this.props.filter;
+    }
+    ngOnInit() {
+        this._formControlObs.next(this.formControl);
+        this._syncSub.subscription = this.value$.pipe(distinctUntilChanged(isSameDateScheduleRange)).subscribe((x) => {
+            this.dbxCalendarScheduleSelectionStore.setDateScheduleRangeValue(x);
+        });
+        this._valueSub.subscription = this.dbxCalendarScheduleSelectionStore.currentDateScheduleRangeValue$.subscribe((x) => {
+            this.formControl.setValue(x);
+        });
+        const filter = this.filter;
+        if (filter != null) {
+            this._filterSub.subscription = this.dbxCalendarScheduleSelectionStore.setFilter(asObservable(filter));
+        }
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._syncSub.destroy();
+        this._valueSub.destroy();
+        this._formControlObs.complete();
+        this._filterSub.destroy();
+    }
+}
+DbxFormCalendarDateScheduleRangeFieldComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormCalendarDateScheduleRangeFieldComponent, deps: [{ token: i1$1.CompactContextStore, optional: true }, { token: DbxCalendarScheduleSelectionStore }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+DbxFormCalendarDateScheduleRangeFieldComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: DbxFormCalendarDateScheduleRangeFieldComponent, selector: "ng-component", providers: [provideCalendarScheduleSelectionStoreIfParentIsUnavailable()], usesInheritance: true, ngImport: i0, template: `
+    <div class="dbx-schedule-selection-field">
+      <dbx-schedule-selection-calendar-date-range [showCustomize]="showCustomize" [appearance]="appearance" [required]="required" [disabled]="isReadonlyOrDisabled" [label]="label" [hint]="description">
+        <dbx-schedule-selection-calendar-date-dialog-button customizeButton></dbx-schedule-selection-calendar-date-dialog-button>
+      </dbx-schedule-selection-calendar-date-range>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "component", type: DbxScheduleSelectionCalendarDateRangeComponent, selector: "dbx-schedule-selection-calendar-date-range", inputs: ["required", "appearance", "label", "hint", "disabled", "showCustomize"] }, { kind: "component", type: DbxScheduleSelectionCalendarDateDialogButtonComponent, selector: "dbx-schedule-selection-calendar-date-dialog-button", inputs: ["buttonText"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormCalendarDateScheduleRangeFieldComponent, decorators: [{
+            type: Component,
+            args: [{
+                    template: `
+    <div class="dbx-schedule-selection-field">
+      <dbx-schedule-selection-calendar-date-range [showCustomize]="showCustomize" [appearance]="appearance" [required]="required" [disabled]="isReadonlyOrDisabled" [label]="label" [hint]="description">
+        <dbx-schedule-selection-calendar-date-dialog-button customizeButton></dbx-schedule-selection-calendar-date-dialog-button>
+      </dbx-schedule-selection-calendar-date-range>
+    </div>
+  `,
+                    providers: [provideCalendarScheduleSelectionStoreIfParentIsUnavailable()]
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.CompactContextStore, decorators: [{
+                    type: Optional
+                }] }, { type: DbxCalendarScheduleSelectionStore }, { type: i0.NgZone }]; } });
+
+const declarations = [
+    //
+    DbxScheduleSelectionCalendarComponent,
+    DbxScheduleSelectionCalendarDateDaysComponent,
+    DbxScheduleSelectionCalendarDateDaysFormComponent,
+    DbxScheduleSelectionCalendarDateRangeComponent,
+    DbxScheduleSelectionCalendarDatePopoverButtonComponent,
+    DbxScheduleSelectionCalendarCellComponent,
+    DbxScheduleSelectionCalendarDatePopoverComponent,
+    DbxScheduleSelectionCalendarDatePopoverContentComponent,
+    DbxCalendarScheduleSelectionStoreInjectionBlockDirective,
+    DbxScheduleSelectionCalendarDateDialogComponent,
+    DbxScheduleSelectionCalendarDateDialogButtonComponent
+];
+class DbxFormCalendarModule {
+}
+DbxFormCalendarModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormCalendarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbxFormCalendarModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: DbxFormCalendarModule, declarations: [
+        //
+        DbxScheduleSelectionCalendarComponent,
+        DbxScheduleSelectionCalendarDateDaysComponent,
+        DbxScheduleSelectionCalendarDateDaysFormComponent,
+        DbxScheduleSelectionCalendarDateRangeComponent,
+        DbxScheduleSelectionCalendarDatePopoverButtonComponent,
+        DbxScheduleSelectionCalendarCellComponent,
+        DbxScheduleSelectionCalendarDatePopoverComponent,
+        DbxScheduleSelectionCalendarDatePopoverContentComponent,
+        DbxCalendarScheduleSelectionStoreInjectionBlockDirective,
+        DbxScheduleSelectionCalendarDateDialogComponent,
+        DbxScheduleSelectionCalendarDateDialogButtonComponent], imports: [
+        //
+        DbxActionModule,
+        DbxFormModule,
+        DbxFormlyModule,
+        DbxCalendarModule,
+        CommonModule,
+        MatIconModule,
+        MatButtonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatFormFieldModule,
+        MatButtonToggleModule,
+        DbxButtonModule,
+        MatDatepickerModule,
+        DbxDialogInteractionModule,
+        DbxPopoverInteractionModule,
+        CalendarModule,
+        CalendarDayModule,
+        FlexLayoutModule,
+        CalendarWeekModule], exports: [
+        //
+        DbxScheduleSelectionCalendarComponent,
+        DbxScheduleSelectionCalendarDateDaysComponent,
+        DbxScheduleSelectionCalendarDateDaysFormComponent,
+        DbxScheduleSelectionCalendarDateRangeComponent,
+        DbxScheduleSelectionCalendarDatePopoverButtonComponent,
+        DbxScheduleSelectionCalendarCellComponent,
+        DbxScheduleSelectionCalendarDatePopoverComponent,
+        DbxScheduleSelectionCalendarDatePopoverContentComponent,
+        DbxCalendarScheduleSelectionStoreInjectionBlockDirective,
+        DbxScheduleSelectionCalendarDateDialogComponent,
+        DbxScheduleSelectionCalendarDateDialogButtonComponent] });
+DbxFormCalendarModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormCalendarModule, imports: [
+        //
+        DbxActionModule,
+        DbxFormModule,
+        DbxFormlyModule,
+        DbxCalendarModule,
+        CommonModule,
+        MatIconModule,
+        MatButtonModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatFormFieldModule,
+        MatButtonToggleModule,
+        DbxButtonModule,
+        MatDatepickerModule,
+        DbxDialogInteractionModule,
+        DbxPopoverInteractionModule,
+        CalendarModule,
+        CalendarDayModule,
+        FlexLayoutModule,
+        CalendarWeekModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormCalendarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        //
+                        DbxActionModule,
+                        DbxFormModule,
+                        DbxFormlyModule,
+                        DbxCalendarModule,
+                        CommonModule,
+                        MatIconModule,
+                        MatButtonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatFormFieldModule,
+                        MatButtonToggleModule,
+                        DbxButtonModule,
+                        MatDatepickerModule,
+                        DbxDialogInteractionModule,
+                        DbxPopoverInteractionModule,
+                        CalendarModule,
+                        CalendarDayModule,
+                        FlexLayoutModule,
+                        CalendarWeekModule
+                    ],
+                    declarations,
+                    exports: declarations
+                }]
+        }] });
+
+class DbxFormDateScheduleRangeFieldModule {
+}
+DbxFormDateScheduleRangeFieldModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormDateScheduleRangeFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+DbxFormDateScheduleRangeFieldModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: DbxFormDateScheduleRangeFieldModule, declarations: [DbxFormCalendarDateScheduleRangeFieldComponent], imports: [CommonModule,
+        MatIconModule,
+        DbxFormCalendarModule,
+        MatButtonModule,
+        DbxTextModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatInputModule, i1$3.FormlyModule] });
+DbxFormDateScheduleRangeFieldModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormDateScheduleRangeFieldModule, imports: [CommonModule,
+        MatIconModule,
+        DbxFormCalendarModule,
+        MatButtonModule,
+        DbxTextModule,
+        FormsModule,
+        ReactiveFormsModule,
+        MatInputModule,
+        FormlyModule.forChild({
+            types: [{ name: 'date-schedule-range', component: DbxFormCalendarDateScheduleRangeFieldComponent }]
+        })] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: DbxFormDateScheduleRangeFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MatIconModule,
+                        DbxFormCalendarModule,
+                        MatButtonModule,
+                        DbxTextModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        MatInputModule,
+                        FormlyModule.forChild({
+                            types: [{ name: 'date-schedule-range', component: DbxFormCalendarDateScheduleRangeFieldComponent }]
+                        })
+                    ],
+                    declarations: [DbxFormCalendarDateScheduleRangeFieldComponent]
+                }]
+        }] });
+
+// export * from './selection';
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CalendarScheduleSelectionDayState, DEFAULT_SCHEDULE_SELECTION_CALENDAR_DATE_POPOVER_KEY, DbxCalendarScheduleSelectionStore, DbxCalendarScheduleSelectionStoreInjectionBlockDirective, DbxCalendarScheduleSelectionStoreProviderBlock, DbxFormCalendarDateScheduleRangeFieldComponent, DbxFormCalendarModule, DbxFormDateScheduleRangeFieldModule, DbxScheduleSelectionCalendarCellComponent, DbxScheduleSelectionCalendarComponent, DbxScheduleSelectionCalendarDateDaysComponent, DbxScheduleSelectionCalendarDateDaysFormComponent, DbxScheduleSelectionCalendarDateDialogButtonComponent, DbxScheduleSelectionCalendarDateDialogComponent, DbxScheduleSelectionCalendarDatePopoverButtonComponent, DbxScheduleSelectionCalendarDatePopoverComponent, DbxScheduleSelectionCalendarDatePopoverContentComponent, DbxScheduleSelectionCalendarDateRangeComponent, computeCalendarScheduleSelectionDateBlockRange, computeCalendarScheduleSelectionRange, computeScheduleSelectionRangeAndExclusion, computeScheduleSelectionValue, dateScheduleRangeField, dbxScheduleSelectionCalendarDateDaysFormDayFields, dbxScheduleSelectionCalendarDateDaysFormFields, defaultCalendarScheduleSelectionCellContentFactory, finalizeNewCalendarScheduleSelectionState, initialCalendarScheduleSelectionState, isEnabledDayInCalendarScheduleSelectionState, noSelectionCalendarScheduleSelectionState, provideCalendarScheduleSelectionStoreIfParentIsUnavailable, updateStateWithChangedDates, updateStateWithChangedRange, updateStateWithChangedScheduleDays, updateStateWithDateScheduleRangeValue, updateStateWithFilter };
+//# sourceMappingURL=dereekb-dbx-form-calendar.mjs.map