@bryntum/calendar-angular-thin 7.1.1

package/esm2015/lib/bryntum-day-resource-view.component.js

@@ -0,0 +1,1347 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Angular wrapper for Bryntum DayResourceView
+ */
+import { Component, EventEmitter, Output, Input } from '@angular/core';
+import WrapperHelper from './wrapper.helper';
+import { Widget } from '@bryntum/core-thin';
+import { DayResourceView } from '@bryntum/calendar-thin';
+import * as i0 from "@angular/core";
+export class BryntumDayResourceViewComponent {
+    constructor(element) {
+        this.bryntumConfig = {
+            adopt: undefined,
+            appendTo: undefined,
+            href: undefined,
+            angularComponent: this,
+            features: {},
+            listeners: {}
+        };
+        // Events emitters
+        /**
+         * This event fires whenever the [autoCreate gesture](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate) is detected
+         * and also when a [drag-create](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag) gesture is detected.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-beforeAutoCreate)
+         * @param {object} event Event object
+         * @param {Event} event.domEvent The DOM event which initiated the creation.
+         * @param {Date} event.date *DEPRECATED in favour of `startDate`.* The starting time of the event to be created. If this is in a `DayView`, this will be snapped according to the specification in [autoCreate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate)
+         * @param {Date} event.startDate The starting time of the event to be created. If this is in a `DayView`, this will be snapped according to the specification in [autoCreate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate)
+         * @param {Date} event.endDate The ending time of the event to be created.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource if the UI includes a resource.
+         * @param {CalendarView} event.view This view.
+         */
+        this.onBeforeAutoCreate = new EventEmitter();
+        /**
+         * Triggered before a view's orientating date changes.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-beforeChangeDate)
+         * @param {object} event Event object
+         * @param {Date} event.oldDate The current orientating date of this view.
+         * @param {Date} event.date The new date to which this view is to be orientated.
+         */
+        this.onBeforeChangeDate = new EventEmitter();
+        /**
+         * Fires before an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onBeforeDestroy = new EventEmitter();
+        /**
+         * Triggered before a widget is hidden. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being hidden.
+         */
+        this.onBeforeHide = new EventEmitter();
+        /**
+         * Triggered before a new [responsiveState](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveState) is applied.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget whose `responsiveState` is to be changed
+         * @param {string} event.state The new value for the widget's `responsiveState`
+         * @param {string} event.oldState The previous value for the widget's `responsiveState`
+         */
+        this.onBeforeResponsiveStateChange = new EventEmitter();
+        /**
+         * Fired before this container will load record values into its child fields. This is useful if you
+         * want to modify the UI before data is loaded (e.g. set some input field to be readonly)
+         * @param {object} event Event object
+         * @param {Core.widget.Container} event.source The container
+         * @param {Core.data.Model} event.record The record
+         */
+        this.onBeforeSetRecord = new EventEmitter();
+        /**
+         * Triggered before a widget is shown. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget,any} event.source The widget being shown
+         */
+        this.onBeforeShow = new EventEmitter();
+        /**
+         * Fired before state is applied to the source. Allows editing the state object or preventing the operation.
+         * @param {object} event Event object
+         * @param {any} event.state State object config
+         */
+        this.onBeforeStateApply = new EventEmitter();
+        /**
+         * Fired before state is saved by the StateProvider. Allows editing the state object or preventing the operation.
+         * @param {object} event Event object
+         * @param {any} event.state State object config
+         */
+        this.onBeforeStateSave = new EventEmitter();
+        /**
+         * Fires when any other event is fired from the object.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-catchAll)
+         * @param {object} event Event object
+         * @param {{[key: string]: any, type: string}} event.event The Object that contains event details
+         * @param {string} event.event.type The type of the event which is caught by the listener
+         */
+        this.onCatchAll = new EventEmitter();
+        /**
+         * Fired when a new set of events has been gathered for this view's date range.
+         * @param {object} event Event object
+         * @param {Map<any, any>} event.cellMap The map of date keys to [day cell](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellCollecter#typedef-DayCell) data blocks.
+         */
+        this.onCellMapPopulated = new EventEmitter();
+        /**
+         * Fires when a Panel is collapsed using the [collapsible](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-collapsible) setting.
+         * @param {object} event Event object
+         * @param {Core.widget.Panel} event.source This Panel.
+         */
+        this.onCollapse = new EventEmitter();
+        /**
+         * Fired after one day cell's events are collected in sorted order according to the
+         * [eventSorter](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-eventSorter)
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-dayCellPopulated)
+         * @param {object} event Event object
+         * @param {Scheduler.model.EventModel[]} event.events The events to be shown for the passed date
+         * @param {Date} event.The date the events are to be shown in.
+         */
+        this.onDayCellPopulated = new EventEmitter();
+        /**
+         * Fires when an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onDestroy = new EventEmitter();
+        /**
+         * Fires when a field is mutated and the state of the [hasChanges](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#property-hasChanges) property changes
+         * @param {object} event Event object
+         * @param {Core.widget.Container} event.source The container.
+         * @param {boolean} event.dirty The dirty state of the Container - `true` if there are any fields which have been changed since initial load.
+         */
+        this.onDirtyStateChange = new EventEmitter();
+        /**
+         * Triggered when a widget's [element](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-element) is available.
+         * @param {object} event Event object
+         * @param {HTMLElement} event.element The Widget's element.
+         */
+        this.onElementCreated = new EventEmitter();
+        /**
+         * Fired when an [autoCreate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate) gesture has created a new event
+         * and added it to the event store.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-eventAutoCreated)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source This Calendar view instance.
+         * @param {Scheduler.model.EventModel} event.eventRecord The new event record.
+         */
+        this.onEventAutoCreated = new EventEmitter();
+        /**
+         * Fires when a day spanning event is found, and the date to which its encapsulating event bar
+         * extends has been calculated.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-eventPropagate)
+         * @param {object} event Event object
+         * @param {Date} event.eventEndDate The end date for which to calculate the propagate end date.
+         * @param {Date} event.propagateEndDate The system-calculated end point of the event bar.
+         * @param {boolean} event.isAllDay `true` if the event is an all day event, or spans multiple days.
+         * @param {boolean} event.isOverflow `true` if this is being called as part of further propagation.
+         * @param {boolean} event.overflows `true` if the event extends into future cells.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event record being propagated.
+         * @param {Date} event.date The date from which the event is being propagated.
+         */
+        this.onEventPropagate = new EventEmitter();
+        /**
+         * Fires when a Panel is expanded using the [collapsible](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-collapsible) setting.
+         * @param {object} event Event object
+         * @param {Core.widget.Panel} event.source This Panel.
+         */
+        this.onExpand = new EventEmitter();
+        /**
+         * Fired when focus enters this Widget.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {HTMLElement} event.fromElement The element which lost focus.
+         * @param {HTMLElement} event.toElement The element which gained focus.
+         * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.
+         * @param {Core.widget.Widget} event.toWidget The widget which gained focus.
+         * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.
+         */
+        this.onFocusIn = new EventEmitter();
+        /**
+         * Fired when focus exits this Widget's ownership tree. This is different from a `blur` event.
+         * focus moving from within this Widget's ownership tree, even if there are floating widgets
+         * will not trigger this event. This is when focus exits this widget completely.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {HTMLElement} event.fromElement The element which lost focus.
+         * @param {HTMLElement} event.toElement The element which gained focus.
+         * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.
+         * @param {Core.widget.Widget} event.toWidget The widget which gained focus.
+         * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.
+         */
+        this.onFocusOut = new EventEmitter();
+        /**
+         * Triggered after a widget was hidden
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget
+         */
+        this.onHide = new EventEmitter();
+        /**
+         * Fires when this DayView changes an aspect of its layout. This happens when changing
+         * [hourHeight](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#property-hourHeight), [minDayWidth](#Calendar/widget/DayView#property-minDayWidth), and when the available
+         * day container height changes.
+         * @param {object} event Event object
+         * @param {Calendar.widget.DayView} event.source The triggering instance.
+         */
+        this.onLayoutUpdate = new EventEmitter();
+        /**
+         * Triggered when a widget which had been in a non-visible state for any reason
+         * achieves visibility.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-paint)
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being painted.
+         * @param {boolean} event.firstPaint `true` if this is the first paint.
+         */
+        this.onPaint = new EventEmitter();
+        /**
+         * Fired when the range of dates encapsulated by this view changes.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-rangeChange)
+         * @param {object} event Event object
+         * @param {typeof DateRangeOwner} event.source This calendar view instance.
+         * @param {object} event.old The old date range <strong>if any</strong>.
+         * @param {Date} event.old.startDate the old start date.
+         * @param {Date} event.old.endDate the old end date.
+         * @param {object} event.new The new date range
+         * @param {Date} event.new.startDate the new start date.
+         * @param {Date} event.new.endDate the new end date.
+         */
+        this.onRangeChange = new EventEmitter();
+        /**
+         * Fired when a Widget's read only state is toggled
+         * @param {object} event Event object
+         * @param {boolean} event.readOnly Read only or not
+         */
+        this.onReadOnly = new EventEmitter();
+        /**
+         * This event is fired after a widget's elements have been synchronized due to a direct or indirect call
+         * to [recompose](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.
+         */
+        this.onRecompose = new EventEmitter();
+        /**
+         * Fires when this DayView refreshes.
+         * @param {object} event Event object
+         * @param {Calendar.widget.DayView} event.source The triggering instance.
+         */
+        this.onRefresh = new EventEmitter();
+        /**
+         * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-monitorResize) is `true`*.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {number} event.width The new width
+         * @param {number} event.height The new height
+         * @param {number} event.oldWidth The old width
+         * @param {number} event.oldHeight The old height
+         */
+        this.onResize = new EventEmitter();
+        /**
+         * Triggered when a new [responsiveState](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveState) is applied.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget whose `responsiveState` has changed
+         * @param {string} event.state The new value for the widget's `responsiveState`
+         * @param {string} event.oldState The previous value for the widget's `responsiveState`
+         */
+        this.onResponsiveStateChange = new EventEmitter();
+        /**
+         * Fired when the [shiftIncrement](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#property-shiftIncrement) of this view changes.
+         * @param {object} event Event object
+         * @param {object} event.old The shift increment *if any*.
+         * @param {object} event.new The shift increment
+         */
+        this.onShiftIncrementChange = new EventEmitter();
+        /**
+         * Triggered after a widget is shown.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget
+         */
+        this.onShow = new EventEmitter();
+        /**
+         * Triggered when changing the [hourHeight](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#property-hourHeight) causes an
+         * [hour height breakpoint](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-hourHeightBreakpoints) to be crossed
+         * and the displayed subTick intervals in the time axis change.
+         * @param {object} event Event object
+         * @param {object} event.old The old hour height tick resolution object.
+         * @param {number} event.old.level The level `0` to `4` where `0` is the default with no subTick times displayed, and `4` means every 5 minute time is displayed.
+         * @param {string} event.old.step The time duration of visible subTicks. This is a string in the format required by [parseDuration](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper#function-parseDuration-static)
+         * @param {object} event.new The new hour height tick resolution object.
+         * @param {number} event.new.level The level `0` to `4` where `0` is the default with no subTick times displayed, and `4` means every 5 minute time is displayed.
+         * @param {string} event.new.step The time duration of visible subTicks. This is a string in the format required by [parseDuration](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper#function-parseDuration-static)
+         */
+        this.onTickChange = new EventEmitter();
+        /**
+         * Fired when a time axis is clicked on. If the handler returns
+         * `false` the current pointer event is not processed further.
+         * @param {object} event Event object
+         * @param {Event} event.domEvent The triggering DOM event.
+         * @param {Date} event.preciseTime The exact date and time at the clicked position
+         * @param {Date} event.time The date and time at the clicked position snapped according to the [increment](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-increment) and [timeSnapType](#Calendar/widget/DayView#config-timeSnapType)
+         */
+        this.onTimeAxisClick = new EventEmitter();
+        /**
+         * A header [tool](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-tools) has been clicked.
+         * @param {object} event Event object
+         * @param {Core.widget.Tool} event.source This Panel.
+         * @param {Core.widget.Tool} event.tool The tool which is being clicked.
+         */
+        this.onToolClick = new EventEmitter();
+        this.elementRef = element;
+    }
+    /**
+     * Create and append the underlying widget
+     */
+    ngOnInit() {
+        const me = this, { elementRef, bryntumConfig } = me, { instanceClass, instanceName, bryntumConfigs, bryntumEvents } = BryntumDayResourceViewComponent;
+        bryntumConfigs.filter(prop => prop in this).forEach(prop => {
+            // @ts-ignore
+            WrapperHelper.applyPropValue(bryntumConfig, prop, this[prop]);
+            if (['features', 'config'].includes(prop)) {
+                WrapperHelper.devWarningConfigProp(instanceName, prop);
+            }
+        });
+        // @ts-ignore
+        bryntumEvents.filter(event => this[event] && this[event].observers.length > 0).forEach(event => {
+            const uncapitalize = (str) => str.charAt(0).toLowerCase() + str.slice(1), eventName = (str) => uncapitalize(str.slice(2));
+            // @ts-ignore
+            bryntumConfig.listeners[eventName(event)] = e => {
+                // @ts-ignore
+                me[event].emit(e);
+                // EventEmitter does not return values in the normal way, work around it by setting `returnValue` flag
+                // in Angular listeners
+                return e.returnValue;
+            };
+        });
+        // If component has no container specified in config then use adopt to Wrapper's element
+        const containerParam = [
+            'adopt',
+            'appendTo',
+            'insertAfter',
+            'insertBefore'
+            // @ts-ignore
+        ].find(prop => bryntumConfig[prop]);
+        if (!containerParam) {
+            if (instanceName === 'Button' || elementRef.nativeElement.getRootNode() instanceof ShadowRoot) {
+                // Button should always be <a> or <button> inside owner element
+                bryntumConfig.appendTo = elementRef.nativeElement;
+            }
+            else {
+                bryntumConfig.adopt = elementRef.nativeElement;
+            }
+        }
+        else {
+            WrapperHelper.devWarningContainer(instanceName, containerParam);
+        }
+        // @ts-ignore
+        me.instance = instanceName === 'Widget' ? Widget.create(bryntumConfig) : new instanceClass(bryntumConfig);
+    }
+    /**
+     * Watch for changes
+     * @param changes
+     */
+    ngOnChanges(changes) {
+        const { instance } = this, { instanceName } = BryntumDayResourceViewComponent;
+        if (!instance) {
+            return;
+        }
+        // Iterate over all changes
+        Object.entries(changes).forEach(([prop, change]) => {
+            const newValue = change.currentValue, { instance } = this, { bryntumConfigsOnly, bryntumProps } = BryntumDayResourceViewComponent;
+            if (bryntumProps.includes(prop)) {
+                WrapperHelper.applyPropValue(instance, prop, newValue, false);
+                if (bryntumConfigsOnly.includes(prop)) {
+                    WrapperHelper.devWarningUpdateProp(instanceName, prop);
+                }
+            }
+        });
+    }
+    /**
+     * Destroy the component
+     */
+    ngOnDestroy() {
+        // @ts-ignore
+        if (this.instance && this.instance.destroy) {
+            this.instance.destroy();
+        }
+    }
+}
+BryntumDayResourceViewComponent.instanceClass = DayResourceView;
+BryntumDayResourceViewComponent.instanceName = 'DayResourceView';
+BryntumDayResourceViewComponent.bryntumEvents = [
+    'onBeforeAutoCreate',
+    'onBeforeChangeDate',
+    'onBeforeDestroy',
+    'onBeforeHide',
+    'onBeforeResponsiveStateChange',
+    'onBeforeSetRecord',
+    'onBeforeShow',
+    'onBeforeStateApply',
+    'onBeforeStateSave',
+    'onCatchAll',
+    'onCellMapPopulated',
+    'onCollapse',
+    'onDayCellPopulated',
+    'onDestroy',
+    'onDirtyStateChange',
+    'onElementCreated',
+    'onEventAutoCreated',
+    'onEventPropagate',
+    'onExpand',
+    'onFocusIn',
+    'onFocusOut',
+    'onHide',
+    'onLayoutUpdate',
+    'onPaint',
+    'onRangeChange',
+    'onReadOnly',
+    'onRecompose',
+    'onRefresh',
+    'onResize',
+    'onResponsiveStateChange',
+    'onShiftIncrementChange',
+    'onShow',
+    'onTickChange',
+    'onTimeAxisClick',
+    'onToolClick'
+];
+BryntumDayResourceViewComponent.bryntumFeatureNames = [];
+BryntumDayResourceViewComponent.bryntumConfigs = BryntumDayResourceViewComponent.bryntumFeatureNames.concat([
+    'actionButtons',
+    'activationKey',
+    'adopt',
+    'align',
+    'alignSelf',
+    'allDayEvents',
+    'allowDragCreate',
+    'allowDragMove',
+    'allowDragResize',
+    'allowZoomUnderflow',
+    'anchor',
+    'animateTimeShift',
+    'appendTo',
+    'ariaDescription',
+    'ariaLabel',
+    'autoCreate',
+    'bbar',
+    'bodyCls',
+    'bubbleEvents',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'centered',
+    'cls',
+    'collapsed',
+    'collapsible',
+    'color',
+    'column',
+    'columnHeaderRenderer',
+    'compactHeader',
+    'config',
+    'constrainTo',
+    'contentElementCls',
+    'coreHours',
+    'currentTimeIndicatorRenderer',
+    'dashedSubticks',
+    'dataField',
+    'dataset',
+    'date',
+    'dateFilter',
+    'dateFormat',
+    'dateSeparator',
+    'dayCellRenderer',
+    'dayEndTime',
+    'dayHeaderRenderer',
+    'dayNameFormat',
+    'dayStartShift',
+    'dayStartTime',
+    'defaultBindProperty',
+    'defaultFocus',
+    'defaults',
+    'defaultScrollOptions',
+    'descriptionFormat',
+    'descriptionRenderer',
+    'detectCSSCompatibilityIssues',
+    'disabled',
+    'dock',
+    'draggable',
+    'dragUnit',
+    'drawer',
+    'elementAttributes',
+    'endDate',
+    'eventFilter',
+    'eventHeaderRenderer',
+    'eventLayout',
+    'eventRenderer',
+    'eventSorter',
+    'eventSpacing',
+    'extendAllDayEndDay',
+    'extraData',
+    'filterEventResources',
+    'fitHours',
+    'fixedDuration',
+    'flex',
+    'floating',
+    'footer',
+    'getPrimaryResource',
+    'header',
+    'height',
+    'hidden',
+    'hideAnimation',
+    'hideEmptyDays',
+    'hideEmptyResources',
+    'hideNonWorkingDays',
+    'hideResourceNameWhenNarrow',
+    'hideWhenEmpty',
+    'hourHeight',
+    'hourHeightBreakpoints',
+    'icon',
+    'id',
+    'ignoreParentReadOnly',
+    'increment',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'interDayDrag',
+    'interDayResize',
+    'itemCls',
+    'items',
+    'keyMap',
+    'labelPosition',
+    'layout',
+    'layoutStyle',
+    'lazyItems',
+    'listeners',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'margin',
+    'maskDefaults',
+    'masked',
+    'maxAllDayHeight',
+    'maxDate',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minDate',
+    'minDayWidth',
+    'minEventHeight',
+    'minHeight',
+    'minHourHeight',
+    'minResourceWidth',
+    'minWidth',
+    'monitorResize',
+    'namedItems',
+    'noMatchingDates',
+    'nonWorkingDays',
+    'overflowPopup',
+    'owner',
+    'pastEventCls',
+    'positioned',
+    'preventTooltipOnTouch',
+    'range',
+    'readOnly',
+    'relayStoreEvents',
+    'rendition',
+    'resourceDateFilter',
+    'resourceImagePath',
+    'responsive',
+    'responsiveRoot',
+    'responsiveState',
+    'responsiveTarget',
+    'ripple',
+    'rootElement',
+    'rtl',
+    'scrollable',
+    'scrollAction',
+    'selectorButton',
+    'selectorMenuItem',
+    'shiftIncrement',
+    'shortDateFormat',
+    'shortDateTimeFormat',
+    'shortEventCls',
+    'shortEventDuration',
+    'showAllDayHeader',
+    'showAnimation',
+    'showAvatars',
+    'showBullet',
+    'showCurrentTime',
+    'showHeaderAvatars',
+    'showResourceAvatars',
+    'showTime',
+    'showTooltipWhenDisabled',
+    'sixMinuteTicks',
+    'snapRelativeToEventStartDate',
+    'span',
+    'stackMultiDayEvents',
+    'startDate',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'strictRecordMapping',
+    'strips',
+    'syncCalendarDate',
+    'syncViewDate',
+    'tab',
+    'tabBarItems',
+    'tag',
+    'tbar',
+    'textAlign',
+    'tickRenderer',
+    'timeAxisTimeFormat',
+    'timeFormat',
+    'timeSnapType',
+    'title',
+    'tools',
+    'tooltip',
+    'trapFocus',
+    'type',
+    'ui',
+    'visibleStartTime',
+    'weekStartDay',
+    'weight',
+    'width',
+    'x',
+    'y',
+    'zoomOnMouseWheel'
+]);
+BryntumDayResourceViewComponent.bryntumConfigsOnly = [
+    'actionButtons',
+    'activationKey',
+    'adopt',
+    'align',
+    'allDayEvents',
+    'anchor',
+    'ariaDescription',
+    'ariaLabel',
+    'bbar',
+    'bodyCls',
+    'bubbleEvents',
+    'centered',
+    'collapsible',
+    'color',
+    'columnHeaderRenderer',
+    'config',
+    'constrainTo',
+    'contentElementCls',
+    'currentTimeIndicatorRenderer',
+    'dataField',
+    'dayCellRenderer',
+    'dayHeaderRenderer',
+    'dayNameFormat',
+    'dayStartShift',
+    'defaultBindProperty',
+    'defaultFocus',
+    'defaults',
+    'descriptionRenderer',
+    'detectCSSCompatibilityIssues',
+    'dock',
+    'draggable',
+    'drawer',
+    'elementAttributes',
+    'endDate',
+    'eventFilter',
+    'eventHeaderRenderer',
+    'eventLayout',
+    'eventRenderer',
+    'eventSorter',
+    'eventSpacing',
+    'floating',
+    'footer',
+    'getPrimaryResource',
+    'header',
+    'hideAnimation',
+    'hideWhenEmpty',
+    'icon',
+    'ignoreParentReadOnly',
+    'itemCls',
+    'lazyItems',
+    'listeners',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'maskDefaults',
+    'masked',
+    'maxAllDayHeight',
+    'monitorResize',
+    'namedItems',
+    'overflowPopup',
+    'owner',
+    'positioned',
+    'preventTooltipOnTouch',
+    'relayStoreEvents',
+    'resourceImagePath',
+    'responsive',
+    'responsiveRoot',
+    'responsiveState',
+    'responsiveTarget',
+    'ripple',
+    'rootElement',
+    'scrollAction',
+    'selectorButton',
+    'selectorMenuItem',
+    'shortEventCls',
+    'shortEventDuration',
+    'showAllDayHeader',
+    'showAnimation',
+    'showBullet',
+    'showHeaderAvatars',
+    'showResourceAvatars',
+    'showTooltipWhenDisabled',
+    'startDate',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'strips',
+    'tab',
+    'tabBarItems',
+    'tag',
+    'tbar',
+    'textAlign',
+    'tickRenderer',
+    'timeAxisTimeFormat',
+    'timeFormat',
+    'trapFocus',
+    'type',
+    'ui',
+    'visibleStartTime',
+    'weekStartDay',
+    'weight',
+    'zoomOnMouseWheel'
+];
+BryntumDayResourceViewComponent.bryntumProps = BryntumDayResourceViewComponent.bryntumFeatureNames.concat([
+    'alignSelf',
+    'allowDragCreate',
+    'allowDragMove',
+    'allowDragResize',
+    'allowZoomUnderflow',
+    'anchorSize',
+    'animateTimeShift',
+    'appendTo',
+    'autoCreate',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'cls',
+    'collapsed',
+    'column',
+    'compactHeader',
+    'coreHours',
+    'dashedSubticks',
+    'dataset',
+    'date',
+    'dateFilter',
+    'dateFormat',
+    'dateSeparator',
+    'dayCellCls',
+    'dayEndTime',
+    'dayStartTime',
+    'defaultScrollOptions',
+    'descriptionFormat',
+    'disabled',
+    'dragUnit',
+    'extendAllDayEndDay',
+    'extraData',
+    'filterEventResources',
+    'firstVisibleCell',
+    'firstVisibleDate',
+    'fitHours',
+    'fixedDuration',
+    'flex',
+    'focusVisible',
+    'hasChanges',
+    'height',
+    'hidden',
+    'hideEmptyDays',
+    'hideEmptyResources',
+    'hideNonWorkingDays',
+    'hideResourceNameWhenNarrow',
+    'horizontalScroller',
+    'hourHeight',
+    'hourHeightBreakpoints',
+    'id',
+    'increment',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'interDayDrag',
+    'interDayResize',
+    'isSettingValues',
+    'isValid',
+    'items',
+    'keyMap',
+    'labelPosition',
+    'lastVisibleCell',
+    'lastVisibleDate',
+    'layout',
+    'layoutStyle',
+    'margin',
+    'maxDate',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minDate',
+    'minDayWidth',
+    'minEventHeight',
+    'minHeight',
+    'minHourHeight',
+    'minResourceWidth',
+    'minWidth',
+    'noMatchingDates',
+    'nonWorkingDays',
+    'parent',
+    'pastEventCls',
+    'range',
+    'readOnly',
+    'record',
+    'rendition',
+    'resourceDateFilter',
+    'rtl',
+    'scrollable',
+    'shiftIncrement',
+    'shortDateFormat',
+    'shortDateTimeFormat',
+    'showAvatars',
+    'showCurrentTime',
+    'showTime',
+    'sixMinuteTicks',
+    'snapRelativeToEventStartDate',
+    'span',
+    'stackMultiDayEvents',
+    'state',
+    'strictRecordMapping',
+    'syncCalendarDate',
+    'syncViewDate',
+    'timeSnapType',
+    'title',
+    'tools',
+    'tooltip',
+    'values',
+    'width',
+    'x',
+    'y'
+]);
+BryntumDayResourceViewComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumDayResourceViewComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+BryntumDayResourceViewComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.0", type: BryntumDayResourceViewComponent, selector: "bryntum-day-resource-view", inputs: { actionButtons: "actionButtons", activationKey: "activationKey", adopt: "adopt", align: "align", allDayEvents: "allDayEvents", anchor: "anchor", ariaDescription: "ariaDescription", ariaLabel: "ariaLabel", bbar: "bbar", bodyCls: "bodyCls", bubbleEvents: "bubbleEvents", centered: "centered", collapsible: "collapsible", color: "color", columnHeaderRenderer: "columnHeaderRenderer", config: "config", constrainTo: "constrainTo", contentElementCls: "contentElementCls", currentTimeIndicatorRenderer: "currentTimeIndicatorRenderer", dataField: "dataField", dayCellRenderer: "dayCellRenderer", dayHeaderRenderer: "dayHeaderRenderer", dayNameFormat: "dayNameFormat", dayStartShift: "dayStartShift", defaultBindProperty: "defaultBindProperty", defaultFocus: "defaultFocus", defaults: "defaults", descriptionRenderer: "descriptionRenderer", detectCSSCompatibilityIssues: "detectCSSCompatibilityIssues", dock: "dock", draggable: "draggable", drawer: "drawer", elementAttributes: "elementAttributes", endDate: "endDate", eventFilter: "eventFilter", eventHeaderRenderer: "eventHeaderRenderer", eventLayout: "eventLayout", eventRenderer: "eventRenderer", eventSorter: "eventSorter", eventSpacing: "eventSpacing", floating: "floating", footer: "footer", getPrimaryResource: "getPrimaryResource", header: "header", hideAnimation: "hideAnimation", hideWhenEmpty: "hideWhenEmpty", icon: "icon", ignoreParentReadOnly: "ignoreParentReadOnly", itemCls: "itemCls", lazyItems: "lazyItems", listeners: "listeners", localeClass: "localeClass", localizable: "localizable", localizableProperties: "localizableProperties", maskDefaults: "maskDefaults", masked: "masked", maxAllDayHeight: "maxAllDayHeight", monitorResize: "monitorResize", namedItems: "namedItems", overflowPopup: "overflowPopup", owner: "owner", positioned: "positioned", preventTooltipOnTouch: "preventTooltipOnTouch", relayStoreEvents: "relayStoreEvents", resourceImagePath: "resourceImagePath", responsive: "responsive", responsiveRoot: "responsiveRoot", responsiveState: "responsiveState", responsiveTarget: "responsiveTarget", ripple: "ripple", rootElement: "rootElement", scrollAction: "scrollAction", selectorButton: "selectorButton", selectorMenuItem: "selectorMenuItem", shortEventCls: "shortEventCls", shortEventDuration: "shortEventDuration", showAllDayHeader: "showAllDayHeader", showAnimation: "showAnimation", showBullet: "showBullet", showHeaderAvatars: "showHeaderAvatars", showResourceAvatars: "showResourceAvatars", showTooltipWhenDisabled: "showTooltipWhenDisabled", startDate: "startDate", stateful: "stateful", statefulEvents: "statefulEvents", stateId: "stateId", stateProvider: "stateProvider", strips: "strips", tab: "tab", tabBarItems: "tabBarItems", tag: "tag", tbar: "tbar", textAlign: "textAlign", tickRenderer: "tickRenderer", timeAxisTimeFormat: "timeAxisTimeFormat", timeFormat: "timeFormat", trapFocus: "trapFocus", type: "type", ui: "ui", visibleStartTime: "visibleStartTime", weekStartDay: "weekStartDay", weight: "weight", zoomOnMouseWheel: "zoomOnMouseWheel", alignSelf: "alignSelf", allowDragCreate: "allowDragCreate", allowDragMove: "allowDragMove", allowDragResize: "allowDragResize", allowZoomUnderflow: "allowZoomUnderflow", animateTimeShift: "animateTimeShift", appendTo: "appendTo", autoCreate: "autoCreate", callOnFunctions: "callOnFunctions", catchEventHandlerExceptions: "catchEventHandlerExceptions", cls: "cls", collapsed: "collapsed", column: "column", compactHeader: "compactHeader", coreHours: "coreHours", dashedSubticks: "dashedSubticks", dataset: "dataset", date: "date", dateFilter: "dateFilter", dateFormat: "dateFormat", dateSeparator: "dateSeparator", dayEndTime: "dayEndTime", dayStartTime: "dayStartTime", defaultScrollOptions: "defaultScrollOptions", descriptionFormat: "descriptionFormat", disabled: "disabled", dragUnit: "dragUnit", extendAllDayEndDay: "extendAllDayEndDay", extraData: "extraData", filterEventResources: "filterEventResources", fitHours: "fitHours", fixedDuration: "fixedDuration", flex: "flex", height: "height", hidden: "hidden", hideEmptyDays: "hideEmptyDays", hideEmptyResources: "hideEmptyResources", hideNonWorkingDays: "hideNonWorkingDays", hideResourceNameWhenNarrow: "hideResourceNameWhenNarrow", hourHeight: "hourHeight", hourHeightBreakpoints: "hourHeightBreakpoints", id: "id", increment: "increment", inputFieldAlign: "inputFieldAlign", insertBefore: "insertBefore", insertFirst: "insertFirst", interDayDrag: "interDayDrag", interDayResize: "interDayResize", items: "items", keyMap: "keyMap", labelPosition: "labelPosition", layout: "layout", layoutStyle: "layoutStyle", margin: "margin", maxDate: "maxDate", maxHeight: "maxHeight", maximizeOnMobile: "maximizeOnMobile", maxWidth: "maxWidth", minDate: "minDate", minDayWidth: "minDayWidth", minEventHeight: "minEventHeight", minHeight: "minHeight", minHourHeight: "minHourHeight", minResourceWidth: "minResourceWidth", minWidth: "minWidth", noMatchingDates: "noMatchingDates", nonWorkingDays: "nonWorkingDays", pastEventCls: "pastEventCls", range: "range", readOnly: "readOnly", rendition: "rendition", resourceDateFilter: "resourceDateFilter", rtl: "rtl", scrollable: "scrollable", shiftIncrement: "shiftIncrement", shortDateFormat: "shortDateFormat", shortDateTimeFormat: "shortDateTimeFormat", showAvatars: "showAvatars", showCurrentTime: "showCurrentTime", showTime: "showTime", sixMinuteTicks: "sixMinuteTicks", snapRelativeToEventStartDate: "snapRelativeToEventStartDate", span: "span", stackMultiDayEvents: "stackMultiDayEvents", strictRecordMapping: "strictRecordMapping", syncCalendarDate: "syncCalendarDate", syncViewDate: "syncViewDate", timeSnapType: "timeSnapType", title: "title", tools: "tools", tooltip: "tooltip", width: "width", x: "x", y: "y", anchorSize: "anchorSize", dayCellCls: "dayCellCls", firstVisibleCell: "firstVisibleCell", firstVisibleDate: "firstVisibleDate", focusVisible: "focusVisible", hasChanges: "hasChanges", horizontalScroller: "horizontalScroller", isSettingValues: "isSettingValues", isValid: "isValid", lastVisibleCell: "lastVisibleCell", lastVisibleDate: "lastVisibleDate", parent: "parent", record: "record", state: "state", values: "values" }, outputs: { onBeforeAutoCreate: "onBeforeAutoCreate", onBeforeChangeDate: "onBeforeChangeDate", onBeforeDestroy: "onBeforeDestroy", onBeforeHide: "onBeforeHide", onBeforeResponsiveStateChange: "onBeforeResponsiveStateChange", onBeforeSetRecord: "onBeforeSetRecord", onBeforeShow: "onBeforeShow", onBeforeStateApply: "onBeforeStateApply", onBeforeStateSave: "onBeforeStateSave", onCatchAll: "onCatchAll", onCellMapPopulated: "onCellMapPopulated", onCollapse: "onCollapse", onDayCellPopulated: "onDayCellPopulated", onDestroy: "onDestroy", onDirtyStateChange: "onDirtyStateChange", onElementCreated: "onElementCreated", onEventAutoCreated: "onEventAutoCreated", onEventPropagate: "onEventPropagate", onExpand: "onExpand", onFocusIn: "onFocusIn", onFocusOut: "onFocusOut", onHide: "onHide", onLayoutUpdate: "onLayoutUpdate", onPaint: "onPaint", onRangeChange: "onRangeChange", onReadOnly: "onReadOnly", onRecompose: "onRecompose", onRefresh: "onRefresh", onResize: "onResize", onResponsiveStateChange: "onResponsiveStateChange", onShiftIncrementChange: "onShiftIncrementChange", onShow: "onShow", onTickChange: "onTickChange", onTimeAxisClick: "onTimeAxisClick", onToolClick: "onToolClick" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumDayResourceViewComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bryntum-day-resource-view',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { actionButtons: [{
+                type: Input
+            }], activationKey: [{
+                type: Input
+            }], adopt: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], allDayEvents: [{
+                type: Input
+            }], anchor: [{
+                type: Input
+            }], ariaDescription: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], bbar: [{
+                type: Input
+            }], bodyCls: [{
+                type: Input
+            }], bubbleEvents: [{
+                type: Input
+            }], centered: [{
+                type: Input
+            }], collapsible: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], columnHeaderRenderer: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], constrainTo: [{
+                type: Input
+            }], contentElementCls: [{
+                type: Input
+            }], currentTimeIndicatorRenderer: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], dayCellRenderer: [{
+                type: Input
+            }], dayHeaderRenderer: [{
+                type: Input
+            }], dayNameFormat: [{
+                type: Input
+            }], dayStartShift: [{
+                type: Input
+            }], defaultBindProperty: [{
+                type: Input
+            }], defaultFocus: [{
+                type: Input
+            }], defaults: [{
+                type: Input
+            }], descriptionRenderer: [{
+                type: Input
+            }], detectCSSCompatibilityIssues: [{
+                type: Input
+            }], dock: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], drawer: [{
+                type: Input
+            }], elementAttributes: [{
+                type: Input
+            }], endDate: [{
+                type: Input
+            }], eventFilter: [{
+                type: Input
+            }], eventHeaderRenderer: [{
+                type: Input
+            }], eventLayout: [{
+                type: Input
+            }], eventRenderer: [{
+                type: Input
+            }], eventSorter: [{
+                type: Input
+            }], eventSpacing: [{
+                type: Input
+            }], floating: [{
+                type: Input
+            }], footer: [{
+                type: Input
+            }], getPrimaryResource: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], hideAnimation: [{
+                type: Input
+            }], hideWhenEmpty: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], ignoreParentReadOnly: [{
+                type: Input
+            }], itemCls: [{
+                type: Input
+            }], lazyItems: [{
+                type: Input
+            }], listeners: [{
+                type: Input
+            }], localeClass: [{
+                type: Input
+            }], localizable: [{
+                type: Input
+            }], localizableProperties: [{
+                type: Input
+            }], maskDefaults: [{
+                type: Input
+            }], masked: [{
+                type: Input
+            }], maxAllDayHeight: [{
+                type: Input
+            }], monitorResize: [{
+                type: Input
+            }], namedItems: [{
+                type: Input
+            }], overflowPopup: [{
+                type: Input
+            }], owner: [{
+                type: Input
+            }], positioned: [{
+                type: Input
+            }], preventTooltipOnTouch: [{
+                type: Input
+            }], relayStoreEvents: [{
+                type: Input
+            }], resourceImagePath: [{
+                type: Input
+            }], responsive: [{
+                type: Input
+            }], responsiveRoot: [{
+                type: Input
+            }], responsiveState: [{
+                type: Input
+            }], responsiveTarget: [{
+                type: Input
+            }], ripple: [{
+                type: Input
+            }], rootElement: [{
+                type: Input
+            }], scrollAction: [{
+                type: Input
+            }], selectorButton: [{
+                type: Input
+            }], selectorMenuItem: [{
+                type: Input
+            }], shortEventCls: [{
+                type: Input
+            }], shortEventDuration: [{
+                type: Input
+            }], showAllDayHeader: [{
+                type: Input
+            }], showAnimation: [{
+                type: Input
+            }], showBullet: [{
+                type: Input
+            }], showHeaderAvatars: [{
+                type: Input
+            }], showResourceAvatars: [{
+                type: Input
+            }], showTooltipWhenDisabled: [{
+                type: Input
+            }], startDate: [{
+                type: Input
+            }], stateful: [{
+                type: Input
+            }], statefulEvents: [{
+                type: Input
+            }], stateId: [{
+                type: Input
+            }], stateProvider: [{
+                type: Input
+            }], strips: [{
+                type: Input
+            }], tab: [{
+                type: Input
+            }], tabBarItems: [{
+                type: Input
+            }], tag: [{
+                type: Input
+            }], tbar: [{
+                type: Input
+            }], textAlign: [{
+                type: Input
+            }], tickRenderer: [{
+                type: Input
+            }], timeAxisTimeFormat: [{
+                type: Input
+            }], timeFormat: [{
+                type: Input
+            }], trapFocus: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], ui: [{
+                type: Input
+            }], visibleStartTime: [{
+                type: Input
+            }], weekStartDay: [{
+                type: Input
+            }], weight: [{
+                type: Input
+            }], zoomOnMouseWheel: [{
+                type: Input
+            }], alignSelf: [{
+                type: Input
+            }], allowDragCreate: [{
+                type: Input
+            }], allowDragMove: [{
+                type: Input
+            }], allowDragResize: [{
+                type: Input
+            }], allowZoomUnderflow: [{
+                type: Input
+            }], animateTimeShift: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], autoCreate: [{
+                type: Input
+            }], callOnFunctions: [{
+                type: Input
+            }], catchEventHandlerExceptions: [{
+                type: Input
+            }], cls: [{
+                type: Input
+            }], collapsed: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], compactHeader: [{
+                type: Input
+            }], coreHours: [{
+                type: Input
+            }], dashedSubticks: [{
+                type: Input
+            }], dataset: [{
+                type: Input
+            }], date: [{
+                type: Input
+            }], dateFilter: [{
+                type: Input
+            }], dateFormat: [{
+                type: Input
+            }], dateSeparator: [{
+                type: Input
+            }], dayEndTime: [{
+                type: Input
+            }], dayStartTime: [{
+                type: Input
+            }], defaultScrollOptions: [{
+                type: Input
+            }], descriptionFormat: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], dragUnit: [{
+                type: Input
+            }], extendAllDayEndDay: [{
+                type: Input
+            }], extraData: [{
+                type: Input
+            }], filterEventResources: [{
+                type: Input
+            }], fitHours: [{
+                type: Input
+            }], fixedDuration: [{
+                type: Input
+            }], flex: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], hideEmptyDays: [{
+                type: Input
+            }], hideEmptyResources: [{
+                type: Input
+            }], hideNonWorkingDays: [{
+                type: Input
+            }], hideResourceNameWhenNarrow: [{
+                type: Input
+            }], hourHeight: [{
+                type: Input
+            }], hourHeightBreakpoints: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], increment: [{
+                type: Input
+            }], inputFieldAlign: [{
+                type: Input
+            }], insertBefore: [{
+                type: Input
+            }], insertFirst: [{
+                type: Input
+            }], interDayDrag: [{
+                type: Input
+            }], interDayResize: [{
+                type: Input
+            }], items: [{
+                type: Input
+            }], keyMap: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], layout: [{
+                type: Input
+            }], layoutStyle: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], maximizeOnMobile: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], minDayWidth: [{
+                type: Input
+            }], minEventHeight: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], minHourHeight: [{
+                type: Input
+            }], minResourceWidth: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], noMatchingDates: [{
+                type: Input
+            }], nonWorkingDays: [{
+                type: Input
+            }], pastEventCls: [{
+                type: Input
+            }], range: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], rendition: [{
+                type: Input
+            }], resourceDateFilter: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], shiftIncrement: [{
+                type: Input
+            }], shortDateFormat: [{
+                type: Input
+            }], shortDateTimeFormat: [{
+                type: Input
+            }], showAvatars: [{
+                type: Input
+            }], showCurrentTime: [{
+                type: Input
+            }], showTime: [{
+                type: Input
+            }], sixMinuteTicks: [{
+                type: Input
+            }], snapRelativeToEventStartDate: [{
+                type: Input
+            }], span: [{
+                type: Input
+            }], stackMultiDayEvents: [{
+                type: Input
+            }], strictRecordMapping: [{
+                type: Input
+            }], syncCalendarDate: [{
+                type: Input
+            }], syncViewDate: [{
+                type: Input
+            }], timeSnapType: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], tools: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], x: [{
+                type: Input
+            }], y: [{
+                type: Input
+            }], anchorSize: [{
+                type: Input
+            }], dayCellCls: [{
+                type: Input
+            }], firstVisibleCell: [{
+                type: Input
+            }], firstVisibleDate: [{
+                type: Input
+            }], focusVisible: [{
+                type: Input
+            }], hasChanges: [{
+                type: Input
+            }], horizontalScroller: [{
+                type: Input
+            }], isSettingValues: [{
+                type: Input
+            }], isValid: [{
+                type: Input
+            }], lastVisibleCell: [{
+                type: Input
+            }], lastVisibleDate: [{
+                type: Input
+            }], parent: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], values: [{
+                type: Input
+            }], onBeforeAutoCreate: [{
+                type: Output
+            }], onBeforeChangeDate: [{
+                type: Output
+            }], onBeforeDestroy: [{
+                type: Output
+            }], onBeforeHide: [{
+                type: Output
+            }], onBeforeResponsiveStateChange: [{
+                type: Output
+            }], onBeforeSetRecord: [{
+                type: Output
+            }], onBeforeShow: [{
+                type: Output
+            }], onBeforeStateApply: [{
+                type: Output
+            }], onBeforeStateSave: [{
+                type: Output
+            }], onCatchAll: [{
+                type: Output
+            }], onCellMapPopulated: [{
+                type: Output
+            }], onCollapse: [{
+                type: Output
+            }], onDayCellPopulated: [{
+                type: Output
+            }], onDestroy: [{
+                type: Output
+            }], onDirtyStateChange: [{
+                type: Output
+            }], onElementCreated: [{
+                type: Output
+            }], onEventAutoCreated: [{
+                type: Output
+            }], onEventPropagate: [{
+                type: Output
+            }], onExpand: [{
+                type: Output
+            }], onFocusIn: [{
+                type: Output
+            }], onFocusOut: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onLayoutUpdate: [{
+                type: Output
+            }], onPaint: [{
+                type: Output
+            }], onRangeChange: [{
+                type: Output
+            }], onReadOnly: [{
+                type: Output
+            }], onRecompose: [{
+                type: Output
+            }], onRefresh: [{
+                type: Output
+            }], onResize: [{
+                type: Output
+            }], onResponsiveStateChange: [{
+                type: Output
+            }], onShiftIncrementChange: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onTickChange: [{
+                type: Output
+            }], onTimeAxisClick: [{
+                type: Output
+            }], onToolClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bryntum-day-resource-view.component.js","sourceRoot":"","sources":["../../../component/src/lib/bryntum-day-resource-view.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Angular wrapper for Bryntum DayResourceView\n */\n\nimport { Component, ElementRef, EventEmitter, Output, Input, SimpleChange, SimpleChanges, OnDestroy, OnInit } from '@angular/core';\n\nimport WrapperHelper from './wrapper.helper';\n\nimport { AlignSpec, Base, BryntumScrollOptions, ButtonConfig, Container, DomConfig, DurationConfig, KeyMapConfig, Layout, MaskConfig, MenuItemConfig, MenuItemEntry, Model, PagingToolbarConfig, Panel, PanelCollapserConfig, PanelCollapserOverlayConfig, PanelHeader, Rectangle, Scroller, ScrollerConfig, StateProvider, TabConfig, Tool, ToolConfig, ToolbarConfig, ToolbarItems, TooltipConfig, Widget } from '@bryntum/core-thin';\nimport { EventModel, ResourceModel } from '@bryntum/scheduler-thin';\nimport { ActionButtonsConfig, CalendarRow, CalendarRowConfig, CalendarView, CalendarContainerItemConfig, CalendarContainerLayoutConfig, DateRangeOwner, DayCell, DayCellWithEvents, DayResourceView, DayResourceViewListeners, DayView, EventBar, FluidDayLayoutConfig, OverflowPopupConfig } from '@bryntum/calendar-thin';\n\nimport { StringHelper } from '@bryntum/core-thin';\n\nexport type BryntumDayResourceViewProps = {\n    // Configs\n    /**\n     * An object or an array of button specifications which add clickable icon buttons to\n     * the rendered event blocks which contain the following properties.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-actionButtons)\n     */\n    actionButtons ? : ActionButtonsConfig[]|Record<string, ActionButtonsConfig>\n    /**\n     * A key to use to activate this view.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-activationKey)\n     */\n    activationKey ? : string\n    /**\n     * Element (or element id) to adopt as this Widget's encapsulating element. The widget's\n     * content will be placed inside this element.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-adopt)\n     */\n    adopt ? : HTMLElement|string\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-align)\n     */\n    align ? : AlignSpec|string\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/calendar/docs/api/Core/widget/Container), it will by default be participating in a\n     * flexbox layout. This config allows you to set this widget's\n     * [align-self](https://developer.mozilla.org/en-US/docs/Web/CSS/align-self) style.\n     */\n    alignSelf ? : string\n    /**\n     * A [CalendarRow](https://bryntum.com/products/calendar/docs/api/Calendar/widget/CalendarRow) widget containing the horizontal series of calendar cells with the\n     * day headers and any all-day, or day-spanning events which fall inside this view's time range.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-allDayEvents)\n     */\n    allDayEvents ? : CalendarRow|CalendarRowConfig|null\n    /**\n     * Configure this as `false` to disable drag-creating events in this view.\n     */\n    allowDragCreate ? : boolean\n    /**\n     * Configure this as `false` to disable drag-moving events in this view.\n     */\n    allowDragMove ? : boolean\n    /**\n     * Configure this as `false` to disable drag-resizing events in this view.\n     */\n    allowDragResize ? : boolean\n    /**\n     * By default, when mousewheel zooming out from *overflowing* the client height, it is not permitted to zoom\n     * further out so that the hours *underflow* the client height.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-allowZoomUnderflow)\n     */\n    allowZoomUnderflow ? : boolean\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating) and being shown through [showBy](#Core/widget/Widget#function-showBy).*\n     * `true` to show a connector arrow pointing to the align target.\n     */\n    anchor ? : boolean\n    /**\n     * By default, when navigating through time, the next time\n     * block will be animated in from the appropriate direction.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-animateTimeShift)\n     */\n    animateTimeShift ? : boolean\n    /**\n     * Element (or the id of an element) to append this widget's element to. Can be configured, or set once at\n     * runtime. To access the element of a rendered widget, see [element](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-element).\n     */\n    appendTo ? : HTMLElement|string\n    /**\n     * A localizable string (May contain `'L{}'` tokens which resolve in the locale file) to inject\n     * into an element which will be linked using the `aria-describedby` attribute.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-ariaDescription)\n     */\n    ariaDescription ? : string\n    /**\n     * A localizable string (May contain `'L{}'` tokens which resolve in the locale file) to inject as\n     * the `aria-label` attribute.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-ariaLabel)\n     */\n    ariaLabel ? : string\n    /**\n     * If this config is set, then the `gesture` configured (which defaults to `dblclick`) creates a\n     * new event at the mouse or touch event's time point.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-autoCreate)\n     */\n    autoCreate ? : {\n        gesture?: string\n        newName?: Function|string\n        step?: string\n        snapType?: 'round'|'ceil'|'floor'\n        duration?: string\n        startHour?: number\n    }|string|boolean\n    /**\n     * A Config object representing the configuration of a [Toolbar](https://bryntum.com/products/calendar/docs/api/Core/widget/Toolbar),\n     * or array of config objects representing the child items of a Toolbar. Another way to add a bbar is to use [strips](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-strips).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-bbar)\n     */\n    bbar ? : (CalendarContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null\n    /**\n     * Custom CSS classes to add to the panel's body element.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-bodyCls)\n     */\n    bodyCls ? : string|object\n    /**\n     * An object where property names with a truthy value indicate which events should bubble up the ownership\n     * hierarchy when triggered.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-bubbleEvents)\n     */\n    bubbleEvents ? : object\n    /**\n     * Set to `false` to not call onXXX method names (e.g. `onShow`, `onClick`), as an easy way to listen for events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-callOnFunctions)\n     */\n    callOnFunctions ? : boolean\n    /**\n     * By default, if an event handler throws an exception, the error propagates up the stack and the\n     * application state is undefined. Code which follows the event handler will *not* be executed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-catchEventHandlerExceptions)\n     */\n    catchEventHandlerExceptions ? : boolean\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating).*\n     * Set to `true` to centre the Widget in browser viewport space.\n     */\n    centered ? : boolean\n    /**\n     * Custom CSS classes to add to element.\n     * May be specified as a space separated string, or as an object in which property names\n     * with truthy values are used as the class names:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-cls)\n     */\n    cls ? : string|object\n    /**\n     * Controls whether the panel is collapsed (the body of the panel is hidden while only the header is\n     * visible). Only valid if the panel is [collapsible](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-collapsible).\n     */\n    collapsed ? : boolean\n    /**\n     * This config enables collapsibility for the panel. See [collapsed](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-collapsed).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-collapsible)\n     */\n    collapsible ? : boolean|PanelCollapserConfig|PanelCollapserOverlayConfig\n    /**\n     * Applies the specified color to the widget, by setting the `--b-primary` CSS variable in the widgets\n     * `style` block.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-color)\n     */\n    color ? : string\n    /**\n     * Programmatic control over which column to start in when used in a grid layout.\n     */\n    column ? : number\n    /**\n     * A function, or name of a function which is passed the [DayCellWithEvents](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#typedef-DayCellWithEvents) object which\n     * describes the events and details of the day.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-columnHeaderRenderer)\n     * @param {DayCellWithEvents} cellData A data block describing the date and the events for that date.\n     * @returns {string,object}\n     */\n    columnHeaderRenderer ? : ((cellData: DayCellWithEvents) => string|object)|string\n    /**\n     * Configure this property as `true` to show the day name and date headers in a more compact style.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-compactHeader)\n     */\n    compactHeader ? : boolean\n    config ? : object\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating) or [positioned](#Core/widget/Widget#config-positioned).*\n     * Element, Widget or Rectangle to which this Widget is constrained.\n     */\n    constrainTo ? : HTMLElement|Widget|Rectangle\n    /**\n     * Custom CSS classes to add to the [contentElement](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-contentElement).\n     * May be specified as a space separated string, or as an object in which property names\n     * with truthy values are used as the class names:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-contentElementCls)\n     */\n    contentElementCls ? : string|object\n    /**\n     * An object containing two properties, `start` and `end` representing the start and\n     * end of core working hours.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-coreHours)\n     * @param {Date} date Date for hours calculation\n     * @returns {object[]}\n     */\n    coreHours ? : object|((date: Date) => object[])|string\n    /**\n     * A function, or name of a function which produces a [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) block to create the current time indicator\n     * which is displayed in a day column which represents the current date. It is the developer's responsibility\n     * to add CSS classes and the appropriate CSS rules to produce the desire appearance.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-currentTimeIndicatorRenderer)\n     * @returns {DomConfig} An object which describes the DOM structure of the today indicator element.\n     */\n    currentTimeIndicatorRenderer ? : (() => DomConfig)|string\n    /**\n     * By default, half hour, fifteen minute tick lines are rendered in a lower contrast\n     * colour than hour lines.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dashedSubticks)\n     */\n    dashedSubticks ? : boolean\n    /**\n     * When this Widget configuration is used in the Grid's RowExpander feature's `widget` config, provide the\n     * field on the expanded record to use for populating this widget's store (if applicable)\n     */\n    dataField ? : string\n    /**\n     * Object to apply to elements dataset (each key will be used as a data-attribute on the element)\n     */\n    dataset ? : Record<string, string>\n    /**\n     * The date to orient this view's [range](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#config-range) around.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-date)\n     */\n    date ? : Date\n    /**\n     * A callback function, or the name of a function in the ownership hierarchy which an\n     * application may provide to filter out day columns for individual dates.\n     * @param {DayCell} context Information about the day column to be created.\n     * @returns {boolean} Return `false` to not display a column for the passed date.\n     */\n    dateFilter ? : ((context: DayCell) => boolean)|string\n    /**\n     * A [DateHelper](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper) format string/function to use to create date output for view descriptions.\n     * @param {Date} date The date to format.\n     * @returns {string} The formatted date.\n     */\n    dateFormat ? : string|((date: Date) => string)\n    /**\n     * A string used to separate start and end dates in the [descriptionFormat](https://bryntum.com/products/calendar/docs/api/Scheduler/view/mixin/Describable#config-descriptionFormat).\n     */\n    dateSeparator ? : string\n    /**\n     * A function, or name of a function which is passed the [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) object which\n     * will be used to sync with a day column.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dayCellRenderer)\n     * @param {DomConfig,object} domConfig A [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) config object which is used to sync the day column element.\n     * @param {object} domConfig.className An object who's truthy property names will be applied as class names.\n     * @param {object} domConfig.style A CSS style definition object.\n     * @param {object} domConfig.dataset The DOM data properties to set.\n     * @param {DomConfig[]} children The [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) definitions for the events in the day.\n     * @param {DayCell} cellData A `DayCell` object that contains data about the cell.\n     * @returns {string}\n     */\n    dayCellRenderer ? : ((domConfig: { className: object, style: object, dataset: object }, children: DomConfig[], cellData: DayCell) => string)|string\n    /**\n     * Either the end hour of the day, or a *24 hour* `HH:MM` string denoting the end date of the last rendered time block.\n     * You can also set this value to a ms timestamp representing time from midnight.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dayEndTime)\n     */\n    dayEndTime ? : string|number\n    /**\n     * A function, or name of a function which is passed the [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) object which\n     * will be used to sync with a day cell header <strong>in the all day row</strong>.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dayHeaderRenderer)\n     * @param {DomConfig,object} headerDomConfig A [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) config object which is used to sync the day header element.\n     * @param {object} headerDomConfig.className An object who's truthy property names will be applied as class names.\n     * @param {object} headerDomConfig.style A CSS style definition object.\n     * @param {object} headerDomConfig.dataset The DOM data properties to set.\n     * @param {DomConfig[]} headerDomConfig.children The [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) definitions the header content. There will be 2 `children` encapsulating the day name and the date.\n     * @param {DayCell} cellData A `DayCell` object that contains data about the cell.\n     * @returns {string}\n     */\n    dayHeaderRenderer ? : ((headerDomConfig: { className: object, style: object, dataset: object, children: DomConfig[] }, cellData: DayCell) => string)|string\n    /**\n     * The [DateHelper](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper) format string/function for day names in the header row (e.g., \"ddd\" for \"Mon\", \"Tue\", ...)\n     * @param {Date} date The date to format.\n     * @returns {string} The formatted date.\n     */\n    dayNameFormat ? : string|((date: Date) => string)\n    /**\n     * Either the start hour of the day, or a *24 hour* `HH:MM` string denoting the start time for days. This\n     * is midnight by default.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dayStartShift)\n     */\n    dayStartShift ? : string|number\n    /**\n     * Either the start hour of the day, or a *24 hour* `HH:MM` string denoting the start of the first rendered\n     * daily time block. You can also set this value to a ms timestamp representing time from midnight.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dayStartTime)\n     */\n    dayStartTime ? : string|number\n    /**\n     * The name of the property to set when a single value is to be applied to this Widget. Such as when used\n     * in a grid WidgetColumn, this is the property to which the column's `field` is applied.\n     */\n    defaultBindProperty ? : string\n    /**\n     * A [query](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#function-query) selector function which can identify the descendant widget to which\n     * focus should be directed by default.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-defaultFocus)\n     * @param {Core.widget.Widget} widget Widget passed to method\n     * @returns {boolean} truthy value if widget is the default one\n     */\n    defaultFocus ? : ((widget: Widget) => boolean)|string\n    /**\n     * A config object containing default settings to apply to all child widgets.\n     */\n    defaults ? : CalendarContainerItemConfig\n    /**\n     * Options to add into scroll options when the [scrollTo](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#function-scrollTo) method is called.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-defaultScrollOptions)\n     */\n    defaultScrollOptions ? : BryntumScrollOptions\n    /**\n     * The date format used by the default [descriptionRenderer](https://bryntum.com/products/calendar/docs/api/Scheduler/view/mixin/Describable#config-descriptionRenderer) for rendering the view's description.\n     * If this value is `null`, the [dateFormat](https://bryntum.com/products/calendar/docs/api/Scheduler/view/mixin/Describable#config-dateFormat) (and potentially [dateSeparator](#Scheduler/view/mixin/Describable#config-dateSeparator)) will\n     * be used.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-descriptionFormat)\n     * @param {Date} date The date to format.\n     * @returns {string} The formatted date.\n     */\n    descriptionFormat ? : string|string[]|boolean[]|((date: Date) => string)|Function[]\n    /**\n     * A function that provides the textual description for this view. If provided, this function overrides the\n     * [descriptionFormat](https://bryntum.com/products/calendar/docs/api/Scheduler/view/mixin/Describable#config-descriptionFormat).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-descriptionRenderer)\n     * @param {Core.widget.Widget} view The active view in case the function is in another scope.\n     * @returns {string} Description string\n     */\n    descriptionRenderer ? : (view: Widget) => string\n    /**\n     * Check for CSS compatibility issues when upgrading to v7. Performs the following checks:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-detectCSSCompatibilityIssues)\n     */\n    detectCSSCompatibilityIssues ? : boolean\n    /**\n     * Disable or enable the widget. It is similar to [readOnly](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-readOnly) except a disabled widget\n     * cannot be focused, uses a different rendition (usually greyish) and does not allow selecting its value.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-disabled)\n     */\n    disabled ? : boolean|'inert'\n    /**\n     * Controls the placement of this widget when it is added to a [panel's ](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel)\n     * [strips collection](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-strips). Typical values for this config are `'top'`,\n     * `'bottom'`, `'left'`, or `'right'`, which cause the widget to be placed on that side of the panel's\n     * body. Such widgets are called \"edge strips\".\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dock)\n     */\n    dock ? : 'top'|'bottom'|'left'|'right'|'start'|'end'|'header'|'pre-header'|object\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating).*\n     * Set to `true` to be able to drag a widget freely on the page. Or set to an object with a ´handleSelector´\n     * property which controls when a drag should start.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-draggable)\n     */\n    draggable ? : boolean|{\n        handleSelector?: string\n    }\n    /**\n     * The [durationUnit](https://bryntum.com/products/calendar/docs/api/Scheduler/model/EventModel#field-durationUnit) to use when drag-creating events\n     * in this view.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-dragUnit)\n     */\n    dragUnit ? : string\n    /**\n     * Make this Panel a docked drawer which slides out from one side of the browser viewport by default.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-drawer)\n     * @param {'start','left','end','right','top','bottom'} side The side of the viewport to dock the drawer to.  * `'start'` means the `inline-start` side. * `'end'` means the `inline-end` side.\n     * @param {string,number} size The size of the drawer in its collapsible axis.\n     * @param {boolean} inline If using the [appendTo](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-appendTo) config to place the drawer inside a host widget, this may be set to `true` to make the drawer inline within that host. Note that, if using this, the layout of the host element must have `flex-direction` set appropriately.\n     * @param {boolean,object} autoClose Specifies what user actions should automatically close the drawer. Defaults to closing when the user clicks outside of the drawer or when focus moves outside of the drawer.\n     * @param {boolean,string} autoClose.mousedown If the user clicks outside of the drawer, the drawer will automatically be hidden. If the value is a string, it is used as a CSS selector to filter clicks which should close the drawer.\n     * @param {boolean,string} autoClose.focusout If focus moves outside of the drawer, the drawer will automatically be hidden.\n     * @param {string} autoClose.mouseout Hides the drawer when the mouse leaves the drawer after the `autoCloseDelay` period.\n     * @param {number} autoCloseDelay When using `mouseout`, this is the delay in milliseconds\n     */\n    drawer ? : boolean|{side?: 'start'|'left'|'end'|'right'|'top'|'bottom', size?: string|number, inline?: boolean, autoClose: { mousedown?: boolean|string, focusout?: boolean|string, mouseout?: string }, autoCloseDelay?: number}\n    /**\n     * An object specifying attributes to assign to the root element of this widget.\n     * Set `null` value to attribute to remove it.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-elementAttributes)\n     */\n    elementAttributes ? : Record<string, string|null>\n    /**\n     * The end date (Time component is zeroed) of this view. Note that in terms of full days,\n     * this is exclusive, ie: 2020-01-012 to 2020-01-08 is *seven* days. The end is 00:00:00 on\n     * the 8th.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-endDate)\n     */\n    endDate ? : Date\n    /**\n     * A function, or the name of a function in the ownership hierarchy to filter which events\n     * are collected into the day cell data blocks.\n     * Return `true` to include the passed event, or a *falsy* value to exclude the event.\n     * @param {Scheduler.model.EventModel} event the passed event\n     * @returns {boolean}\n     */\n    eventFilter ? : ((event: EventModel) => boolean)|string\n    /**\n     * A function, or the name of a function in the ownership hierarchy which you\n     * can specify to customize event DOM content.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-eventHeaderRenderer)\n     * @param {object} detail An object that contains data about the event being rendered\n     * @param {CalendarView} detail.view The view rendering the event\n     * @param {Scheduler.model.EventModel} detail.eventRecord The event record\n     * @param {Scheduler.model.ResourceModel} detail.resourceRecord The resource record\n     * @param {object} detail.renderData A data object containing properties that will be used to create the event element\n     * @param {object} detail.renderData.style The style property is an object containing style properties for the event element\n     * @param {object} detail.renderData.cls The cls property is an object whose property names will be added to the event element if the property value is truthy\n     * @param {object} detail.renderData.iconStyle The iconStyle property is an object containing style properties for the icon element if an icon element is to be used\n     * @param {object} detail.renderData.iconCls The iconCls property is an object whose property names will be added to the icon element. Initially set from the event record's [iconCls](https://bryntum.com/products/calendar/docs/api/Scheduler/model/EventModel#field-iconCls). Can be mutated by the renderer. If null, or no properties are set, no icon will be rendered\n     * @param {string} detail.renderData.eventColor Color to be applied to the event\n     * @param {object} detail.renderData.dataset An object which produces the `dataset` of the resulting event bar\n     * @param {boolean} detail.renderData.solidBar This is valid for views which create event bars. This is set to `true` by default for all day and interday events so that these appear as a solid block of background color. An eventRenderer may mutate this flag to change in what manner the event bar is colored - as a solid bar of color, or using the foreground color (text and icons) such as the MonthView, the CalendarRow (all day events in a DayView), and OverflowPopups\n     * @param {string} detail.renderData.bodyColor When used in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this color is applied to the body of the event element. Note that this must be light enough that the text color (From the SASS variable `$dayview-event-color`) is visible\n     * @param {boolean} detail.showBullet If there is no `iconCls`, and the event is not recurring, then by default a \"bullet\" circular icon is shown if the view's [showBullet](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-showBullet) if set. Setting this property in an event renderer overrides this behaviour.\n     * @returns {DomConfig,DomConfig[],string,void}\n     */\n    eventHeaderRenderer ? : ((detail: { view: CalendarView, eventRecord: EventModel, resourceRecord: ResourceModel, renderData: { style: object, cls: object, iconStyle: object, iconCls: object, eventColor: string, dataset: object, solidBar: boolean, bodyColor: string }, showBullet: boolean }) => DomConfig|DomConfig[]|string|void)|string\n    /**\n     * Configuration to manage event layout class.\n     * See [FluidDayLayout](https://bryntum.com/products/calendar/docs/api/Calendar/layout/day/FluidDayLayout) class docs to see all possible configurations.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-eventLayout)\n     */\n    eventLayout ? : FluidDayLayoutConfig\n    /**\n     * A function, or the name of a function in the ownership hierarchy which you\n     * can specify to customize event DOM content.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-eventRenderer)\n     * @param {object} detail An object that contains data about the event being rendered\n     * @param {CalendarView} detail.view The view rendering the event\n     * @param {Scheduler.model.EventModel} detail.eventRecord The event record\n     * @param {Scheduler.model.ResourceModel} detail.resourceRecord The Resource record\n     * @param {object} detail.renderData A data object containing properties that will be used to create the event element\n     * @param {object} detail.renderData.style The style property is an object containing style properties for the event element\n     * @param {object} detail.renderData.cls The cls property is an object whose property names will be added to the event element if the property value is truthy\n     * @param {object} detail.renderData.iconStyle The iconStyle property is an object containing style properties for the icon element if an icon element is to be used\n     * @param {object} detail.renderData.iconCls The iconCls property is an object whose property names will be added to the icon element. Initially set from the event record's [iconCls](https://bryntum.com/products/calendar/docs/api/Scheduler/model/EventModel#field-iconCls). Can be mutated by the renderer. If null, or no properties are set, no icon will be rendered\n     * @param {string} detail.renderData.eventColor Color to be applied to the event. This may be a CSS color name or a CSS color value in any of the supported CSS color formats such as `#RRGGBB`, `rgb(255, 0, 0)`, or `rgba(255, 0, 0, 0.5)`.\n     * @param {string} detail.renderData.eventBackground A CSS background style to be applied to the event. This is not set by default, but can be set by the renderer to provide a background image or gradient for the event bar. This overrides the `eventColor` property if present.\n     * @param {string} detail.renderData.textColor A CSS color to be applied to the event text. This is not set by default, but can be set by the renderer to provide a custom color for the event name text in the event bar. This may be a CSS color name or a CSS color value in any of the supported CSS color formats such as `#RRGGBB`, `rgb(255, 0, 0)`, or `rgba(255, 0, 0, 0.5)`.\n     * @param {object} detail.renderData.eventInnerStyle The eventInnerStyle property is an object containing style properties for the inner part of the event element, the `.b-cal-event` element.\n     * @param {object} detail.renderData.dataset An object which produces the `dataset` of the resulting event bar\n     * @param {boolean} detail.renderData.solidBar This is valid for views which create event bars. This is set to `true` by default for all day and interday events so that these appear as a solid block of background color. An eventRenderer may mutate this flag to change in what manner the event bar is colored - as a solid bar of color, or using the foreground color (text and icons) such as the MonthView, the CalendarRow (all day events in a DayView), and OverflowPopups\n     * @param {string} detail.renderData.bodyColor When used in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this color is applied to the body of the event element. Note that this must be light enough that the text color (From the SASS variable `$dayview-event-color`) is visible\n     * @param {boolean} detail.renderData.showBullet If there is no `iconCls`, and the event is not recurring, then by default a \"bullet\" circular icon is shown if the view's [showBullet](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-showBullet) if set. Setting this property in an event renderer overrides this behaviour.\n     * @returns {DomConfig,DomConfig[],string,void} The content to be used as the event body.\n     */\n    eventRenderer ? : ((detail: { view: CalendarView, eventRecord: EventModel, resourceRecord: ResourceModel, renderData: { style: object, cls: object, iconStyle: object, iconCls: object, eventColor: string, eventBackground: string, textColor: string, eventInnerStyle: object, dataset: object, solidBar: boolean, bodyColor: string, showBullet: boolean } }) => DomConfig|DomConfig[]|string|void)|string\n    /**\n     * A function which compares events which some views use to decide upon rendering order.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-eventSorter)\n     * @param {Scheduler.model.EventModel,EventBar} lhs The left side value to conpare\n     * @param {Scheduler.model.EventModel,EventBar} rhs The right side value to conpare\n     * @returns {number}\n     */\n    eventSorter ? : (lhs: EventModel|EventBar, rhs: EventModel|EventBar) => number\n    /**\n     * Number of pixels to reduce the height of events by, to leave a gap between them.\n     */\n    eventSpacing ? : number\n    /**\n     * By default, the end date of an all day event is displayed in the UI as\n     * the last calendar date on which the event falls. For most end users, this is the\n     * expected value.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-extendAllDayEndDay)\n     */\n    extendAllDayEndDay ? : boolean\n    extraData ? : any\n    /**\n     * If this is set to `true`, then when determining which assigned resource of a multi assigned event\n     * to use to create the event UI, the first resource which is still selected in the\n     * [resourceFilter](https://bryntum.com/products/calendar/docs/api/Calendar/widget/Sidebar#property-resourceFilter) is used.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-filterEventResources)\n     */\n    filterEventResources ? : boolean\n    /**\n     * When set to `true`, the hours in the day will be sized so that they fit in the available\n     * height.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-fitHours)\n     */\n    fitHours ? : boolean|{\n        minHeight?: number\n    }\n    /**\n     * By default, reconfiguring the [startDate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-startDate) maintains the current duration\n     * of the view and moves the [endDate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-endDate).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-fixedDuration)\n     */\n    fixedDuration ? : boolean\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/calendar/docs/api/Core/widget/Container), it will by default be participating in a\n     * flexbox layout. This config allows you to set this widget's\n     * [flex](https://developer.mozilla.org/en-US/docs/Web/CSS/flex) style.\n     * This may be configured as a single number or a `&lt;flex-grow&gt; &lt;flex-shrink&gt; &lt;flex-basis&gt;` format string.\n     * numeric-only values are interpreted as the `flex-grow` value.\n     */\n    flex ? : number|string\n    /**\n     * Set to `true` to move the widget out of the document flow and position it\n     * absolutely in browser viewport space.\n     */\n    floating ? : boolean\n    /**\n     * Config object of a footer. May contain a `dock`, `html` and a `cls` property. A footer is not a widget,\n     * but rather plain HTML that follows the last element of the panel's body and [strips](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-strips).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-footer)\n     */\n    footer ? : {\n        dock?: 'top'|'right'|'bottom'|'left'|'start'|'end'\n        html?: string\n        cls?: string\n    }|string\n    /**\n     * A Function (or name of a function in the ownership hierarchy) which returns the\n     * [resource record](https://bryntum.com/products/calendar/docs/api/Scheduler/model/ResourceModel) to use to create the UI for an event.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-getPrimaryResource)\n     * @param {Scheduler.model.EventModel} eventRecord The event from which to extract the primary resource.\n     * @returns {Scheduler.model.ResourceModel} The resource to be used to render the event.\n     */\n    getPrimaryResource ? : ((eventRecord: EventModel) => ResourceModel)|string\n    /**\n     * A config [object](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#typedef-PanelHeader) for the panel's header or a string in place of a `title`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-header)\n     */\n    header ? : string|boolean|PanelHeader\n    /**\n     * Widget's height, used to set element `style.height`. Either specify a valid height string or a number,\n     * which will get 'px' appended. We recommend using CSS as the primary way to control height, but in some\n     * cases this config is convenient.\n     */\n    height ? : string|number\n    /**\n     * Configure with true to make widget initially hidden.\n     */\n    hidden ? : boolean\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-hideAnimation)\n     */\n    hideAnimation ? : boolean|object\n    /**\n     * Configure this as `true` to hide day columns which contain no events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-hideEmptyDays)\n     */\n    hideEmptyDays ? : boolean\n    /**\n     * Configure this as `true` to hide resource columns which contain no events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-hideEmptyResources)\n     */\n    hideEmptyResources ? : boolean\n    /**\n     * Configure as `true` to hide [nonWorkingDays](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-nonWorkingDays)\n     */\n    hideNonWorkingDays ? : boolean\n    /**\n     * By default, when a resource leaf column drops to below 100 pixels wide, the resource avatar\n     * hides.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-hideResourceNameWhenNarrow)\n     */\n    hideResourceNameWhenNarrow ? : boolean\n    /**\n     * Specify `true` to make this container hide when it has no visible children (Either empty\n     * or all children hidden).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-hideWhenEmpty)\n     */\n    hideWhenEmpty ? : boolean\n    /**\n     * The height <strong>in pixels</strong> of one hour cell in a day column.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-hourHeight)\n     */\n    hourHeight ? : number\n    /**\n     * An array which encapsulates a set of [hourHeight](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-hourHeight) breakpoints which\n     * dictate when subticks - intervening time indicators - are introduced into the DayView's\n     * time axis.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-hourHeightBreakpoints)\n     */\n    hourHeightBreakpoints ? : number[]\n    /**\n     * An icon to show before the [title](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-title). Either pass a CSS class as a string, or pass a\n     * [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) object describing an element to represent the icon.\n     */\n    icon ? : string|DomConfig\n    /**\n     * Widget id, if not specified one will be generated. Also used for lookups through Widget.getById\n     */\n    id ? : string\n    /**\n     * Determines if the widgets read-only state should be controlled by its parent.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-ignoreParentReadOnly)\n     */\n    ignoreParentReadOnly ? : boolean\n    /**\n     * A millisecond value to which to snap pointer times when clicking or dragging within a day column\n     * and when calculating the hovered time for the [ScheduleTooltip](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ScheduleTooltip) tooltip.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-increment)\n     */\n    increment ? : string|number\n    /**\n     * Convenience setting to align input fields of child widgets. By default, the Field input element is\n     * placed immediately following the `label`. If you prefer to have all input fields aligned to the\n     * right, set this config to `'end'`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-inputFieldAlign)\n     */\n    inputFieldAlign ? : 'start'|'end'\n    /**\n     * Element (or element id) to insert this widget before. If provided, [appendTo](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-appendTo) config is ignored.\n     */\n    insertBefore ? : HTMLElement|string\n    /**\n     * Element (or element id) to append this widget element to, as a first child. If provided, [appendTo](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-appendTo) config is ignored.\n     */\n    insertFirst ? : HTMLElement|string\n    /**\n     * By default, drag-moving an event allows the drag gesture to move the event into other day columns.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-interDayDrag)\n     */\n    interDayDrag ? : boolean\n    /**\n     * By default, drag-resizing an event (including creating a new event) allows the drag gesture to span multiple day\n     * columns to make the event an inter day event.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-interDayResize)\n     */\n    interDayResize ? : boolean\n    /**\n     * An optional CSS class to add to child items of this container.\n     */\n    itemCls ? : string\n    /**\n     * An object containing typed child widget config objects or Widgets. May also be specified\n     * as an array.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-items)\n     */\n    items ? : Record<string, CalendarContainerItemConfig|MenuItemEntry>|(CalendarContainerItemConfig|MenuItemEntry|Widget)[]\n    /**\n     * An object whose keys are the [key](https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key) name\n     * and optional modifier prefixes: `'Ctrl+'`, `'Alt+'`, `'Meta+'`, and `'Shift+'` (case-insensitive). The values\n     * are the name of the instance method to call when the keystroke is received.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-keyMap)\n     */\n    keyMap ? : Record<string, KeyMapConfig>\n    /**\n     * Convenience setting to use same label placement on all child widgets.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-labelPosition)\n     */\n    labelPosition ? : 'before'|'above'|'align-before'|'auto'|null\n    /**\n     * The short name of a helper class which manages rendering and styling of child items.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-layout)\n     */\n    layout ? : string|CalendarContainerLayoutConfig\n    /**\n     * The CSS style properties to apply to the [contentElement](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-contentElement).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-layoutStyle)\n     */\n    layoutStyle ? : object\n    /**\n     * An array of [child item](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#config-items) *config objects* which is to be converted into\n     * instances only when this Container is rendered, rather than eagerly at construct time.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-lazyItems)\n     */\n    lazyItems ? : Record<string, CalendarContainerItemConfig>|CalendarContainerItemConfig[]|Widget[]\n    /**\n     * The listener set for this object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-listeners)\n     */\n    listeners ? : DayResourceViewListeners\n    /**\n     * A class translations of which are used for translating this entity.\n     * This is often used when translations of an item are defined on its container class.\n     * For example:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-localeClass)\n     */\n    localeClass ? : typeof Base\n    /**\n     * Set to `false` to disable localization of this object.\n     */\n    localizable ? : boolean\n    /**\n     * List of properties which values should be translated automatically upon a locale applying.\n     * In case there is a need to localize not typical value (not a String value or a field with re-defined setter/getter),\n     * you could use 'localeKey' meta configuration.\n     * Example:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-localizableProperties)\n     */\n    localizableProperties ? : string[]\n    /**\n     * Widget's margin. This may be configured as a single number or a `TRBL` format string.\n     * numeric-only values are interpreted as pixels.\n     */\n    margin ? : number|string\n    /**\n     * This config object contains the defaults for the [Mask](https://bryntum.com/products/calendar/docs/api/Core/widget/Mask) created for the\n     * [masked](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-masked) config. Any properties specified in the `masked` config will override these\n     * values.\n     */\n    maskDefaults ? : MaskConfig\n    /**\n     * Set to `true` to apply the default mask to the widget. Alternatively, this can be the mask message or a\n     * [Mask](https://bryntum.com/products/calendar/docs/api/Core/widget/Mask) config object.\n     */\n    masked ? : boolean|string|MaskConfig\n    /**\n     * The maximum height the all day event row is allowed to grow within this view\n     * when it is expanded to show all its \"all day\" events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-maxAllDayHeight)\n     */\n    maxAllDayHeight ? : number|string\n    /**\n     * The maximum date to which the `endDate` of this view may be navigated.\n     */\n    maxDate ? : Date|string\n    /**\n     * The element's maxHeight. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [height](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-height), *reading* the value will return the numeric value in pixels.\n     */\n    maxHeight ? : string|number\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-maximizeOnMobile)\n     */\n    maximizeOnMobile ? : number|string\n    /**\n     * The elements maxWidth. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [width](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-width), *reading* the value will return the numeric value in pixels.\n     */\n    maxWidth ? : string|number\n    /**\n     * The minimum date to which the `startDate` of this view may be navigated.\n     */\n    minDate ? : Date|string\n    /**\n     * The minimum width of a day column.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-minDayWidth)\n     */\n    minDayWidth ? : number|string\n    /**\n     * The minimum height to which event blocks in a day cell may shrink. If an event has very\n     * short duration, whatever the [hourHeight](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-hourHeight), and regardless of\n     * [timeline zooming](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#function-zoomTo), the event block will never drop below this height.\n     */\n    minEventHeight ? : number|string\n    /**\n     * The element's minHeight. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [height](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-height), *reading* the value will return the numeric value in pixels.\n     */\n    minHeight ? : string|number\n    /**\n     * The minimum height <strong>in pixels</strong> to allow a zoom request to zoom out to.\n     */\n    minHourHeight ? : number\n    /**\n     * The minimum width of a resource column. This must be a non-zero value to ensure that space\n     * is allocated even when there are many resources and a narrow viewport.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-minResourceWidth)\n     */\n    minResourceWidth ? : number|string\n    /**\n     * The elements minWidth. Can be either a String or a Number (which will have 'px' appended). Note that\n     * like [width](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-width), *reading* the value will return the numeric value in pixels.\n     */\n    minWidth ? : string|number\n    /**\n     * When this is configured as `true` a [ResizeObserver](https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver)\n     * is used to monitor this element for size changes caused by either style manipulation, or by CSS\n     * layout.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-monitorResize)\n     */\n    monitorResize ? : boolean|{\n        immediate?: boolean\n    }\n    /**\n     * An object containing default config objects which may be referenced by name in the [items](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#config-items)\n     * config. For example, a specialized [Menu](https://bryntum.com/products/calendar/docs/api/Core/widget/Menu) subclass may have a `namedItems` default\n     * value defined like this:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-namedItems)\n     */\n    namedItems ? : Record<string, CalendarContainerItemConfig>\n    /**\n     * Text or HTML, or a [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) block to display when all dates in the range have been filtered out.\n     */\n    noMatchingDates ? : string|DomConfig\n    /**\n     * Non-working days as an object where keys are day indices, 0-6 (Sunday-Saturday), and the value is `true`.\n     * Defaults to [nonWorkingDays](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper#property-nonWorkingDays-static).\n     */\n    nonWorkingDays ? : Record<number, boolean>\n    /**\n     * A config object used to create the [OverflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/OverflowPopup) that the\n     * [allDayEvents](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#property-allDayEvents) may show when events for one day overflow the available space.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-overflowPopup)\n     */\n    overflowPopup ? : OverflowPopupConfig\n    /**\n     * The owning Widget of this Widget. If this Widget is directly contained (that is, it is one of the\n     * [items](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#property-items) of a Container), this config will be ignored. In this case\n     * the owner is <strong>always</strong> the encapsulating Container.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-owner)\n     */\n    owner ? : Widget|any\n    /**\n     * The class name to add to events which have an end date in the past. Defaults to `'b-past-event'`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-pastEventCls)\n     */\n    pastEventCls ? : string\n    /**\n     * Set to `true` when a widget is rendered into another widget's [contentElement](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-contentElement), but must\n     * not participate in the standard layout of that widget, and must be positioned relatively to that\n     * widget's [contentElement](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-contentElement).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-positioned)\n     */\n    positioned ? : boolean\n    /**\n     * Prevent tooltip from being displayed on touch devices. Useful for example for buttons that display a\n     * menu on click etc, since the tooltip would be displayed at the same time.\n     */\n    preventTooltipOnTouch ? : boolean\n    /**\n     * The time range around the [date](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#config-date) to display events for.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-range)\n     */\n    range ? : string|DurationConfig\n    /**\n     * Whether this widget is read-only.  This is only valid if the widget is an input\n     * field, <strong>or contains input fields at any depth</strong>.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-readOnly)\n     */\n    readOnly ? : boolean\n    relayStoreEvents ? : boolean\n    /**\n     * Either a default `rendition` to apply to all child widgets, or a map of renditions keyed by child widget\n     * `type`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-rendition)\n     */\n    rendition ? : string|Record<string, string>|null\n    /**\n     * A callback function which an application may provide to filter out resource columns for\n     * particular dates.\n     * @param {DayCell} context Information about the day column to be created.\n     * @returns {boolean} Return `false` to not display a column for the passed resource at the passed date.\n     */\n    resourceDateFilter ? : ((context: DayCell) => boolean)|string\n    /**\n     * Path to load resource images from. Used by the [showResourceAvatars](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-showResourceAvatars) config\n     * to create URLs using the resource's\n     * [image](https://bryntum.com/products/calendar/docs/api/Scheduler/model/ResourceModel#field-image) or\n     * [imageUrl](https://bryntum.com/products/calendar/docs/api/Scheduler/model/ResourceModel#field-imageUrl) fields:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-resourceImagePath)\n     */\n    resourceImagePath ? : string\n    /**\n     * Specifies the various responsive state objects keyed by their name. Each key (except `'*'`, see below) in\n     * this object is a state name (see [responsiveState](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveState)) and its corresponding value is the\n     * associated [ResponsiveState](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#typedef-ResponsiveState) object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-responsive)\n     */\n    responsive ? : object\n    /**\n     * Set to `true` to mark this instance as the default [responsiveTarget](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveTarget) for descendants that do\n     * not specify an explicit [responsiveTarget](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveTarget) of their own.\n     */\n    responsiveRoot ? : boolean\n    /**\n     * The name of the active state of the [responsive](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsive) config. This is assigned internally\n     * and should not be assigned directly.\n     */\n    responsiveState ? : string\n    /**\n     * The widget whose size and other properties drive this object's responsive behavior. If this config is not\n     * specified, the closest ancestor that specified [responsiveRoot=true](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveRoot) will be\n     * used. If there is no such ancestor, then the instance using this mixin is used.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-responsiveTarget)\n     */\n    responsiveTarget ? : string|Widget\n    /**\n     * Configure as `true` to have the component display a translucent ripple when its\n     * [focusElement](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-focusElement), or [element](#Core/widget/Widget#property-element) is tapped <em>if the\n     * current theme supports ripples</em>. Out of the box, only the Material theme supports ripples.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-ripple)\n     */\n    ripple ? : boolean|{\n        delegate?: string\n        color?: string\n        radius?: number\n        clip?: string\n    }\n    /**\n     * If you are rendering this widget to a shadow root inside a web component, set this config to the shadowRoot. If not inside a web component, set it to `document.body`\n     */\n    rootElement ? : ShadowRoot|HTMLElement\n    /**\n     * This may be configured as `true` to make the widget's element use the `direction:rtl` style.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-rtl)\n     */\n    rtl ? : boolean\n    /**\n     * Specifies whether (and optionally in which axes) a Widget may scroll. `true` means this widget may scroll\n     * in both axes. May be an object containing boolean `overflowX` and `overflowY` properties which are\n     * applied to CSS style properties `overflowX` and `overflowY`. If they are boolean, they are translated to\n     * CSS overflow properties thus:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-scrollable)\n     */\n    scrollable ? : boolean|ScrollerConfig|Scroller\n    /**\n     * Defines what to do if document is scrolled while Widget is visible (only relevant when floating is set to `true`).\n     * Valid values: ´null´: do nothing, ´hide´: hide the widget or ´realign´: realign to the target if possible.\n     */\n    scrollAction ? : 'hide'|'realign'|null\n    /**\n     * A button configuration object to use for the automatically created mode selector button for this mode.\n     */\n    selectorButton ? : ButtonConfig\n    /**\n     * A menu item configuration object to use for the automatically created mode selector menu item for this mode.\n     */\n    selectorMenuItem ? : MenuItemConfig\n    /**\n     * The time range to move by when [next](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#function-next) or [previous](#Calendar/widget/mixin/DateRangeOwner#function-previous) is called.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-shiftIncrement)\n     */\n    shiftIncrement ? : string|DurationConfig\n    /**\n     * A [DateHelper](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper) format string/function to use to create date output for\n     * abbreviated view descriptions.\n     * @param {Date} date The date to format.\n     * @returns {string} The formatted date.\n     */\n    shortDateFormat ? : string|((date: Date) => string)\n    /**\n     * A [DateHelper](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper) format string/function to use to create date and time output for\n     * abbreviated view descriptions.\n     * @param {Date} date The date to format.\n     * @returns {string} The formatted date.\n     */\n    shortDateTimeFormat ? : string|((date: Date) => string)\n    /**\n     * The class name to add to events which have duration less than or equal to\n     * [shortEventDuration](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-shortEventDuration).\n     */\n    shortEventCls ? : string\n    /**\n     * The duration at which below and equal to this value, an event's encapsulating element gets\n     * the [shortEventCls](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-shortEventCls) added to it so that small event bars can have style rearrangements.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-shortEventDuration)\n     */\n    shortEventDuration ? : string|number\n    /**\n     * Shows an all day header above the main schedule for All Day events.\n     * Set to `false` to not show all day, or multi-day events in an all day header, but\n     * to have them showing wrapping through the day cells.\n     */\n    showAllDayHeader ? : boolean\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-showAnimation)\n     */\n    showAnimation ? : boolean|object\n    /**\n     * By default, resource avatars are shown in the resource header if there is horizontal space.\n     * Configure this as `false` to inhibit this.\n     */\n    showAvatars ? : boolean\n    /**\n     * <strong>Not applicable in a `DayView`</strong>\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-showBullet)\n     * @param {boolean} bar This is `false` by default. Set this to `true` in modes where a solid event bar should show a bullet icon\n     * @param {boolean} noBar This is `true` by default. Events with no background colour, use this to show the event's defined `eventColor`\n     */\n    showBullet ? : boolean|{bar?: boolean, noBar?: boolean}\n    /**\n     * By default <b>today's</b> date shows a current time line to indicate the current time. This\n     * line is confined to the day cell for <b>today</b>.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-showCurrentTime)\n     */\n    showCurrentTime ? : boolean|{\n        fullWidth?: boolean\n        showTime?: boolean\n        onTop?: boolean\n    }\n    /**\n     * Configure as `true` to show avatars of the resources (calendars) alongside\n     * resource names in resource column headers.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-showHeaderAvatars)\n     */\n    showHeaderAvatars ? : boolean|'last'\n    /**\n     * Configure as `true` to show avatars of the assigned resources (calendars) at the\n     * start of the event bar.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-showResourceAvatars)\n     */\n    showResourceAvatars ? : boolean|string\n    /**\n     * Configure as `false` to hide the start time normally shown at the top of the events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-showTime)\n     */\n    showTime ? : boolean|Record<('startTime'|'endTime'|'duration'), boolean|string|Function>\n    /**\n     * Set to `false` to not show the tooltip when this widget is [disabled](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-disabled)\n     */\n    showTooltipWhenDisabled ? : boolean\n    /**\n     * By default, the most granular time tick level in the DayView's time axis is five minutes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-sixMinuteTicks)\n     */\n    sixMinuteTicks ? : boolean\n    /**\n     * Affects drag drop and moving of events with regard to the [increment](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#property-increment)\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-snapRelativeToEventStartDate)\n     */\n    snapRelativeToEventStartDate ? : boolean\n    /**\n     * Programmatic control over how many columns to span when used in a grid layout.\n     */\n    span ? : number\n    /**\n     * Set to `true` to stack multi-day events within each cell in the order of their start time.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-stackMultiDayEvents)\n     */\n    stackMultiDayEvents ? : boolean\n    /**\n     * The start date (Time component is zeroed) of this view.\n     */\n    startDate ? : Date\n    /**\n     * This value can be one of the following:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-stateful)\n     */\n    stateful ? : boolean|object|string[]\n    /**\n     * The events that, when fired by this component, should trigger it to save its state by calling\n     * [saveState](https://bryntum.com/products/calendar/docs/api/Core/mixin/State#function-saveState).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-statefulEvents)\n     */\n    statefulEvents ? : object|string[]\n    /**\n     * The key to use when saving this object's state in the [stateProvider](https://bryntum.com/products/calendar/docs/api/Core/mixin/State#config-stateProvider). If this config is\n     * not assigned, and [stateful](https://bryntum.com/products/calendar/docs/api/Core/mixin/State#config-stateful) is not set to `false`, the [id](#Core/widget/Widget#config-id)\n     * (if explicitly specified) will be used as the `stateId`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-stateId)\n     */\n    stateId ? : string\n    /**\n     * The `StateProvider` to use to save and restore this object's [state](https://bryntum.com/products/calendar/docs/api/Core/mixin/State#property-state). By default, `state`\n     * will be saved using the [default state provider](https://bryntum.com/products/calendar/docs/api/Core/state/StateProvider#property-instance-static).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-stateProvider)\n     */\n    stateProvider ? : StateProvider\n    /**\n     * Specify `true` to match fields by their `name` property only when assigning a [record](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#config-record),\n     * without falling back to `ref`.\n     */\n    strictRecordMapping ? : boolean\n    /**\n     * An object containing widgets keyed by name. By default (when no `type` is given), strips are\n     * [toolbars](https://bryntum.com/products/calendar/docs/api/Core/widget/Toolbar). If you want to pass an array, you can use\n     * the toolbar's [items](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#config-items).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-strips)\n     */\n    strips ? : Record<string, CalendarContainerItemConfig>\n    /**\n     * The converse of [syncViewDate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#property-syncViewDate)\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-syncCalendarDate)\n     */\n    syncCalendarDate ? : boolean\n    /**\n     * The converse of [syncCalendarDate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#property-syncCalendarDate)\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-syncViewDate)\n     */\n    syncViewDate ? : boolean\n    /**\n     * A configuration for the [tab](https://bryntum.com/products/calendar/docs/api/Core/widget/Tab) created for this widget when it is placed in a\n     * [TabPanel](https://bryntum.com/products/calendar/docs/api/Core/widget/TabPanel). For example, this config can be used to control the icon of the `tab` for\n     * this widget:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-tab)\n     */\n    tab ? : boolean|TabConfig\n    /**\n     * When this container is used as a tab in a TabPanel, these items are added to the\n     * [TabBar](https://bryntum.com/products/calendar/docs/api/Core/widget/TabBar) when this container is the active tab.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-tabBarItems)\n     */\n    tabBarItems ? : ToolbarItems[]|Widget[]\n    /**\n     * The tag name of this Widget's root element\n     */\n    tag ? : string\n    /**\n     * A Config object representing the configuration of a [Toolbar](https://bryntum.com/products/calendar/docs/api/Core/widget/Toolbar),\n     * or array of config objects representing the child items of a Toolbar.\n     * This creates a toolbar docked to the top of the panel immediately below the header.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-tbar)\n     */\n    tbar ? : (CalendarContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null\n    /**\n     * Text alignment: 'left', 'center' or 'right'. Also accepts direction neutral 'start' and 'end'.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-textAlign)\n     */\n    textAlign ? : 'left'|'center'|'right'|'start'|'end'\n    /**\n     * A function, or name of a function which yields a [DomConfig](https://bryntum.com/products/calendar/docs/api/Core/helper/DomHelper#typedef-DomConfig) object to use as a tick background element\n     * for the tick context passed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-tickRenderer)\n     * @param {object} tickContext An object containing the context for the tick being rendered.\n     * @param {Date} tickContext.startTime The start time of the tick.\n     * @param {Date} tickContext.endTime The end time of the tick.\n     * @param {Scheduler.model.EventModel[]} tickContext.events The events that visually intersect with the tick.\n     * @param {number} tickContext.tickIndex The zero-based overall tick index.\n     * @param {number} tickContext.subtickIndex The zero-based subtick index *within* the hour.\n     * @param {number} tickContext.subtickCount The total number of visible subticks in an hour.\n     * @param {Scheduler.model.ResourceModel} tickContext.resourceRecord *If* this view is a resource view, the resource record.\n     * @returns {DomConfig} The DOM config object to use for the tick.\n     */\n    tickRenderer ? : ((tickContext: { startTime: Date, endTime: Date, events: EventModel[], tickIndex: number, subtickIndex: number, subtickCount: number, resourceRecord: ResourceModel }) => DomConfig)|string\n    /**\n     * A [DateHelper](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper) format string/function used to format the time displayed in the\n     * time axis at the left side of the view.\n     * @param {Date} date The date to format.\n     * @returns {string} The formatted date.\n     */\n    timeAxisTimeFormat ? : string|((date: Date) => string)\n    /**\n     * A [DateHelper](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper) format string/function used to format the time displayed in events\n     * @param {Date} date The date to format.\n     * @returns {string} The formatted date.\n     */\n    timeFormat ? : string|((date: Date) => string)\n    /**\n     * The type of rounding to apply when calculating a date from a pointer position in a day\n     * column.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-timeSnapType)\n     */\n    timeSnapType ? : 'round'|'ceil'|'floor'|null\n    /**\n     * A title to display in the header or owning TabPanel. Causes creation and docking of a header\n     * to the top if no header is configured.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-title)\n     */\n    title ? : string\n    /**\n     * The [tools](https://bryntum.com/products/calendar/docs/api/Core/widget/Tool) to add either before or after the `title` in the Panel header. Each\n     * property name is the reference by which an instantiated tool may be retrieved from the live\n     * `[tools](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Toolable#property-tools)` property.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-tools)\n     */\n    tools ? : Record<string, ToolConfig>|null\n    /**\n     * Tooltip for the widget, either as a string or as a Tooltip config object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-tooltip)\n     */\n    tooltip ? : string|TooltipConfig|null\n    /**\n     * By default, tabbing within a Panel is not contained, ie you can TAB out of the Panel\n     * forwards or backwards.\n     * Configure this as `true` to disallow tabbing out of the Panel, and make tabbing circular within this Panel.\n     */\n    trapFocus ? : boolean\n    type ? : 'dayresource'\n    /**\n     * Custom CSS class name suffixes to apply to the elements rendered by this widget. This may be specified\n     * as a space separated string, an array of strings, or as an object in which property names with truthy\n     * values are used as the class names.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-ui)\n     */\n    ui ? : 'plain'|'toolbar'|string|object\n    /**\n     * Either the start hour of the day, or a *24 hour* `HH:MM` string denoting the initially visible start\n     * time of the day. Defaults to 7am.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-visibleStartTime)\n     */\n    visibleStartTime ? : string|number|{\n        time?: string|number\n        block?: 'start'|'end'|'center'|'nearest'\n        edgeOffset?: number\n        animate?: object|boolean|number\n        duration?: number\n        easing?: string\n    }|null\n    /**\n     * The week start day, 0 meaning Sunday, 6 meaning Saturday.\n     * Defaults to [weekStartDay](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper#property-weekStartDay-static).\n     */\n    weekStartDay ? : number\n    /**\n     * A widgets weight determines its position among siblings when added to a [Container](https://bryntum.com/products/calendar/docs/api/Core/widget/Container).\n     * Higher weights go further down.\n     */\n    weight ? : number\n    /**\n     * Widget's width, used to set element `style.width`. Either specify a valid width string or a number, which\n     * will get 'px' appended. We recommend using CSS as the primary way to control width, but in some cases\n     * this config is convenient.\n     */\n    width ? : string|number\n    /**\n     * The x position for the widget.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-x)\n     */\n    x ? : number\n    /**\n     * The y position for the widget.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-y)\n     */\n    y ? : number\n    /**\n     * You can zoom in and out on the time axis using CTRL-key + mouse wheel\n     * on mouse-based devices or pinch-zoom on touch devices.\n     * See also the [hourHeightBreakpoints](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-hourHeightBreakpoints) config option.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#config-zoomOnMouseWheel)\n     */\n    zoomOnMouseWheel ? : boolean|number\n\n}\n\n@Component({\n    selector : 'bryntum-day-resource-view',\n    template : ''\n})\nexport class BryntumDayResourceViewComponent implements OnInit, OnDestroy {\n\n    public static instanceClass = DayResourceView;\n\n    public static instanceName = 'DayResourceView';\n\n    private static bryntumEvents: string[] = [\n        'onBeforeAutoCreate',\n        'onBeforeChangeDate',\n        'onBeforeDestroy',\n        'onBeforeHide',\n        'onBeforeResponsiveStateChange',\n        'onBeforeSetRecord',\n        'onBeforeShow',\n        'onBeforeStateApply',\n        'onBeforeStateSave',\n        'onCatchAll',\n        'onCellMapPopulated',\n        'onCollapse',\n        'onDayCellPopulated',\n        'onDestroy',\n        'onDirtyStateChange',\n        'onElementCreated',\n        'onEventAutoCreated',\n        'onEventPropagate',\n        'onExpand',\n        'onFocusIn',\n        'onFocusOut',\n        'onHide',\n        'onLayoutUpdate',\n        'onPaint',\n        'onRangeChange',\n        'onReadOnly',\n        'onRecompose',\n        'onRefresh',\n        'onResize',\n        'onResponsiveStateChange',\n        'onShiftIncrementChange',\n        'onShow',\n        'onTickChange',\n        'onTimeAxisClick',\n        'onToolClick'\n    ];\n\n    private static bryntumFeatureNames: string[] = [\n\n    ];\n\n    private static bryntumConfigs: string[] = BryntumDayResourceViewComponent.bryntumFeatureNames.concat([\n        'actionButtons',\n        'activationKey',\n        'adopt',\n        'align',\n        'alignSelf',\n        'allDayEvents',\n        'allowDragCreate',\n        'allowDragMove',\n        'allowDragResize',\n        'allowZoomUnderflow',\n        'anchor',\n        'animateTimeShift',\n        'appendTo',\n        'ariaDescription',\n        'ariaLabel',\n        'autoCreate',\n        'bbar',\n        'bodyCls',\n        'bubbleEvents',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'centered',\n        'cls',\n        'collapsed',\n        'collapsible',\n        'color',\n        'column',\n        'columnHeaderRenderer',\n        'compactHeader',\n        'config',\n        'constrainTo',\n        'contentElementCls',\n        'coreHours',\n        'currentTimeIndicatorRenderer',\n        'dashedSubticks',\n        'dataField',\n        'dataset',\n        'date',\n        'dateFilter',\n        'dateFormat',\n        'dateSeparator',\n        'dayCellRenderer',\n        'dayEndTime',\n        'dayHeaderRenderer',\n        'dayNameFormat',\n        'dayStartShift',\n        'dayStartTime',\n        'defaultBindProperty',\n        'defaultFocus',\n        'defaults',\n        'defaultScrollOptions',\n        'descriptionFormat',\n        'descriptionRenderer',\n        'detectCSSCompatibilityIssues',\n        'disabled',\n        'dock',\n        'draggable',\n        'dragUnit',\n        'drawer',\n        'elementAttributes',\n        'endDate',\n        'eventFilter',\n        'eventHeaderRenderer',\n        'eventLayout',\n        'eventRenderer',\n        'eventSorter',\n        'eventSpacing',\n        'extendAllDayEndDay',\n        'extraData',\n        'filterEventResources',\n        'fitHours',\n        'fixedDuration',\n        'flex',\n        'floating',\n        'footer',\n        'getPrimaryResource',\n        'header',\n        'height',\n        'hidden',\n        'hideAnimation',\n        'hideEmptyDays',\n        'hideEmptyResources',\n        'hideNonWorkingDays',\n        'hideResourceNameWhenNarrow',\n        'hideWhenEmpty',\n        'hourHeight',\n        'hourHeightBreakpoints',\n        'icon',\n        'id',\n        'ignoreParentReadOnly',\n        'increment',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'interDayDrag',\n        'interDayResize',\n        'itemCls',\n        'items',\n        'keyMap',\n        'labelPosition',\n        'layout',\n        'layoutStyle',\n        'lazyItems',\n        'listeners',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'margin',\n        'maskDefaults',\n        'masked',\n        'maxAllDayHeight',\n        'maxDate',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minDate',\n        'minDayWidth',\n        'minEventHeight',\n        'minHeight',\n        'minHourHeight',\n        'minResourceWidth',\n        'minWidth',\n        'monitorResize',\n        'namedItems',\n        'noMatchingDates',\n        'nonWorkingDays',\n        'overflowPopup',\n        'owner',\n        'pastEventCls',\n        'positioned',\n        'preventTooltipOnTouch',\n        'range',\n        'readOnly',\n        'relayStoreEvents',\n        'rendition',\n        'resourceDateFilter',\n        'resourceImagePath',\n        'responsive',\n        'responsiveRoot',\n        'responsiveState',\n        'responsiveTarget',\n        'ripple',\n        'rootElement',\n        'rtl',\n        'scrollable',\n        'scrollAction',\n        'selectorButton',\n        'selectorMenuItem',\n        'shiftIncrement',\n        'shortDateFormat',\n        'shortDateTimeFormat',\n        'shortEventCls',\n        'shortEventDuration',\n        'showAllDayHeader',\n        'showAnimation',\n        'showAvatars',\n        'showBullet',\n        'showCurrentTime',\n        'showHeaderAvatars',\n        'showResourceAvatars',\n        'showTime',\n        'showTooltipWhenDisabled',\n        'sixMinuteTicks',\n        'snapRelativeToEventStartDate',\n        'span',\n        'stackMultiDayEvents',\n        'startDate',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'strictRecordMapping',\n        'strips',\n        'syncCalendarDate',\n        'syncViewDate',\n        'tab',\n        'tabBarItems',\n        'tag',\n        'tbar',\n        'textAlign',\n        'tickRenderer',\n        'timeAxisTimeFormat',\n        'timeFormat',\n        'timeSnapType',\n        'title',\n        'tools',\n        'tooltip',\n        'trapFocus',\n        'type',\n        'ui',\n        'visibleStartTime',\n        'weekStartDay',\n        'weight',\n        'width',\n        'x',\n        'y',\n        'zoomOnMouseWheel'\n    ]);\n\n    private static bryntumConfigsOnly: string[] = [\n        'actionButtons',\n        'activationKey',\n        'adopt',\n        'align',\n        'allDayEvents',\n        'anchor',\n        'ariaDescription',\n        'ariaLabel',\n        'bbar',\n        'bodyCls',\n        'bubbleEvents',\n        'centered',\n        'collapsible',\n        'color',\n        'columnHeaderRenderer',\n        'config',\n        'constrainTo',\n        'contentElementCls',\n        'currentTimeIndicatorRenderer',\n        'dataField',\n        'dayCellRenderer',\n        'dayHeaderRenderer',\n        'dayNameFormat',\n        'dayStartShift',\n        'defaultBindProperty',\n        'defaultFocus',\n        'defaults',\n        'descriptionRenderer',\n        'detectCSSCompatibilityIssues',\n        'dock',\n        'draggable',\n        'drawer',\n        'elementAttributes',\n        'endDate',\n        'eventFilter',\n        'eventHeaderRenderer',\n        'eventLayout',\n        'eventRenderer',\n        'eventSorter',\n        'eventSpacing',\n        'floating',\n        'footer',\n        'getPrimaryResource',\n        'header',\n        'hideAnimation',\n        'hideWhenEmpty',\n        'icon',\n        'ignoreParentReadOnly',\n        'itemCls',\n        'lazyItems',\n        'listeners',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'maskDefaults',\n        'masked',\n        'maxAllDayHeight',\n        'monitorResize',\n        'namedItems',\n        'overflowPopup',\n        'owner',\n        'positioned',\n        'preventTooltipOnTouch',\n        'relayStoreEvents',\n        'resourceImagePath',\n        'responsive',\n        'responsiveRoot',\n        'responsiveState',\n        'responsiveTarget',\n        'ripple',\n        'rootElement',\n        'scrollAction',\n        'selectorButton',\n        'selectorMenuItem',\n        'shortEventCls',\n        'shortEventDuration',\n        'showAllDayHeader',\n        'showAnimation',\n        'showBullet',\n        'showHeaderAvatars',\n        'showResourceAvatars',\n        'showTooltipWhenDisabled',\n        'startDate',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'strips',\n        'tab',\n        'tabBarItems',\n        'tag',\n        'tbar',\n        'textAlign',\n        'tickRenderer',\n        'timeAxisTimeFormat',\n        'timeFormat',\n        'trapFocus',\n        'type',\n        'ui',\n        'visibleStartTime',\n        'weekStartDay',\n        'weight',\n        'zoomOnMouseWheel'\n    ];\n\n    private static bryntumProps: string[] = BryntumDayResourceViewComponent.bryntumFeatureNames.concat([\n        'alignSelf',\n        'allowDragCreate',\n        'allowDragMove',\n        'allowDragResize',\n        'allowZoomUnderflow',\n        'anchorSize',\n        'animateTimeShift',\n        'appendTo',\n        'autoCreate',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'cls',\n        'collapsed',\n        'column',\n        'compactHeader',\n        'coreHours',\n        'dashedSubticks',\n        'dataset',\n        'date',\n        'dateFilter',\n        'dateFormat',\n        'dateSeparator',\n        'dayCellCls',\n        'dayEndTime',\n        'dayStartTime',\n        'defaultScrollOptions',\n        'descriptionFormat',\n        'disabled',\n        'dragUnit',\n        'extendAllDayEndDay',\n        'extraData',\n        'filterEventResources',\n        'firstVisibleCell',\n        'firstVisibleDate',\n        'fitHours',\n        'fixedDuration',\n        'flex',\n        'focusVisible',\n        'hasChanges',\n        'height',\n        'hidden',\n        'hideEmptyDays',\n        'hideEmptyResources',\n        'hideNonWorkingDays',\n        'hideResourceNameWhenNarrow',\n        'horizontalScroller',\n        'hourHeight',\n        'hourHeightBreakpoints',\n        'id',\n        'increment',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'interDayDrag',\n        'interDayResize',\n        'isSettingValues',\n        'isValid',\n        'items',\n        'keyMap',\n        'labelPosition',\n        'lastVisibleCell',\n        'lastVisibleDate',\n        'layout',\n        'layoutStyle',\n        'margin',\n        'maxDate',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minDate',\n        'minDayWidth',\n        'minEventHeight',\n        'minHeight',\n        'minHourHeight',\n        'minResourceWidth',\n        'minWidth',\n        'noMatchingDates',\n        'nonWorkingDays',\n        'parent',\n        'pastEventCls',\n        'range',\n        'readOnly',\n        'record',\n        'rendition',\n        'resourceDateFilter',\n        'rtl',\n        'scrollable',\n        'shiftIncrement',\n        'shortDateFormat',\n        'shortDateTimeFormat',\n        'showAvatars',\n        'showCurrentTime',\n        'showTime',\n        'sixMinuteTicks',\n        'snapRelativeToEventStartDate',\n        'span',\n        'stackMultiDayEvents',\n        'state',\n        'strictRecordMapping',\n        'syncCalendarDate',\n        'syncViewDate',\n        'timeSnapType',\n        'title',\n        'tools',\n        'tooltip',\n        'values',\n        'width',\n        'x',\n        'y'\n    ]);\n\n    private elementRef: ElementRef;\n    public instance!: DayResourceView;\n\n    private bryntumConfig = {\n        adopt            : undefined,\n        appendTo         : undefined,\n        href             : undefined,\n        angularComponent : this,\n        features         : {},\n        listeners        : {}\n    };\n\n    constructor(element: ElementRef) {\n        this.elementRef = element;\n    }\n\n    // Configs only\n    @Input() actionButtons                ! : ActionButtonsConfig[]|Record<string, ActionButtonsConfig>;\n    @Input() activationKey                ! : string;\n    @Input() adopt                        ! : HTMLElement|string;\n    @Input() align                        ! : AlignSpec|string;\n    @Input() allDayEvents                 ! : CalendarRow|CalendarRowConfig|null;\n    @Input() anchor                       ! : boolean;\n    @Input() ariaDescription              ! : string;\n    @Input() ariaLabel                    ! : string;\n    @Input() bbar                         ! : (CalendarContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null;\n    @Input() bodyCls                      ! : string|object;\n    @Input() bubbleEvents                 ! : object;\n    @Input() centered                     ! : boolean;\n    @Input() collapsible                  ! : boolean|PanelCollapserConfig|PanelCollapserOverlayConfig;\n    @Input() color                        ! : string;\n    @Input() columnHeaderRenderer         ! : ((cellData: DayCellWithEvents) => string|object)|string;\n    @Input() config                       ! : object;\n    @Input() constrainTo                  ! : HTMLElement|Widget|Rectangle;\n    @Input() contentElementCls            ! : string|object;\n    @Input() currentTimeIndicatorRenderer ! : (() => DomConfig)|string;\n    @Input() dataField                    ! : string;\n    @Input() dayCellRenderer              ! : ((domConfig: { className: object, style: object, dataset: object }, children: DomConfig[], cellData: DayCell) => string)|string;\n    @Input() dayHeaderRenderer            ! : ((headerDomConfig: { className: object, style: object, dataset: object, children: DomConfig[] }, cellData: DayCell) => string)|string;\n    @Input() dayNameFormat                ! : string|((date: Date) => string);\n    @Input() dayStartShift                ! : string|number;\n    @Input() defaultBindProperty          ! : string;\n    @Input() defaultFocus                 ! : ((widget: Widget) => boolean)|string;\n    @Input() defaults                     ! : CalendarContainerItemConfig;\n    @Input() descriptionRenderer          ! : (view: Widget) => string;\n    @Input() detectCSSCompatibilityIssues ! : boolean;\n    @Input() dock                         ! : 'top'|'bottom'|'left'|'right'|'start'|'end'|'header'|'pre-header'|object;\n    @Input() draggable                    ! : boolean|{\n        handleSelector?: string\n    };\n    @Input() drawer                       ! : boolean|{side?: 'start'|'left'|'end'|'right'|'top'|'bottom', size?: string|number, inline?: boolean, autoClose: { mousedown?: boolean|string, focusout?: boolean|string, mouseout?: string }, autoCloseDelay?: number};\n    @Input() elementAttributes            ! : Record<string, string|null>;\n    @Input() endDate                      ! : Date;\n    @Input() eventFilter                  ! : ((event: EventModel) => boolean)|string;\n    @Input() eventHeaderRenderer          ! : ((detail: { view: CalendarView, eventRecord: EventModel, resourceRecord: ResourceModel, renderData: { style: object, cls: object, iconStyle: object, iconCls: object, eventColor: string, dataset: object, solidBar: boolean, bodyColor: string }, showBullet: boolean }) => DomConfig|DomConfig[]|string|void)|string;\n    @Input() eventLayout                  ! : FluidDayLayoutConfig;\n    @Input() eventRenderer                ! : ((detail: { view: CalendarView, eventRecord: EventModel, resourceRecord: ResourceModel, renderData: { style: object, cls: object, iconStyle: object, iconCls: object, eventColor: string, eventBackground: string, textColor: string, eventInnerStyle: object, dataset: object, solidBar: boolean, bodyColor: string, showBullet: boolean } }) => DomConfig|DomConfig[]|string|void)|string;\n    @Input() eventSorter                  ! : (lhs: EventModel|EventBar, rhs: EventModel|EventBar) => number;\n    @Input() eventSpacing                 ! : number;\n    @Input() floating                     ! : boolean;\n    @Input() footer                       ! : {\n        dock?: 'top'|'right'|'bottom'|'left'|'start'|'end'\n        html?: string\n        cls?: string\n    }|string;\n    @Input() getPrimaryResource           ! : ((eventRecord: EventModel) => ResourceModel)|string;\n    @Input() header                       ! : string|boolean|PanelHeader;\n    @Input() hideAnimation                ! : boolean|object;\n    @Input() hideWhenEmpty                ! : boolean;\n    @Input() icon                         ! : string|DomConfig;\n    @Input() ignoreParentReadOnly         ! : boolean;\n    @Input() itemCls                      ! : string;\n    @Input() lazyItems                    ! : Record<string, CalendarContainerItemConfig>|CalendarContainerItemConfig[]|Widget[];\n    @Input() listeners                    ! : DayResourceViewListeners;\n    @Input() localeClass                  ! : typeof Base;\n    @Input() localizable                  ! : boolean;\n    @Input() localizableProperties        ! : string[];\n    @Input() maskDefaults                 ! : MaskConfig;\n    @Input() masked                       ! : boolean|string|MaskConfig;\n    @Input() maxAllDayHeight              ! : number|string;\n    @Input() monitorResize                ! : boolean|{\n        immediate?: boolean\n    };\n    @Input() namedItems                   ! : Record<string, CalendarContainerItemConfig>;\n    @Input() overflowPopup                ! : OverflowPopupConfig;\n    @Input() owner                        ! : Widget|any;\n    @Input() positioned                   ! : boolean;\n    @Input() preventTooltipOnTouch        ! : boolean;\n    @Input() relayStoreEvents             ! : boolean;\n    @Input() resourceImagePath            ! : string;\n    @Input() responsive                   ! : object;\n    @Input() responsiveRoot               ! : boolean;\n    @Input() responsiveState              ! : string;\n    @Input() responsiveTarget             ! : string|Widget;\n    @Input() ripple                       ! : boolean|{\n        delegate?: string\n        color?: string\n        radius?: number\n        clip?: string\n    };\n    @Input() rootElement                  ! : ShadowRoot|HTMLElement;\n    @Input() scrollAction                 ! : 'hide'|'realign'|null;\n    @Input() selectorButton               ! : ButtonConfig;\n    @Input() selectorMenuItem             ! : MenuItemConfig;\n    @Input() shortEventCls                ! : string;\n    @Input() shortEventDuration           ! : string|number;\n    @Input() showAllDayHeader             ! : boolean;\n    @Input() showAnimation                ! : boolean|object;\n    @Input() showBullet                   ! : boolean|{bar?: boolean, noBar?: boolean};\n    @Input() showHeaderAvatars            ! : boolean|'last';\n    @Input() showResourceAvatars          ! : boolean|string;\n    @Input() showTooltipWhenDisabled      ! : boolean;\n    @Input() startDate                    ! : Date;\n    @Input() stateful                     ! : boolean|object|string[];\n    @Input() statefulEvents               ! : object|string[];\n    @Input() stateId                      ! : string;\n    @Input() stateProvider                ! : StateProvider;\n    @Input() strips                       ! : Record<string, CalendarContainerItemConfig>;\n    @Input() tab                          ! : boolean|TabConfig;\n    @Input() tabBarItems                  ! : ToolbarItems[]|Widget[];\n    @Input() tag                          ! : string;\n    @Input() tbar                         ! : (CalendarContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null;\n    @Input() textAlign                    ! : 'left'|'center'|'right'|'start'|'end';\n    @Input() tickRenderer                 ! : ((tickContext: { startTime: Date, endTime: Date, events: EventModel[], tickIndex: number, subtickIndex: number, subtickCount: number, resourceRecord: ResourceModel }) => DomConfig)|string;\n    @Input() timeAxisTimeFormat           ! : string|((date: Date) => string);\n    @Input() timeFormat                   ! : string|((date: Date) => string);\n    @Input() trapFocus                    ! : boolean;\n    @Input() type                         ! : 'dayresource';\n    @Input() ui                           ! : 'plain'|'toolbar'|string|object;\n    @Input() visibleStartTime             ! : string|number|{\n        time?: string|number\n        block?: 'start'|'end'|'center'|'nearest'\n        edgeOffset?: number\n        animate?: object|boolean|number\n        duration?: number\n        easing?: string\n    }|null;\n    @Input() weekStartDay                 ! : number;\n    @Input() weight                       ! : number;\n    @Input() zoomOnMouseWheel             ! : boolean|number;\n\n    // Configs and properties\n    @Input() alignSelf                    ! : string;\n    @Input() allowDragCreate              ! : boolean;\n    @Input() allowDragMove                ! : boolean;\n    @Input() allowDragResize              ! : boolean;\n    @Input() allowZoomUnderflow           ! : boolean;\n    @Input() animateTimeShift             ! : boolean;\n    @Input() appendTo                     ! : HTMLElement|string;\n    @Input() autoCreate                   ! : {\n        gesture?: string\n        newName?: Function|string\n        step?: string\n        snapType?: 'round'|'ceil'|'floor'\n        duration?: string\n        startHour?: number\n    }|string|boolean;\n    @Input() callOnFunctions              ! : boolean;\n    @Input() catchEventHandlerExceptions  ! : boolean;\n    @Input() cls                          ! : string|object;\n    @Input() collapsed                    ! : boolean;\n    @Input() column                       ! : number;\n    @Input() compactHeader                ! : boolean;\n    @Input() coreHours                    ! : object|((date: Date) => object[])|string;\n    @Input() dashedSubticks               ! : boolean;\n    @Input() dataset                      ! : object|Record<string, string>;\n    @Input() date                         ! : Date;\n    @Input() dateFilter                   ! : ((context: DayCell) => boolean)|string;\n    @Input() dateFormat                   ! : string|((date: Date) => string);\n    @Input() dateSeparator                ! : string;\n    @Input() dayEndTime                   ! : string|number;\n    @Input() dayStartTime                 ! : string|number;\n    @Input() defaultScrollOptions         ! : BryntumScrollOptions;\n    @Input() descriptionFormat            ! : string|string[]|boolean[]|((date: Date) => string)|Function[];\n    @Input() disabled                     ! : boolean|'inert';\n    @Input() dragUnit                     ! : string;\n    @Input() extendAllDayEndDay           ! : boolean;\n    @Input() extraData                    ! : any;\n    @Input() filterEventResources         ! : boolean;\n    @Input() fitHours                     ! : boolean|{\n        minHeight?: number\n    };\n    @Input() fixedDuration                ! : boolean;\n    @Input() flex                         ! : number|string;\n    @Input() height                       ! : number|string;\n    @Input() hidden                       ! : boolean;\n    @Input() hideEmptyDays                ! : boolean;\n    @Input() hideEmptyResources           ! : boolean;\n    @Input() hideNonWorkingDays           ! : boolean;\n    @Input() hideResourceNameWhenNarrow   ! : boolean;\n    @Input() hourHeight                   ! : number;\n    @Input() hourHeightBreakpoints        ! : number[];\n    @Input() id                           ! : string;\n    @Input() increment                    ! : string|number;\n    @Input() inputFieldAlign              ! : 'start'|'end';\n    @Input() insertBefore                 ! : HTMLElement|string;\n    @Input() insertFirst                  ! : HTMLElement|string;\n    @Input() interDayDrag                 ! : boolean;\n    @Input() interDayResize               ! : boolean;\n    @Input() items                        ! : (CalendarContainerItemConfig|MenuItemConfig|Widget)[]|Record<string, CalendarContainerItemConfig|MenuItemConfig>|Widget[]|Record<string, CalendarContainerItemConfig|MenuItemEntry>|(CalendarContainerItemConfig|MenuItemEntry|Widget)[];\n    @Input() keyMap                       ! : Record<string, KeyMapConfig>;\n    @Input() labelPosition                ! : 'before'|'above'|'align-before'|'auto'|null;\n    @Input() layout                       ! : Layout|string|CalendarContainerLayoutConfig;\n    @Input() layoutStyle                  ! : object;\n    @Input() margin                       ! : number|string;\n    @Input() maxDate                      ! : Date|string;\n    @Input() maxHeight                    ! : string|number;\n    @Input() maximizeOnMobile             ! : number|string;\n    @Input() maxWidth                     ! : string|number;\n    @Input() minDate                      ! : Date|string;\n    @Input() minDayWidth                  ! : number|string;\n    @Input() minEventHeight               ! : number|string;\n    @Input() minHeight                    ! : string|number;\n    @Input() minHourHeight                ! : number;\n    @Input() minResourceWidth             ! : number|string;\n    @Input() minWidth                     ! : string|number;\n    @Input() noMatchingDates              ! : string|DomConfig;\n    @Input() nonWorkingDays               ! : Record<number, boolean>;\n    @Input() pastEventCls                 ! : string;\n    @Input() range                        ! : string|DurationConfig;\n    @Input() readOnly                     ! : boolean;\n    @Input() rendition                    ! : string|Record<string, string>|null;\n    @Input() resourceDateFilter           ! : ((context: DayCell) => boolean)|string;\n    @Input() rtl                          ! : boolean;\n    @Input() scrollable                   ! : Scroller|boolean|ScrollerConfig;\n    @Input() shiftIncrement               ! : string|DurationConfig;\n    @Input() shortDateFormat              ! : string|((date: Date) => string);\n    @Input() shortDateTimeFormat          ! : string|((date: Date) => string);\n    @Input() showAvatars                  ! : boolean;\n    @Input() showCurrentTime              ! : boolean|{\n        fullWidth?: boolean\n        showTime?: boolean\n        onTop?: boolean\n    };\n    @Input() showTime                     ! : boolean|Record<('startTime'|'endTime'|'duration'), boolean|string|Function>;\n    @Input() sixMinuteTicks               ! : boolean;\n    @Input() snapRelativeToEventStartDate ! : boolean;\n    @Input() span                         ! : number;\n    @Input() stackMultiDayEvents          ! : boolean;\n    @Input() strictRecordMapping          ! : boolean;\n    @Input() syncCalendarDate             ! : boolean;\n    @Input() syncViewDate                 ! : boolean;\n    @Input() timeSnapType                 ! : 'round'|'ceil'|'floor'|null;\n    @Input() title                        ! : string;\n    @Input() tools                        ! : Record<string, Tool|ToolConfig>|null|Record<string, Tool>|Record<string, ToolConfig>;\n    @Input() tooltip                      ! : string|TooltipConfig|null;\n    @Input() width                        ! : number|string;\n    @Input() x                            ! : number;\n    @Input() y                            ! : number;\n\n    // Properties only\n    @Input() anchorSize         ! : number[];\n    @Input() dayCellCls         ! : string;\n    @Input() firstVisibleCell   ! : HTMLElement;\n    @Input() firstVisibleDate   ! : Date;\n    @Input() focusVisible       ! : boolean;\n    @Input() hasChanges         ! : boolean;\n    @Input() horizontalScroller ! : Scroller;\n    @Input() isSettingValues    ! : boolean;\n    @Input() isValid            ! : boolean;\n    @Input() lastVisibleCell    ! : HTMLElement;\n    @Input() lastVisibleDate    ! : Date;\n    @Input() parent             ! : Widget;\n    @Input() record             ! : Model;\n    @Input() state              ! : any;\n    @Input() values             ! : Record<string, object>;\n\n    // Events emitters\n    /**\n     * This event fires whenever the [autoCreate gesture](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate) is detected\n     * and also when a [drag-create](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag) gesture is detected.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-beforeAutoCreate)\n     * @param {object} event Event object\n     * @param {Event} event.domEvent The DOM event which initiated the creation.\n     * @param {Date} event.date *DEPRECATED in favour of `startDate`.* The starting time of the event to be created. If this is in a `DayView`, this will be snapped according to the specification in [autoCreate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate)\n     * @param {Date} event.startDate The starting time of the event to be created. If this is in a `DayView`, this will be snapped according to the specification in [autoCreate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate)\n     * @param {Date} event.endDate The ending time of the event to be created.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource if the UI includes a resource.\n     * @param {CalendarView} event.view This view.\n     */\n    @Output() onBeforeAutoCreate: any = new EventEmitter<((event: { domEvent: Event, date: Date, startDate: Date, endDate: Date, resourceRecord: ResourceModel, view: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Triggered before a view's orientating date changes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-beforeChangeDate)\n     * @param {object} event Event object\n     * @param {Date} event.oldDate The current orientating date of this view.\n     * @param {Date} event.date The new date to which this view is to be orientated.\n     */\n    @Output() onBeforeChangeDate: any = new EventEmitter<((event: { oldDate: Date, date: Date }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onBeforeDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Triggered before a widget is hidden. Return `false` to prevent the action.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being hidden.\n     */\n    @Output() onBeforeHide: any = new EventEmitter<((event: { source: Widget }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Triggered before a new [responsiveState](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveState) is applied.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget whose `responsiveState` is to be changed\n     * @param {string} event.state The new value for the widget's `responsiveState`\n     * @param {string} event.oldState The previous value for the widget's `responsiveState`\n     */\n    @Output() onBeforeResponsiveStateChange: any = new EventEmitter<((event: { source: Widget, state: string, oldState: string }) => void)|string>();\n    /**\n     * Fired before this container will load record values into its child fields. This is useful if you\n     * want to modify the UI before data is loaded (e.g. set some input field to be readonly)\n     * @param {object} event Event object\n     * @param {Core.widget.Container} event.source The container\n     * @param {Core.data.Model} event.record The record\n     */\n    @Output() onBeforeSetRecord: any = new EventEmitter<((event: { source: Container, record: Model }) => void)|string>();\n    /**\n     * Triggered before a widget is shown. Return `false` to prevent the action.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget,any} event.source The widget being shown\n     */\n    @Output() onBeforeShow: any = new EventEmitter<((event: { source: Widget|any }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired before state is applied to the source. Allows editing the state object or preventing the operation.\n     * @param {object} event Event object\n     * @param {any} event.state State object config\n     */\n    @Output() onBeforeStateApply: any = new EventEmitter<((event: { state: any }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired before state is saved by the StateProvider. Allows editing the state object or preventing the operation.\n     * @param {object} event Event object\n     * @param {any} event.state State object config\n     */\n    @Output() onBeforeStateSave: any = new EventEmitter<((event: { state: any }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires when any other event is fired from the object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-catchAll)\n     * @param {object} event Event object\n     * @param {{[key: string]: any, type: string}} event.event The Object that contains event details\n     * @param {string} event.event.type The type of the event which is caught by the listener\n     */\n    @Output() onCatchAll: any = new EventEmitter<((event: {[key: string]: any, type: string}) => void)|string>();\n    /**\n     * Fired when a new set of events has been gathered for this view's date range.\n     * @param {object} event Event object\n     * @param {Map<any, any>} event.cellMap The map of date keys to [day cell](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellCollecter#typedef-DayCell) data blocks.\n     */\n    @Output() onCellMapPopulated: any = new EventEmitter<((event: { cellMap: Map<any, any> }) => void)|string>();\n    /**\n     * Fires when a Panel is collapsed using the [collapsible](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-collapsible) setting.\n     * @param {object} event Event object\n     * @param {Core.widget.Panel} event.source This Panel.\n     */\n    @Output() onCollapse: any = new EventEmitter<((event: { source: Panel }) => void)|string>();\n    /**\n     * Fired after one day cell's events are collected in sorted order according to the\n     * [eventSorter](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-eventSorter)\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-dayCellPopulated)\n     * @param {object} event Event object\n     * @param {Scheduler.model.EventModel[]} event.events The events to be shown for the passed date\n     * @param {Date} event.The date the events are to be shown in.\n     */\n    @Output() onDayCellPopulated: any = new EventEmitter<((event: { events: EventModel[], The: Date }) => void)|string>();\n    /**\n     * Fires when an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Fires when a field is mutated and the state of the [hasChanges](https://bryntum.com/products/calendar/docs/api/Core/widget/Container#property-hasChanges) property changes\n     * @param {object} event Event object\n     * @param {Core.widget.Container} event.source The container.\n     * @param {boolean} event.dirty The dirty state of the Container - `true` if there are any fields which have been changed since initial load.\n     */\n    @Output() onDirtyStateChange: any = new EventEmitter<((event: { source: Container, dirty: boolean }) => void)|string>();\n    /**\n     * Triggered when a widget's [element](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#property-element) is available.\n     * @param {object} event Event object\n     * @param {HTMLElement} event.element The Widget's element.\n     */\n    @Output() onElementCreated: any = new EventEmitter<((event: { element: HTMLElement }) => void)|string>();\n    /**\n     * Fired when an [autoCreate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate) gesture has created a new event\n     * and added it to the event store.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-eventAutoCreated)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source This Calendar view instance.\n     * @param {Scheduler.model.EventModel} event.eventRecord The new event record.\n     */\n    @Output() onEventAutoCreated: any = new EventEmitter<((event: { source: CalendarView, eventRecord: EventModel }) => void)|string>();\n    /**\n     * Fires when a day spanning event is found, and the date to which its encapsulating event bar\n     * extends has been calculated.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-eventPropagate)\n     * @param {object} event Event object\n     * @param {Date} event.eventEndDate The end date for which to calculate the propagate end date.\n     * @param {Date} event.propagateEndDate The system-calculated end point of the event bar.\n     * @param {boolean} event.isAllDay `true` if the event is an all day event, or spans multiple days.\n     * @param {boolean} event.isOverflow `true` if this is being called as part of further propagation.\n     * @param {boolean} event.overflows `true` if the event extends into future cells.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event record being propagated.\n     * @param {Date} event.date The date from which the event is being propagated.\n     */\n    @Output() onEventPropagate: any = new EventEmitter<((event: { eventEndDate: Date, propagateEndDate: Date, isAllDay: boolean, isOverflow: boolean, overflows: boolean, eventRecord: EventModel, date: Date }) => void)|string>();\n    /**\n     * Fires when a Panel is expanded using the [collapsible](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-collapsible) setting.\n     * @param {object} event Event object\n     * @param {Core.widget.Panel} event.source This Panel.\n     */\n    @Output() onExpand: any = new EventEmitter<((event: { source: Panel }) => void)|string>();\n    /**\n     * Fired when focus enters this Widget.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source This Widget\n     * @param {HTMLElement} event.fromElement The element which lost focus.\n     * @param {HTMLElement} event.toElement The element which gained focus.\n     * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.\n     * @param {Core.widget.Widget} event.toWidget The widget which gained focus.\n     * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.\n     */\n    @Output() onFocusIn: any = new EventEmitter<((event: { source: Widget, fromElement: HTMLElement, toElement: HTMLElement, fromWidget: Widget, toWidget: Widget, backwards: boolean }) => void)|string>();\n    /**\n     * Fired when focus exits this Widget's ownership tree. This is different from a `blur` event.\n     * focus moving from within this Widget's ownership tree, even if there are floating widgets\n     * will not trigger this event. This is when focus exits this widget completely.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source This Widget\n     * @param {HTMLElement} event.fromElement The element which lost focus.\n     * @param {HTMLElement} event.toElement The element which gained focus.\n     * @param {Core.widget.Widget} event.fromWidget The widget which lost focus.\n     * @param {Core.widget.Widget} event.toWidget The widget which gained focus.\n     * @param {boolean} event.backwards `true` if the `toElement` is before the `fromElement` in document order.\n     */\n    @Output() onFocusOut: any = new EventEmitter<((event: { source: Widget, fromElement: HTMLElement, toElement: HTMLElement, fromWidget: Widget, toWidget: Widget, backwards: boolean }) => void)|string>();\n    /**\n     * Triggered after a widget was hidden\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget\n     */\n    @Output() onHide: any = new EventEmitter<((event: { source: Widget }) => void)|string>();\n    /**\n     * Fires when this DayView changes an aspect of its layout. This happens when changing\n     * [hourHeight](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#property-hourHeight), [minDayWidth](#Calendar/widget/DayView#property-minDayWidth), and when the available\n     * day container height changes.\n     * @param {object} event Event object\n     * @param {Calendar.widget.DayView} event.source The triggering instance.\n     */\n    @Output() onLayoutUpdate: any = new EventEmitter<((event: { source: DayView }) => void)|string>();\n    /**\n     * Triggered when a widget which had been in a non-visible state for any reason\n     * achieves visibility.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-paint)\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being painted.\n     * @param {boolean} event.firstPaint `true` if this is the first paint.\n     */\n    @Output() onPaint: any = new EventEmitter<((event: { source: Widget, firstPaint: boolean }) => void)|string>();\n    /**\n     * Fired when the range of dates encapsulated by this view changes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayResourceView#event-rangeChange)\n     * @param {object} event Event object\n     * @param {typeof DateRangeOwner} event.source This calendar view instance.\n     * @param {object} event.old The old date range <strong>if any</strong>.\n     * @param {Date} event.old.startDate the old start date.\n     * @param {Date} event.old.endDate the old end date.\n     * @param {object} event.new The new date range\n     * @param {Date} event.new.startDate the new start date.\n     * @param {Date} event.new.endDate the new end date.\n     */\n    @Output() onRangeChange: any = new EventEmitter<((event: { source: typeof DateRangeOwner, old: { startDate: Date, endDate: Date }, new: { startDate: Date, endDate: Date } }) => void)|string>();\n    /**\n     * Fired when a Widget's read only state is toggled\n     * @param {object} event Event object\n     * @param {boolean} event.readOnly Read only or not\n     */\n    @Output() onReadOnly: any = new EventEmitter<((event: { readOnly: boolean }) => void)|string>();\n    /**\n     * This event is fired after a widget's elements have been synchronized due to a direct or indirect call\n     * to [recompose](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.\n     */\n    @Output() onRecompose: any = new EventEmitter<(() => void)|string>();\n    /**\n     * Fires when this DayView refreshes.\n     * @param {object} event Event object\n     * @param {Calendar.widget.DayView} event.source The triggering instance.\n     */\n    @Output() onRefresh: any = new EventEmitter<((event: { source: DayView }) => void)|string>();\n    /**\n     * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-monitorResize) is `true`*.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source This Widget\n     * @param {number} event.width The new width\n     * @param {number} event.height The new height\n     * @param {number} event.oldWidth The old width\n     * @param {number} event.oldHeight The old height\n     */\n    @Output() onResize: any = new EventEmitter<((event: { source: Widget, width: number, height: number, oldWidth: number, oldHeight: number }) => void)|string>();\n    /**\n     * Triggered when a new [responsiveState](https://bryntum.com/products/calendar/docs/api/Core/widget/mixin/Responsive#config-responsiveState) is applied.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget whose `responsiveState` has changed\n     * @param {string} event.state The new value for the widget's `responsiveState`\n     * @param {string} event.oldState The previous value for the widget's `responsiveState`\n     */\n    @Output() onResponsiveStateChange: any = new EventEmitter<((event: { source: Widget, state: string, oldState: string }) => void)|string>();\n    /**\n     * Fired when the [shiftIncrement](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#property-shiftIncrement) of this view changes.\n     * @param {object} event Event object\n     * @param {object} event.old The shift increment *if any*.\n     * @param {object} event.new The shift increment\n     */\n    @Output() onShiftIncrementChange: any = new EventEmitter<((event: { old?: object, new: object }) => void)|string>();\n    /**\n     * Triggered after a widget is shown.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget\n     */\n    @Output() onShow: any = new EventEmitter<((event: { source: Widget }) => void)|string>();\n    /**\n     * Triggered when changing the [hourHeight](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#property-hourHeight) causes an\n     * [hour height breakpoint](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-hourHeightBreakpoints) to be crossed\n     * and the displayed subTick intervals in the time axis change.\n     * @param {object} event Event object\n     * @param {object} event.old The old hour height tick resolution object.\n     * @param {number} event.old.level The level `0` to `4` where `0` is the default with no subTick times displayed, and `4` means every 5 minute time is displayed.\n     * @param {string} event.old.step The time duration of visible subTicks. This is a string in the format required by [parseDuration](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper#function-parseDuration-static)\n     * @param {object} event.new The new hour height tick resolution object.\n     * @param {number} event.new.level The level `0` to `4` where `0` is the default with no subTick times displayed, and `4` means every 5 minute time is displayed.\n     * @param {string} event.new.step The time duration of visible subTicks. This is a string in the format required by [parseDuration](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper#function-parseDuration-static)\n     */\n    @Output() onTickChange: any = new EventEmitter<((event: { old: { level: number, step: string }, new: { level: number, step: string } }) => void)|string>();\n    /**\n     * Fired when a time axis is clicked on. If the handler returns\n     * `false` the current pointer event is not processed further.\n     * @param {object} event Event object\n     * @param {Event} event.domEvent The triggering DOM event.\n     * @param {Date} event.preciseTime The exact date and time at the clicked position\n     * @param {Date} event.time The date and time at the clicked position snapped according to the [increment](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#config-increment) and [timeSnapType](#Calendar/widget/DayView#config-timeSnapType)\n     */\n    @Output() onTimeAxisClick: any = new EventEmitter<((event: { domEvent: Event, preciseTime: Date, time: Date }) => void)|string>();\n    /**\n     * A header [tool](https://bryntum.com/products/calendar/docs/api/Core/widget/Panel#config-tools) has been clicked.\n     * @param {object} event Event object\n     * @param {Core.widget.Tool} event.source This Panel.\n     * @param {Core.widget.Tool} event.tool The tool which is being clicked.\n     */\n    @Output() onToolClick: any = new EventEmitter<((event: { source: Tool, tool: Tool }) => void)|string>();\n\n    /**\n     * Create and append the underlying widget\n     */\n    ngOnInit(): void {\n        const\n            me = this,\n            {\n                elementRef,\n                bryntumConfig\n            } = me,\n            {\n                instanceClass,\n                instanceName,\n                bryntumConfigs,\n                bryntumEvents\n            } = BryntumDayResourceViewComponent;\n\n        bryntumConfigs.filter(prop => prop in this).forEach(prop => {\n            // @ts-ignore\n            WrapperHelper.applyPropValue(bryntumConfig, prop, this[prop]);\n            if (['features', 'config'].includes(prop)) {\n                WrapperHelper.devWarningConfigProp(instanceName, prop);\n            }\n        });\n        // @ts-ignore\n        bryntumEvents.filter(event => this[event] && this[event].observers.length > 0).forEach(event => {\n            const\n                uncapitalize = (str: string) => str.charAt(0).toLowerCase() + str.slice(1),\n                eventName = (str: string) => uncapitalize(str.slice(2));\n\n            // @ts-ignore\n            bryntumConfig.listeners[eventName(event)] = e => {\n                // @ts-ignore\n                me[event].emit(e);\n                // EventEmitter does not return values in the normal way, work around it by setting `returnValue` flag\n                // in Angular listeners\n                return e.returnValue;\n            };\n        });\n\n        // If component has no container specified in config then use adopt to Wrapper's element\n        const\n            containerParam = [\n                'adopt',\n                'appendTo',\n                'insertAfter',\n                'insertBefore'\n                // @ts-ignore\n            ].find(prop => bryntumConfig[prop]);\n        if (!containerParam) {\n            if (instanceName === 'Button' || elementRef.nativeElement.getRootNode() instanceof ShadowRoot) {\n                // Button should always be <a> or <button> inside owner element\n                bryntumConfig.appendTo = elementRef.nativeElement;\n            }\n            else {\n                bryntumConfig.adopt = elementRef.nativeElement;\n            }\n        }\n        else {\n            WrapperHelper.devWarningContainer(instanceName, containerParam);\n        }\n\n        // @ts-ignore\n        me.instance = instanceName === 'Widget' ? Widget.create(bryntumConfig) : new instanceClass(bryntumConfig);\n\n    }\n\n    /**\n     * Watch for changes\n     * @param changes\n     */\n    ngOnChanges(changes: SimpleChanges): void {\n        const\n            { instance } = this,\n            { instanceName } = BryntumDayResourceViewComponent;\n        if (!instance) {\n            return;\n        }\n        // Iterate over all changes\n        Object.entries(changes).forEach(([prop, change]) => {\n            const\n                newValue = (change as SimpleChange).currentValue,\n                { instance } = this,\n                { bryntumConfigsOnly, bryntumProps } = BryntumDayResourceViewComponent;\n            if (bryntumProps.includes(prop)) {\n                WrapperHelper.applyPropValue(instance, prop, newValue, false);\n                if (bryntumConfigsOnly.includes(prop)) {\n                    WrapperHelper.devWarningUpdateProp(instanceName, prop);\n                }\n            }\n        });\n    }\n\n    /**\n     * Destroy the component\n     */\n    ngOnDestroy(): void {\n        // @ts-ignore\n        if (this.instance && this.instance.destroy) {\n            this.instance.destroy();\n        }\n    }\n}\n"]}