@bryntum/calendar-angular-thin 7.1.1

package/esm2015/lib/bryntum-calendar.component.js

@@ -0,0 +1,2355 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Angular wrapper for Bryntum Calendar
+ */
+import { Component, EventEmitter, Output, Input } from '@angular/core';
+import WrapperHelper from './wrapper.helper';
+import { Widget } from '@bryntum/core-thin';
+import { Calendar } from '@bryntum/calendar-thin';
+import { StringHelper } from '@bryntum/core-thin';
+import * as i0 from "@angular/core";
+export class BryntumCalendarComponent {
+    constructor(element) {
+        this.bryntumConfig = {
+            adopt: undefined,
+            appendTo: undefined,
+            href: undefined,
+            angularComponent: this,
+            features: {},
+            listeners: {}
+        };
+        // Events emitters
+        /**
+         * Fired when a change of view (Calendar mode) has completed. By default, view changes are animated and this
+         * event fires when the view is fully visible.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar instance.
+         * @param {CalendarView} event.prevActiveItem The previously active view.
+         * @param {CalendarView} event.activeItem The new active view.
+         * @param {boolean} event.containedFocus `true` if the outgoing view contained focus.
+         */
+        this.onActiveItemChange = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler after editor is closed by any action - save, delete or cancel
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source The scheduler
+         * @param {'save','delete','cancel'} event.action The action that was taken to end the edit. One of 'save', 'delete' or 'cancel'
+         * @param {Scheduler.feature.SchedulerEventEdit} event.eventEdit The eventEdit feature
+         * @param {Scheduler.model.EventModel} event.eventRecord The record that has been edited.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The Resource record for the event. If the event is being created, it will not contain a resource, so this parameter specifies the resource the event is being created for.
+         * @param {HTMLElement} event.eventElement The element which represents the event in the scheduler display.
+         * @param {Core.widget.Popup} event.editor The editor
+         */
+        this.onAfterEventEdit = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler after an event is successfully saved
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source The scheduler instance
+         * @param {Scheduler.model.EventModel} event.eventRecord The record about to be saved
+         */
+        this.onAfterEventSave = new EventEmitter();
+        /**
+         * Fired before a change of view (Calendar mode) is initiated.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar instance.
+         * @param {CalendarView} event.prevActiveItem The previously active view.
+         * @param {CalendarView} event.activeItem The new active view.
+         */
+        this.onBeforeActiveItemChange = new EventEmitter();
+        /**
+         * Fires before an assignment is removed. Can be triggered by user pressing [DELETE] or [BACKSPACE] or
+         * by the event editor. Can for example be used to display a custom dialog to confirm deletion, in which
+         * case records should be "manually" removed after confirmation:
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeAssignmentDelete)
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source The Scheduler instance
+         * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment records about to be deleted
+         * @param {object} event.context Additional removal context:
+         * @param {Function} event.context.finalize Function to call to finalize the removal. Used to asynchronously decide to remove the records or not. Provide `false` to the function to prevent the removal.
+         * @param {boolean} event.context.finalize.removeRecords Provide `false` to the function to prevent the removal.
+         */
+        this.onBeforeAssignmentDelete = new EventEmitter();
+        /**
+         * Fired any time there is going to be a change to the assignments selected in the Scheduler.
+         * Returning `false` prevents the change
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source This Scheduler instance.
+         * @param {'select','deselect','update','clear'} event.action One of the actions 'select', 'deselect', 'update', 'clear'
+         * @param {Scheduler.model.AssignmentModel[]} event.selected An array of assignments that will be added to the selection.
+         * @param {Scheduler.model.AssignmentModel[]} event.deselected An array of assignments that will be removed from the selection.
+         * @param {Scheduler.model.AssignmentModel[]} event.selection The currently selected assignments, before applying `selected` and `deselected`.
+         */
+        this.onBeforeAssignmentSelectionChange = new EventEmitter();
+        /**
+         * This event fires whenever a child view's [autoCreate gesture](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate) is detected and also when a [drag-create](#Calendar/feature/CalendarDrag) gesture is detected.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeAutoCreate)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The child view on which the event was initiated.
+         * @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.
+         */
+        this.onBeforeAutoCreate = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler before a copy action is performed, return `false` to prevent the action
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Owner scheduler
+         * @param {Scheduler.model.EventModel[]} event.eventRecords The event records about to be copied
+         * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment records about to be copied
+         * @param {boolean} event.isCut `true` if this is a cut action
+         * @param {string} event.entityName 'event' to distinguish this event from other beforeCopy events
+         */
+        this.onBeforeCopy = new EventEmitter();
+        /**
+         * Fires before a mode is created. The configuration block is passed to the handler for possible modification.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar
+         * @param {AgendaViewConfig,DayResourceViewConfig,DayViewConfig,EventListConfig,MonthViewConfig,ResourceViewConfig,WeekViewConfig,YearViewConfig,DayAgendaViewConfig,MonthAgendaViewConfig,CalendarContainerItemConfig} event.config The configuration block of the mode about to be created. Any property, including the `type` may be changed.
+         */
+        this.onBeforeCreateMode = new EventEmitter();
+        /**
+         * Fires on the owning Grid before CSV export starts. Return `false` to cancel the export.
+         * @param {object} event Event object
+         * @param {ExportConfig} event.config Export config
+         * @param {Grid.column.Column[]} event.columns An array of columns to export
+         * @param {Core.data.Model[]} event.rows An array of records to export
+         * @param {string} event.lineDelimiter The CSV delimiter to separate lines
+         * @param {string} event.columnDelimiter The CSV delimiter to separate values on one line
+         */
+        this.onBeforeCSVExport = 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();
+        /**
+         * This event fires on the owning Calendar before a drag creation gesture is started. Return `false` to
+         * veto the operation.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag create context.
+         * @param {Event} event.domEvent The browser event.
+         * @param {Date} event.date The date at the drag DOM event position.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {CalendarView} event.view The Calendar widget in which the drag is being started.
+         */
+        this.onBeforeDragCreate = new EventEmitter();
+        /**
+         * This event fires on the owning Calendar before a drag creation gesture is completed. Return `false` to
+         * immediately veto the operation or a Promise yielding `true` or `false` for async vetoing.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag create context.
+         * @param {Event} event.event The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record being created that has not yet been added in the store.
+         * @param {Date} event.newStartDate The new start date.
+         * @param {Date} event.newEndDate The new end date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {boolean,ValidateCreateResult} event.validation The result of the [validateCreateFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateCreateFn) if one was provided.
+         * @param {CalendarView} event.view The Calendar widget in which the drag completed.
+         */
+        this.onBeforeDragCreateEnd = new EventEmitter();
+        /**
+         * This event fires on the owning Calendar before a drag move gesture is started. Return `false` to
+         * veto the operation.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag move context.
+         * @param {Event} event.domEvent The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record being moved.
+         * @param {Date} event.date The date at the drag DOM event position.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {CalendarView} event.view The Calendar widget in which the drag is being started.
+         */
+        this.onBeforeDragMove = new EventEmitter();
+        /**
+         * This event fires on the owning Calendar before a drag move gesture is completed. Return `false` to immediately veto the operation
+         * or a Promise yielding `true` or `false` for async vetoing.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag create context.
+         * @param {Event} event.event The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record that has *not yet been updated* in the store.
+         * @param {Scheduler.model.EventModel} event.proxyEventRecord The `EventModel` record that is being used as a proxy for the drag operation and being updated on every pointer move. This will contain changed values based on the drag position.
+         * @param {Date} event.newStartDate The new start date.
+         * @param {Date} event.newEndDate The new end date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {boolean,ValidateCreateResult} event.validation The result of the [validateMoveFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateMoveFn) if one was provided.
+         * @param {CalendarView} event.view The Calendar widget in which the drag completed.
+         */
+        this.onBeforeDragMoveEnd = new EventEmitter();
+        /**
+         * This event fires on the owning Calendar before a drag resize gesture is started. Return `false` to
+         * veto the operation.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag resize context.
+         * @param {Event} event.domEvent The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record being resized.
+         * @param {Date} event.date The date at the drag DOM event position.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {CalendarView} event.view The Calendar widget in which the drag is being started.
+         */
+        this.onBeforeDragResize = new EventEmitter();
+        /**
+         * This event fires on the owning Calendar before a drag resize gesture is completed. Return `false` to immediately veto the operation
+         * or a Promise yielding `true` or `false` for async vetoing.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag create context.
+         * @param {Event} event.event The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record that has *not yet been updated* in the store.
+         * @param {Scheduler.model.EventModel} event.proxyEventRecord The `EventModel` record that is being used as a proxy for the drag operation and being updated on every pointer move. This will contain changed values based on the drag position.
+         * @param {Date} event.newStartDate The new start date.
+         * @param {Date} event.newEndDate The new end date.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {boolean,ValidateCreateResult} event.validation The result of the [validateResizeFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateResizeFn) if one was provided.
+         * @param {CalendarView} event.view The Calendar widget in which the drag completed.
+         */
+        this.onBeforeDragResizeEnd = new EventEmitter();
+        /**
+         * This event is fired on the owning Calendar when dropping an event from the calendar on the
+         * external source <strong>if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) was configured</strong>. Returning `false`
+         * prevents the gesture from being completed.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeDropExternal)
+         * @param {object} event Event object
+         * @param {Scheduler.model.EventModel} event.eventRecord The event record being dragged.
+         * @param {boolean} event.dropOnCalendar `true` if the drop gesture is over the client Calendar. This feature also allows drag *out* of the Calendar and onto the external event source if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) config is set.
+         * @param {HTMLElement} event.itemElement The element in which the drag gesture started.
+         * @param {HTMLElement} event.targetElement The current over element.
+         * @param {Event} event.domEvent The pointer event associated with the drag point.
+         * @param {number} event.overIndex *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the index of the row being moved over;
+         * @param {Core.data.Model} event.overRecord *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the record being moved over;
+         * @param {boolean} event.isAbove *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, `true` if the pointer position is above the halfway line of the over row.
+         * @param {boolean} event.altKey `true` if the Alt key was down when the last event was processed.
+         * @param {boolean} event.ctrlKey `true` if the Ctrl key was down when the last event was processed.
+         * @param {boolean} event.metaKey `true` if the Meta key was down when the last event was processed.
+         * @param {boolean} event.shiftKey `true` if the Shift key was down when the last event was processed.
+         */
+        this.onBeforeDropExternal = new EventEmitter();
+        /**
+         * Fires before an event is removed. Can be triggered by user pressing [DELETE] or [BACKSPACE] or by the
+         * event editor. Can for example be used to display a custom dialog to confirm deletion, in which case
+         * records should be "manually" removed after confirmation:
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeEventDelete)
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance
+         * @param {Scheduler.model.EventModel[]} event.eventRecords The records about to be deleted
+         * @param {object} event.context Additional removal context:
+         * @param {Function} event.context.finalize Function to call to finalize the removal. Used to asynchronously decide to remove the records or not. Provide `false` to the function to prevent the removal.
+         * @param {boolean} event.context.finalize.removeRecords Provide `false` to the function to prevent the removal.
+         */
+        this.onBeforeEventDelete = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler before an event is displayed in an editor.
+         * This may be listened for to allow an application to take over event editing duties. Returning `false`
+         * stops the default editing UI from being shown.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeEventEdit)
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source The scheduler
+         * @param {Scheduler.feature.SchedulerEventEdit} event.eventEdit The eventEdit feature
+         * @param {Scheduler.model.EventModel} event.eventRecord The record about to be shown in the event editor.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The Resource record for the event. If the event is being created, it will not contain a resource, so this parameter specifies the resource the event is being created for.
+         * @param {HTMLElement} event.eventElement The element which represents the event in the scheduler display.
+         */
+        this.onBeforeEventEdit = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler when the editor for an event is available but before it is populated with
+         * data and shown. Allows manipulating fields etc.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source The scheduler
+         * @param {Scheduler.feature.SchedulerEventEdit} event.eventEdit The eventEdit feature
+         * @param {Scheduler.model.EventModel} event.eventRecord The record about to be shown in the event editor.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The Resource record for the event. If the event is being created, it will not contain a resource, so this parameter specifies the resource the event is being created for.
+         * @param {HTMLElement} event.eventElement The element which represents the event in the scheduler display.
+         * @param {Core.widget.Popup} event.editor The editor
+         */
+        this.onBeforeEventEditShow = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler before an event is saved.
+         * Return `false` to immediately prevent saving
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeEventSave)
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source The scheduler instance
+         * @param {Scheduler.model.EventModel} event.eventRecord The record about to be saved
+         * @param {Scheduler.model.ResourceModel[]} event.resourceRecords The resources to which the event is assigned
+         * @param {object} event.values The new values
+         * @param {object} event.context Extended save context:
+         * @param {boolean} event.context.async Set this to `true` in a listener to indicate that the listener will asynchronously decide to prevent or not the event save.
+         * @param {Function} event.context.finalize Function to call to finalize the save. Used when `async` is `true`. Provide `false` to the function to prevent the save.
+         */
+        this.onBeforeEventSave = new EventEmitter();
+        /**
+         * Fired any time there is going to be a change to the events selected in the Scheduler.
+         * Returning `false` prevents the change
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source This Scheduler instance.
+         * @param {'select','deselect','update','clear'} event.action One of the actions 'select', 'deselect', 'update', 'clear'
+         * @param {Scheduler.model.EventModel[]} event.selected An array of events that will be added to the selection.
+         * @param {Scheduler.model.EventModel[]} event.deselected An array of events that will be removed from the selection.
+         * @param {Scheduler.model.EventModel[]} event.selection The currently selected events, before applying `selected` and `deselected`.
+         */
+        this.onBeforeEventSelectionChange = new EventEmitter();
+        /**
+         * Fires on the owning Grid before Excel export starts. Return `false` to cancel the export.
+         * @param {object} event Event object
+         * @param {ExportConfig} event.config Export config
+         * @param {XLSColumn[]} event.columns An array of columns to export
+         * @param {any[][]} event.rows An array of records to export
+         */
+        this.onBeforeExcelExport = 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();
+        /**
+         * Fires on the owning Scheduler before a paste action is performed, return `false` to prevent the action.
+         * Depending on if the EventStore is using [singleAssignment](https://bryntum.com/products/calendar/docs/api/Scheduler/data/EventStore#config-singleAssignment) or the
+         * configuration of [copyPasteAction](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/EventCopyPaste#config-copyPasteAction), either the `eventRecords` or the `assignmentRecords` param
+         * will be populated with record copies.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Owner scheduler
+         * @param {Scheduler.model.EventModel[]} event.eventRecords The events about to be pasted
+         * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignments about to be pasted
+         * @param {Scheduler.model.EventModel[]} event.originalEventRecords The original event records
+         * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecords The original assignment record
+         * @param {Date} event.date The date when the pasted events will be scheduled
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The target resource record, the clipboard event records will be assigned to this resource.
+         * @param {boolean} event.isCut `true` if this is a cut action
+         * @param {string} event.entityName 'event' to distinguish this event from other beforePaste events
+         */
+        this.onBeforePaste = new EventEmitter();
+        /**
+         * Fires on the owning Calendar before print starts. Return `false` to cancel the print.
+         * @param {object} event Event object
+         * @param {object} event.config Print config
+         */
+        this.onBeforePrint = 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/view/Calendar#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();
+        /**
+         * Fires when a cell overflow indicator is clicked or activated by the <kbd>ENTER</kbd> key in any view. This will include
+         * the cells of a [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView) and the `+ n more` overflow
+         * indicator of cells in a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView), and "all day" events section
+         * of a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView).
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date clicked on.
+         */
+        this.onCellOverflowClick = 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();
+        /**
+         * This event fires on the owning widget when an item is selected in the context menu.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The owning widget
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         */
+        this.onContextMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning widget when a check item is toggled in the context menu.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The owning widget
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {boolean} event.checked Checked or not
+         */
+        this.onContextMenuToggleItem = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler after a copy action is performed. Depending on if the EventStore is using
+         * [singleAssignment](https://bryntum.com/products/calendar/docs/api/Scheduler/data/EventStore#config-singleAssignment) or the configuration of
+         * [copyPasteAction](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/EventCopyPaste#config-copyPasteAction), either the `eventRecords` or the `assignmentRecords` param will be populated
+         * with record copies.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Owner scheduler
+         * @param {Scheduler.model.EventModel[]} event.eventRecords The event record copies
+         * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment record copies
+         * @param {Scheduler.model.EventModel[]} event.originalEventRecords The event records that were copied
+         * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecord The assignment records that were copied
+         * @param {boolean} event.isCut `true` if this is a cut action
+         * @param {string} event.entityName 'event' to distinguish this event from other copy events
+         */
+        this.onCopy = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler/Gantt when the line indicating the current time is updated (see [currentTimeLineUpdateInterval](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/TimeRanges#config-currentTimeLineUpdateInterval)).
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source The scheduler
+         * @param {Date} event.date The current date
+         */
+        this.onCurrentTimelineUpdate = new EventEmitter();
+        /**
+         * Fired when data in any of the projects stores changes.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dataChange)
+         * @param {object} event Event object
+         * @param {typeof Scheduler.data.mixin.ProjectConsumer,any} event.source Owning component
+         * @param {typeof Scheduler.model.mixin.ProjectModelMixin,any} event.project Project model
+         * @param {Core.data.Store} event.store Affected store
+         * @param {'remove','removeAll','add','clearchanges','filter','update','dataset','replace'} event.action Name of action which triggered the change. May be one of:  * `'remove'` * `'removeAll'` * `'add'` * `'clearchanges'` * `'filter'` * `'update'` * `'dataset'` * `'replace'`
+         * @param {Core.data.Model} event.record Changed record, for actions that affects exactly one record (`'update'`)
+         * @param {Core.data.Model[]} event.records Changed records, passed for all actions except `'removeAll'`
+         * @param {object} event.changes Passed for the `'update'` action, info on which record fields changed
+         */
+        this.onDataChange = new EventEmitter();
+        /**
+         * Fires when the calendar changes the date that it orientates its views around.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dateChange)
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar.
+         * @param {Date} event.oldDate The previous Calendar date.
+         * @param {Date} event.date The new Calendar date.
+         */
+        this.onDateChange = new EventEmitter();
+        /**
+         * Fired when the eventStore is queried for events by date range, and the date range
+         * requested is different from the last time the store was queried.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dateRangeChange)
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar instance
+         * @param {object} event.old The old date range
+         * @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.onDateRangeChange = new EventEmitter();
+        /**
+         * Fires when the [LoadOnDemand](https://bryntum.com/products/calendar/docs/api/Calendar/feature/LoadOnDemand) feature has loaded a range of events.
+         * @param {object} event Event object
+         * @param {object} event.response The decoded JSON response.
+         * @param {object} event.options The options object passed into the CrudManager [CrudManager](https://bryntum.com/products/calendar/docs/api/Scheduler/data/CrudManager) [load](https://bryntum.com/products/calendar/docs/api/Scheduler/crud/AbstractCrudManagerMixin#function-load) method.
+         * @param {Date} event.startDate The start date of the range to request.
+         * @param {Date} event.endDate The end date of the range to request. <strong>Note that Dates are timestamps</strong>.
+         */
+        this.onDateRangeLoad = new EventEmitter();
+        /**
+         * Fired <strong>every</strong> time the eventStore is queried for events by date range.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dateRangeRequested)
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar instance
+         * @param {object} event.old The old date range
+         * @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
+         * @param {boolean} event.changed `true` if the date range is different from the last time a request was made
+         */
+        this.onDateRangeRequested = new EventEmitter();
+        /**
+         * Fired by the active view 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/view/Calendar#event-dayCellPopulated)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @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 a day number is clicked or activated by the <kbd>ENTER</kbd> key in a view which shows day numbers.
+         * This will include the cells of a [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView), the cell header of cells
+         * in a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView), and the day header in a [DayView](#Calendar/widget/DayView).
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dayNumberClick)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date clicked on.
+         * @param {DayCell} event.cellData An object that contains data about the calendar cell for the date.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onDayNumberClick = 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();
+        /**
+         * This event fires on the owning Calendar when a drag creation gesture is completed.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag create context.
+         * @param {Event} event.event The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The new `EventModel` record added in the store.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {boolean,ValidateCreateResult} event.validation The result of the [validateCreateFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateCreateFn) if one was provided.
+         * @param {CalendarView} event.view The Calendar widget in which the drag completed.
+         */
+        this.onDragCreateEnd = new EventEmitter();
+        /**
+         * This event fires on the owning Calendar when a drag move gesture is completed. The `eventRecord` has already been added
+         * to the `eventStore` of the owning calendar.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag create context.
+         * @param {Event} event.event The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The updated `EventModel` record.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {boolean,ValidateCreateResult} event.validation The result of the [validateMoveFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateMoveFn) if one was provided.
+         * @param {CalendarView} event.view The Calendar widget in which the drag completed.
+         */
+        this.onDragMoveEnd = new EventEmitter();
+        /**
+         * This event is fired on the owning Calendar when dragging an event from the calendar over the
+         * external source <strong>if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) was configured</strong>.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dragMoveExternal)
+         * @param {object} event Event object
+         * @param {Scheduler.model.EventModel} event.eventRecord The event record being dragged.
+         * @param {HTMLElement} event.itemElement The element in which the drag gesture started.
+         * @param {HTMLElement} event.targetElement The current over element.
+         * @param {Event} event.domEvent The pointer event associated with the drag point.
+         * @param {number} event.overIndex *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the index of the row being moved over;
+         * @param {Core.data.Model} event.overRecord *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the record being moved over;
+         * @param {boolean} event.isAbove *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, `true` if the pointer position is above the halfway line of the over row.
+         * @param {boolean} event.altKey `true` if the Alt key was down when the last event was processed.
+         * @param {boolean} event.ctrlKey `true` if the Ctrl key was down when the last event was processed.
+         * @param {boolean} event.metaKey `true` if the Meta key was down when the last event was processed.
+         * @param {boolean} event.shiftKey `true` if the Shift key was down when the last event was processed.
+         */
+        this.onDragMoveExternal = new EventEmitter();
+        /**
+         * This event fires on the owning Calendar when a drag resize gesture is completed.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.
+         * @param {Core.util.drag.DragContext} event.drag The drag create context.
+         * @param {Event} event.event The browser event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The updated `EventModel` record.
+         * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.
+         * @param {boolean,ValidateCreateResult} event.validation The result of the [validateResizeFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateResizeFn) if one was provided.
+         * @param {CalendarView} event.view The Calendar widget in which the drag completed.
+         */
+        this.onDragResizeEnd = new EventEmitter();
+        /**
+         * This event is fired on the owning Calendar after dropping an event from the calendar on the
+         * external source has been completed <strong>if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) was configured</strong>.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dropExternal)
+         * @param {object} event Event object
+         * @param {Scheduler.model.EventModel} event.eventRecord The event record that was dropped.
+         * @param {boolean} event.dropOnCalendar `true` if the drop gesture is over the client Calendar. This feature also allows drag *out* of the Calendar and onto the external event source if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) config is set.
+         * @param {HTMLElement} event.itemElement The element in which the drag gesture started.
+         * @param {HTMLElement} event.targetElement The current over element.
+         * @param {Event} event.domEvent The pointer event associated with the drag point.
+         * @param {number} event.overIndex *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the index of the row being moved over;
+         * @param {Core.data.Model} event.overRecord *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the record being moved over;
+         * @param {boolean} event.isAbove *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, `true` if the pointer position is above the halfway line of the over row.
+         * @param {boolean} event.altKey `true` if the Alt key was down when the last event was processed.
+         * @param {boolean} event.ctrlKey `true` if the Ctrl key was down when the last event was processed.
+         * @param {boolean} event.metaKey `true` if the Meta key was down when the last event was processed.
+         * @param {boolean} event.shiftKey `true` if the Shift key was down when the last event was processed.
+         */
+        this.onDropExternal = 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 empty cell content area is clicked on in a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView) or a
+         * [CalendarRow](https://bryntum.com/products/calendar/docs/api/Calendar/widget/CalendarRow).
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The child view on which the event was initiated.
+         * @param {Event} event.domEvent The triggering DOM event.
+         * @param {Date} event.date The date which has no visible events
+         */
+        this.onEmptyCellClick = 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/view/Calendar#event-eventAutoCreated)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The child view on which the event was initiated.
+         * @param {Scheduler.model.EventModel} event.eventRecord The new event record.
+         */
+        this.onEventAutoCreated = new EventEmitter();
+        /**
+         * Fires when an event bar is clicked in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event clicked on.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource clicked on if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventClick = new EventEmitter();
+        /**
+         * Fires when an event bar is right-clicked in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event right-clicked on.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource right-clicked on if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventContextMenu = new EventEmitter();
+        /**
+         * Fires when an event bar is double clicked in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event double clicked on.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource double clicked on if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventDblClick = new EventEmitter();
+        /**
+         * Fired before the editor will load the event record data into its input fields. This is useful if you
+         * want to modify the fields 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 editor widget
+         * @param {Scheduler.model.EventModel} event.record The record
+         */
+        this.onEventEditBeforeSetRecord = new EventEmitter();
+        /**
+         * Fires when a key is pressed while an event bar is focused.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event in which the key event was detected.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource in which the key event was detected if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventKeyDown = new EventEmitter();
+        /**
+         * This event fires on the owning Scheduler before the context menu is shown for an event. Allows manipulation of the items
+         * to show in the same way as in `processItems`. Returning `false` from a listener prevents the menu from
+         * being shown.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {Scheduler.model.EventModel} event.eventRecord Event record for which the menu was triggered
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord Resource record
+         * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used
+         * @param {HTMLElement} event.eventElement
+         * @param {MouseEvent} event.event Pointer event which triggered the context menu (if any)
+         */
+        this.onEventMenuBeforeShow = new EventEmitter();
+        /**
+         * This event fires on the owning Scheduler when an item is selected in the context menu.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source
+         * @param {Core.widget.MenuItem} event.item
+         * @param {Scheduler.model.EventModel} event.eventRecord
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord
+         * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used
+         * @param {HTMLElement} event.eventElement
+         */
+        this.onEventMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning Scheduler after showing the context menu for an event
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Scheduler.model.EventModel} event.eventRecord Event record for which the menu was triggered
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord Resource record
+         * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used
+         * @param {HTMLElement} event.eventElement
+         */
+        this.onEventMenuShow = new EventEmitter();
+        /**
+         * Fires when an event bar is mousedowned in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event mousedowned on.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mousedowned on if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventMouseDown = new EventEmitter();
+        /**
+         * Fires when cursor enters an event bar in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event record.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventMouseEnter = new EventEmitter();
+        /**
+         * Fires when cursor leaves an event bar in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event record.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventMouseLeave = new EventEmitter();
+        /**
+         * Fires when an event bar is mouseouted in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event mouseouted.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mouseouted if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventMouseOut = new EventEmitter();
+        /**
+         * Fires when an event bar is mouseovered in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event mouseovered.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mouseovered if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventMouseOver = new EventEmitter();
+        /**
+         * Fires when an event bar is mouseupped in any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement The UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord The event mouseupped.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mouseupped if the UI includes a resource.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onEventMouseUp = 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/view/Calendar#event-eventPropagate)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @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 the [LoadOnDemand](https://bryntum.com/products/calendar/docs/api/Calendar/feature/LoadOnDemand) feature detects that a request
+         * for data from the server has failed.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-loadOnDemandFail)
+         * @param {object} event Event object
+         * @param {Response} event.rawResponse The HTTP `fetch` response object.
+         * @param {object} event.request The CrudManager load data block.
+         * @param {object} event.response The decoded JSON response.
+         */
+        this.onLoadOnDemandFail = new EventEmitter();
+        /**
+         * Fires when a month name header in a [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView) or a [MonthGrid](#Calendar/widget/MonthGrid) is clicked
+         * or activated by the <kbd>ENTER</kbd> key.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-monthNameClick)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {number} event.month The month index *(zero based)* clicked on.
+         * @param {Date} event.date The date of the first of the month clicked on.
+         */
+        this.onMonthNameClick = new EventEmitter();
+        /**
+         * Fired when a user gesture causes the active item to change.
+         * @param {object} event Event object
+         * @param {Event} event.event The browser event which instigated navigation. May be a click or key or focus event.
+         * @param {HTMLElement,null} event.item The newly active item, or `null` if focus moved out.
+         * @param {HTMLElement,null} event.oldItem The previously active item, or `null` if focus is moving in.
+         */
+        this.onNavigate = 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/view/Calendar#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();
+        /**
+         * Fires on the owning Scheduler after a paste action is performed.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Owner scheduler
+         * @param {Scheduler.model.EventModel[]} event.eventRecords The pasted event records
+         * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The pasted assignment records
+         * @param {Scheduler.model.EventModel[]} event.pastedEventRecords (DEPRECATED) Use eventRecords instead
+         * @param {Scheduler.model.EventModel[]} event.originalEventRecords The original copied event records
+         * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecords The original copied assignment records
+         * @param {Date} event.date date Pasted to this date
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The target resource record
+         * @param {boolean} event.isCut `true` if this is a cut action
+         * @param {string} event.entityName 'event' to distinguish this event from other paste events
+         */
+        this.onPaste = new EventEmitter();
+        /**
+         * Fires on the owning Scheduler if a paste action is not allowed. Depending on if the EventStore is using
+         * [singleAssignment](https://bryntum.com/products/calendar/docs/api/Scheduler/data/EventStore#config-singleAssignment) or the configuration of
+         * [copyPasteAction](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/EventCopyPaste#config-copyPasteAction), either the `eventRecords` or the `assignmentRecords` param will be populated
+         * with record copies.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Owner scheduler
+         * @param {Scheduler.model.EventModel[]} event.eventRecords The event records about to be pasted
+         * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment records about to be pasted
+         * @param {Scheduler.model.EventModel[]} event.originalEventRecords The event records that were copied
+         * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecords The assignment records that were copied
+         * @param {Date} event.date The paste date
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The target resource record
+         * @param {boolean} event.isCut `true` if this is a cut action
+         * @param {string} event.entityName 'event' to distinguish this event from other `pasteNotAllowed` events
+         * @param {'overlappingEvents','resourceReadOnly'} event.reason A string id to use for displaying an error message to the user.
+         */
+        this.onPasteNotAllowed = 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 one of the views in this Calendar refreshes.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which refreshed.
+         */
+        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();
+        /**
+         * Fires when a click event is received by a view which supports resources.
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-resourceClick)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date of the UI element which contains the event.
+         * @param {HTMLElement} event.eventElement *If* an event was interacted with, the UI element which represents the event.
+         * @param {Scheduler.model.EventModel} event.eventRecord *If* an event was interacted with.
+         * @param {HTMLElement} event.resourceElement The UI element which encapsulates the resource.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the target element.
+         * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).
+         */
+        this.onResourceClick = 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();
+        /**
+         * Fires when a click made its way through to an empty part of any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date clicked on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.
+         */
+        this.onScheduleClick = new EventEmitter();
+        /**
+         * Fires when a context menu made its way through to an empty part of any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date clicked on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.
+         */
+        this.onScheduleContextMenu = new EventEmitter();
+        /**
+         * Fires when a dblclick made its way through to an empty part of any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date double clicked on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.
+         */
+        this.onScheduleDblClick = new EventEmitter();
+        /**
+         * This event fires on the owning Scheduler or Gantt widget before the context menu is shown for the schedule.
+         * Allows manipulation of the items to show in the same way as in `processItems`. Returning `false` from a listener
+         * prevents the menu from being shown.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord Resource record
+         * @param {Date} event.date Clicked date, rounded according to viewPreset's settings
+         * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used
+         * @param {HTMLElement} event.eventElement
+         */
+        this.onScheduleMenuBeforeShow = new EventEmitter();
+        /**
+         * This event fires on the owning Scheduler or Gantt widget when an item is selected in the context menu.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source
+         * @param {Core.widget.MenuItem} event.item
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord
+         * @param {Date} event.date Clicked date, rounded according to viewPreset's settings
+         * @param {HTMLElement} event.element
+         */
+        this.onScheduleMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning Scheduler or Gantt widget after showing the context menu for the schedule.
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord
+         * @param {Date} event.date Clicked date, rounded according to viewPreset's settings
+         * @param {HTMLElement} event.targetElement
+         */
+        this.onScheduleMenuShow = new EventEmitter();
+        /**
+         * Fires when a mousedown made its way through to an empty part of any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date mousedowned on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.
+         */
+        this.onScheduleMouseDown = new EventEmitter();
+        /**
+         * Fires when a mouseout made it's way through to an empty part of any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date mouseouted. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.
+         */
+        this.onScheduleMouseOut = new EventEmitter();
+        /**
+         * Fires when a mouseover made its way through to an empty part of any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date mouseovered. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.
+         */
+        this.onScheduleMouseOver = new EventEmitter();
+        /**
+         * Fires when a mouseup made its way through to an empty part of any view.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {Date} event.date The date mouseupped on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.
+         * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.
+         */
+        this.onScheduleMouseUp = new EventEmitter();
+        /**
+         * Fired any time there is a change to the events selected in the Calendar.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source The Calendar instance.
+         * @param {'select','deselect','update','clear'} event.action One of the actions 'select', 'deselect', 'update', 'clear'
+         * @param {Scheduler.model.EventModel[]} event.selected An array of the Events added to the selection.
+         * @param {Scheduler.model.EventModel[]} event.deselected An array of the Event removed from the selection.
+         * @param {Scheduler.model.EventModel[]} event.selection The new selection.
+         */
+        this.onSelectionChange = 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();
+        /**
+         * Fired when the sidebar is collapsed either through the UI or programatically.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar instance
+         */
+        this.onSidebarCollapse = new EventEmitter();
+        /**
+         * Fired when the sidebar is expanded either through the UI or programatically.
+         * @param {object} event Event object
+         * @param {Calendar.view.Calendar} event.source This Calendar instance
+         */
+        this.onSidebarExpand = new EventEmitter();
+        /**
+         * Fired when a time axis of a DayView or WeekView is clicked on. If the handler returns
+         * `false` the current pointer event is not processed further.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @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();
+        /**
+         * Fired on the owning Scheduler or Gantt widget when a click happens on a time range header element
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Scheduler instance
+         * @param {Scheduler.model.TimeSpan} event.timeRangeRecord The record
+         * @param {MouseEvent} event.domEvent Browser event
+         */
+        this.onTimeRangeHeaderClick = new EventEmitter();
+        /**
+         * Fired on the owning Scheduler or Gantt widget when a right click happens on a time range header element
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Scheduler instance
+         * @param {Scheduler.model.TimeSpan} event.timeRangeRecord The record
+         * @param {MouseEvent} event.domEvent Browser event
+         */
+        this.onTimeRangeHeaderContextMenu = new EventEmitter();
+        /**
+         * Fired on the owning Scheduler or Gantt widget when a double click happens on a time range header element
+         * @param {object} event Event object
+         * @param {Scheduler.view.Scheduler} event.source Scheduler instance
+         * @param {Scheduler.model.TimeSpan} event.timeRangeRecord The record
+         * @param {MouseEvent} event.domEvent Browser event
+         */
+        this.onTimeRangeHeaderDblClick = 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();
+        /**
+         * Fires when one of the child views is painted. That is when it becomes visible.
+         * Note that due to the slide-in animation, while the view is visible, it will not
+         * yet be in its final position.
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The widget being painted
+         * @param {boolean} event.firstPaint `true` if this is the first paint
+         */
+        this.onViewPaint = new EventEmitter();
+        /**
+         * Fires when a week number is clicked or activated by the <kbd>ENTER</kbd> key. This will include the week number cells of a
+         * [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView), the week number in the first cell
+         * in each row of a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView)
+         * ...
+         * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-weekNumberClick)
+         * @param {object} event Event object
+         * @param {CalendarView} event.source The view which triggered the event.
+         * @param {Event} event.domEvent The initiating DOM event.
+         * @param {number[]} event.week The `[year, week]` clicked on.
+         * @param {Date} event.date The date clicked on.
+         */
+        this.onWeekNumberClick = new EventEmitter();
+        this.elementRef = element;
+    }
+    /**
+     * Create and append the underlying widget
+     */
+    ngOnInit() {
+        const me = this, { elementRef, bryntumConfig } = me, { instanceClass, instanceName, bryntumConfigs, bryntumEvents } = BryntumCalendarComponent;
+        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);
+        // Backwards compatibility for gridInstance, schedulerInstance etc.
+        // @ts-ignore
+        me[StringHelper.uncapitalize(instanceName) + 'Instance'] = me.instance;
+        // 
+    }
+    /**
+     * Watch for changes
+     * @param changes
+     */
+    ngOnChanges(changes) {
+        const { instance } = this, { instanceName } = BryntumCalendarComponent;
+        if (!instance) {
+            return;
+        }
+        // Iterate over all changes
+        Object.entries(changes).forEach(([prop, change]) => {
+            const newValue = change.currentValue, { instance } = this, { bryntumConfigsOnly, bryntumProps } = BryntumCalendarComponent;
+            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();
+        }
+    }
+}
+BryntumCalendarComponent.instanceClass = Calendar;
+BryntumCalendarComponent.instanceName = 'Calendar';
+BryntumCalendarComponent.bryntumEvents = [
+    'onActiveItemChange',
+    'onAfterEventEdit',
+    'onAfterEventSave',
+    'onBeforeActiveItemChange',
+    'onBeforeAssignmentDelete',
+    'onBeforeAssignmentSelectionChange',
+    'onBeforeAutoCreate',
+    'onBeforeCopy',
+    'onBeforeCreateMode',
+    'onBeforeCSVExport',
+    'onBeforeDestroy',
+    'onBeforeDragCreate',
+    'onBeforeDragCreateEnd',
+    'onBeforeDragMove',
+    'onBeforeDragMoveEnd',
+    'onBeforeDragResize',
+    'onBeforeDragResizeEnd',
+    'onBeforeDropExternal',
+    'onBeforeEventDelete',
+    'onBeforeEventEdit',
+    'onBeforeEventEditShow',
+    'onBeforeEventSave',
+    'onBeforeEventSelectionChange',
+    'onBeforeExcelExport',
+    'onBeforeHide',
+    'onBeforePaste',
+    'onBeforePrint',
+    'onBeforeResponsiveStateChange',
+    'onBeforeSetRecord',
+    'onBeforeShow',
+    'onBeforeStateApply',
+    'onBeforeStateSave',
+    'onCatchAll',
+    'onCellOverflowClick',
+    'onCollapse',
+    'onContextMenuItem',
+    'onContextMenuToggleItem',
+    'onCopy',
+    'onCurrentTimelineUpdate',
+    'onDataChange',
+    'onDateChange',
+    'onDateRangeChange',
+    'onDateRangeLoad',
+    'onDateRangeRequested',
+    'onDayCellPopulated',
+    'onDayNumberClick',
+    'onDestroy',
+    'onDirtyStateChange',
+    'onDragCreateEnd',
+    'onDragMoveEnd',
+    'onDragMoveExternal',
+    'onDragResizeEnd',
+    'onDropExternal',
+    'onElementCreated',
+    'onEmptyCellClick',
+    'onEventAutoCreated',
+    'onEventClick',
+    'onEventContextMenu',
+    'onEventDblClick',
+    'onEventEditBeforeSetRecord',
+    'onEventKeyDown',
+    'onEventMenuBeforeShow',
+    'onEventMenuItem',
+    'onEventMenuShow',
+    'onEventMouseDown',
+    'onEventMouseEnter',
+    'onEventMouseLeave',
+    'onEventMouseOut',
+    'onEventMouseOver',
+    'onEventMouseUp',
+    'onEventPropagate',
+    'onExpand',
+    'onFocusIn',
+    'onFocusOut',
+    'onHide',
+    'onLoadOnDemandFail',
+    'onMonthNameClick',
+    'onNavigate',
+    'onPaint',
+    'onPaste',
+    'onPasteNotAllowed',
+    'onReadOnly',
+    'onRecompose',
+    'onRefresh',
+    'onResize',
+    'onResourceClick',
+    'onResponsiveStateChange',
+    'onScheduleClick',
+    'onScheduleContextMenu',
+    'onScheduleDblClick',
+    'onScheduleMenuBeforeShow',
+    'onScheduleMenuItem',
+    'onScheduleMenuShow',
+    'onScheduleMouseDown',
+    'onScheduleMouseOut',
+    'onScheduleMouseOver',
+    'onScheduleMouseUp',
+    'onSelectionChange',
+    'onShow',
+    'onSidebarCollapse',
+    'onSidebarExpand',
+    'onTimeAxisClick',
+    'onTimeRangeHeaderClick',
+    'onTimeRangeHeaderContextMenu',
+    'onTimeRangeHeaderDblClick',
+    'onToolClick',
+    'onViewPaint',
+    'onWeekNumberClick'
+];
+BryntumCalendarComponent.bryntumFeatureNames = [
+    'dragFeature',
+    'eventBufferFeature',
+    'eventCopyPasteFeature',
+    'eventEditFeature',
+    'eventMenuFeature',
+    'eventTooltipFeature',
+    'excelExporterFeature',
+    'externalEventSourceFeature',
+    'loadOnDemandFeature',
+    'printFeature',
+    'scheduleMenuFeature',
+    'scheduleTooltipFeature',
+    'timeRangesFeature',
+    'weekExpanderFeature'
+];
+BryntumCalendarComponent.bryntumConfigs = BryntumCalendarComponent.bryntumFeatureNames.concat([
+    'activeDateCls',
+    'adopt',
+    'align',
+    'alignSelf',
+    'anchor',
+    'appendTo',
+    'ariaDescription',
+    'ariaLabel',
+    'assignments',
+    'assignmentStore',
+    'autoCreate',
+    'bbar',
+    'bodyCls',
+    'bubbleEvents',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'centered',
+    'cls',
+    'collapsed',
+    'collapsible',
+    'color',
+    'column',
+    'config',
+    'constrainTo',
+    'contentElementCls',
+    'contextMenuTriggerEvent',
+    'crudManager',
+    'crudManagerClass',
+    'dataField',
+    'dataset',
+    'date',
+    'dateFormat',
+    'datePicker',
+    'defaultBindProperty',
+    'defaultCalendar',
+    'defaultFocus',
+    'defaults',
+    'deselectAllOnScheduleClick',
+    'deselectOnClick',
+    'destroyStores',
+    'detectCSSCompatibilityIssues',
+    'disabled',
+    'dock',
+    'draggable',
+    'drawer',
+    'elementAttributes',
+    'enableDeleteKey',
+    'enableRecurringEvents',
+    'enableUndoRedoKeys',
+    'events',
+    'eventSelectionDisabled',
+    'eventStore',
+    'extraData',
+    'filterEventResources',
+    'flex',
+    'floating',
+    'footer',
+    'header',
+    'height',
+    'hidden',
+    'hideAnimation',
+    'hideNonWorkingDays',
+    'hideWhenEmpty',
+    'highlightDate',
+    'highlightPredecessors',
+    'highlightSuccessors',
+    'icon',
+    'id',
+    'ignoreParentReadOnly',
+    'includeWeekendsButton',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'isEventSelectable',
+    'itemCls',
+    'items',
+    'keyMap',
+    'labelPosition',
+    'layout',
+    'layoutStyle',
+    'lazyItems',
+    'listeners',
+    'loadMask',
+    'loadMaskDefaults',
+    'loadMaskError',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'maintainSelectionOnDatasetChange',
+    'margin',
+    'maskDefaults',
+    'masked',
+    'maxDate',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minDate',
+    'minHeight',
+    'minWidth',
+    'mode',
+    'modeDefaults',
+    'modes',
+    'monitorResize',
+    'multiEventSelect',
+    'namedItems',
+    'navigatorPlacement',
+    'nonWorkingDays',
+    'overlaySidebar',
+    'owner',
+    'positioned',
+    'preventTooltipOnTouch',
+    'project',
+    'propagatedConfigs',
+    'readOnly',
+    'recurrenceConfirmationPopup',
+    'relayStoreEvents',
+    'rendition',
+    'resourceImagePath',
+    'resources',
+    'resourceStore',
+    'resourceTimeRanges',
+    'resourceTimeRangeStore',
+    'responsive',
+    'responsiveRoot',
+    'responsiveState',
+    'responsiveTarget',
+    'ripple',
+    'rootElement',
+    'rtl',
+    'scrollable',
+    'scrollAction',
+    'selectResourceOnEventNavigate',
+    'selectResourceOnScheduleClick',
+    'showAnimation',
+    'showRecurringUI',
+    'showTooltipWhenDisabled',
+    'sidebar',
+    'span',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'strictRecordMapping',
+    'strips',
+    'syncMask',
+    'tab',
+    'tabBarItems',
+    'tag',
+    'tbar',
+    'textAlign',
+    'timeRanges',
+    'timeRangeStore',
+    'timeZone',
+    'title',
+    'tools',
+    'tooltip',
+    'trapFocus',
+    'triggerSelectionChangeOnRemove',
+    'type',
+    'ui',
+    'useContextualRecurrenceRules',
+    'viewContainer',
+    'weekStartDay',
+    'weight',
+    'width',
+    'x',
+    'y'
+]);
+BryntumCalendarComponent.bryntumConfigsOnly = [
+    'adopt',
+    'align',
+    'anchor',
+    'ariaDescription',
+    'ariaLabel',
+    'assignmentStore',
+    'autoCreate',
+    'bbar',
+    'bodyCls',
+    'bubbleEvents',
+    'centered',
+    'collapsible',
+    'color',
+    'config',
+    'constrainTo',
+    'contentElementCls',
+    'contextMenuTriggerEvent',
+    'crudManagerClass',
+    'dataField',
+    'datePicker',
+    'defaultBindProperty',
+    'defaultFocus',
+    'defaults',
+    'deselectOnClick',
+    'destroyStores',
+    'detectCSSCompatibilityIssues',
+    'dock',
+    'draggable',
+    'drawer',
+    'elementAttributes',
+    'enableDeleteKey',
+    'enableRecurringEvents',
+    'enableUndoRedoKeys',
+    'eventSelectionDisabled',
+    'eventStore',
+    'filterEventResources',
+    'floating',
+    'footer',
+    'header',
+    'hideAnimation',
+    'hideWhenEmpty',
+    'highlightDate',
+    'highlightPredecessors',
+    'highlightSuccessors',
+    'icon',
+    'ignoreParentReadOnly',
+    'includeWeekendsButton',
+    'itemCls',
+    'lazyItems',
+    'listeners',
+    'loadMask',
+    'loadMaskDefaults',
+    'loadMaskError',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'maintainSelectionOnDatasetChange',
+    'maskDefaults',
+    'masked',
+    'monitorResize',
+    'multiEventSelect',
+    'namedItems',
+    'navigatorPlacement',
+    'overlaySidebar',
+    'owner',
+    'positioned',
+    'preventTooltipOnTouch',
+    'propagatedConfigs',
+    'relayStoreEvents',
+    'resourceImagePath',
+    'resourceStore',
+    'resourceTimeRangeStore',
+    'responsive',
+    'responsiveRoot',
+    'responsiveState',
+    'responsiveTarget',
+    'ripple',
+    'rootElement',
+    'scrollAction',
+    'showAnimation',
+    'showRecurringUI',
+    'showTooltipWhenDisabled',
+    'sidebar',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'strips',
+    'syncMask',
+    'tab',
+    'tabBarItems',
+    'tag',
+    'tbar',
+    'textAlign',
+    'timeRangeStore',
+    'timeZone',
+    'trapFocus',
+    'triggerSelectionChangeOnRemove',
+    'type',
+    'ui',
+    'viewContainer',
+    'weekStartDay',
+    'weight'
+];
+BryntumCalendarComponent.bryntumProps = BryntumCalendarComponent.bryntumFeatureNames.concat([
+    'activeDateCls',
+    'activeSubView',
+    'activeView',
+    'alignSelf',
+    'anchorSize',
+    'appendTo',
+    'assignments',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'cls',
+    'collapsed',
+    'column',
+    'crudManager',
+    'dataset',
+    'date',
+    'dateFormat',
+    'defaultCalendar',
+    'deselectAllOnScheduleClick',
+    'disabled',
+    'events',
+    'extraData',
+    'flex',
+    'focusVisible',
+    'hasChanges',
+    'height',
+    'hidden',
+    'hideNonWorkingDays',
+    'id',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'isEngineReady',
+    'isEventSelectable',
+    'isSettingValues',
+    'isValid',
+    'items',
+    'keyMap',
+    'labelPosition',
+    'layout',
+    'layoutStyle',
+    'margin',
+    'maxDate',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minDate',
+    'minHeight',
+    'minWidth',
+    'mode',
+    'modeDefaults',
+    'modes',
+    'nonWorkingDays',
+    'parent',
+    'project',
+    'readOnly',
+    'record',
+    'recurrenceConfirmationPopup',
+    'rendition',
+    'resources',
+    'resourceTimeRanges',
+    'rtl',
+    'scrollable',
+    'selectedEvents',
+    'selectResourceOnEventNavigate',
+    'selectResourceOnScheduleClick',
+    'span',
+    'state',
+    'strictRecordMapping',
+    'timeRanges',
+    'title',
+    'tools',
+    'tooltip',
+    'useContextualRecurrenceRules',
+    'values',
+    'views',
+    'width',
+    'x',
+    'y'
+]);
+BryntumCalendarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumCalendarComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+BryntumCalendarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.0", type: BryntumCalendarComponent, selector: "bryntum-calendar", inputs: { adopt: "adopt", align: "align", anchor: "anchor", ariaDescription: "ariaDescription", ariaLabel: "ariaLabel", assignmentStore: "assignmentStore", autoCreate: "autoCreate", bbar: "bbar", bodyCls: "bodyCls", bubbleEvents: "bubbleEvents", centered: "centered", collapsible: "collapsible", color: "color", config: "config", constrainTo: "constrainTo", contentElementCls: "contentElementCls", contextMenuTriggerEvent: "contextMenuTriggerEvent", crudManagerClass: "crudManagerClass", dataField: "dataField", datePicker: "datePicker", defaultBindProperty: "defaultBindProperty", defaultFocus: "defaultFocus", defaults: "defaults", deselectOnClick: "deselectOnClick", destroyStores: "destroyStores", detectCSSCompatibilityIssues: "detectCSSCompatibilityIssues", dock: "dock", draggable: "draggable", drawer: "drawer", elementAttributes: "elementAttributes", enableDeleteKey: "enableDeleteKey", enableRecurringEvents: "enableRecurringEvents", enableUndoRedoKeys: "enableUndoRedoKeys", eventSelectionDisabled: "eventSelectionDisabled", eventStore: "eventStore", filterEventResources: "filterEventResources", floating: "floating", footer: "footer", header: "header", hideAnimation: "hideAnimation", hideWhenEmpty: "hideWhenEmpty", highlightDate: "highlightDate", highlightPredecessors: "highlightPredecessors", highlightSuccessors: "highlightSuccessors", icon: "icon", ignoreParentReadOnly: "ignoreParentReadOnly", includeWeekendsButton: "includeWeekendsButton", itemCls: "itemCls", lazyItems: "lazyItems", listeners: "listeners", loadMask: "loadMask", loadMaskDefaults: "loadMaskDefaults", loadMaskError: "loadMaskError", localeClass: "localeClass", localizable: "localizable", localizableProperties: "localizableProperties", maintainSelectionOnDatasetChange: "maintainSelectionOnDatasetChange", maskDefaults: "maskDefaults", masked: "masked", monitorResize: "monitorResize", multiEventSelect: "multiEventSelect", namedItems: "namedItems", navigatorPlacement: "navigatorPlacement", overlaySidebar: "overlaySidebar", owner: "owner", positioned: "positioned", preventTooltipOnTouch: "preventTooltipOnTouch", propagatedConfigs: "propagatedConfigs", relayStoreEvents: "relayStoreEvents", resourceImagePath: "resourceImagePath", resourceStore: "resourceStore", resourceTimeRangeStore: "resourceTimeRangeStore", responsive: "responsive", responsiveRoot: "responsiveRoot", responsiveState: "responsiveState", responsiveTarget: "responsiveTarget", ripple: "ripple", rootElement: "rootElement", scrollAction: "scrollAction", showAnimation: "showAnimation", showRecurringUI: "showRecurringUI", showTooltipWhenDisabled: "showTooltipWhenDisabled", sidebar: "sidebar", stateful: "stateful", statefulEvents: "statefulEvents", stateId: "stateId", stateProvider: "stateProvider", strips: "strips", syncMask: "syncMask", tab: "tab", tabBarItems: "tabBarItems", tag: "tag", tbar: "tbar", textAlign: "textAlign", timeRangeStore: "timeRangeStore", timeZone: "timeZone", trapFocus: "trapFocus", triggerSelectionChangeOnRemove: "triggerSelectionChangeOnRemove", type: "type", ui: "ui", viewContainer: "viewContainer", weekStartDay: "weekStartDay", weight: "weight", activeDateCls: "activeDateCls", alignSelf: "alignSelf", appendTo: "appendTo", assignments: "assignments", callOnFunctions: "callOnFunctions", catchEventHandlerExceptions: "catchEventHandlerExceptions", cls: "cls", collapsed: "collapsed", column: "column", crudManager: "crudManager", dataset: "dataset", date: "date", dateFormat: "dateFormat", defaultCalendar: "defaultCalendar", deselectAllOnScheduleClick: "deselectAllOnScheduleClick", disabled: "disabled", events: "events", extraData: "extraData", flex: "flex", height: "height", hidden: "hidden", hideNonWorkingDays: "hideNonWorkingDays", id: "id", inputFieldAlign: "inputFieldAlign", insertBefore: "insertBefore", insertFirst: "insertFirst", isEventSelectable: "isEventSelectable", items: "items", keyMap: "keyMap", labelPosition: "labelPosition", layout: "layout", layoutStyle: "layoutStyle", margin: "margin", maxDate: "maxDate", maxHeight: "maxHeight", maximizeOnMobile: "maximizeOnMobile", maxWidth: "maxWidth", minDate: "minDate", minHeight: "minHeight", minWidth: "minWidth", mode: "mode", modeDefaults: "modeDefaults", modes: "modes", nonWorkingDays: "nonWorkingDays", project: "project", readOnly: "readOnly", recurrenceConfirmationPopup: "recurrenceConfirmationPopup", rendition: "rendition", resources: "resources", resourceTimeRanges: "resourceTimeRanges", rtl: "rtl", scrollable: "scrollable", selectResourceOnEventNavigate: "selectResourceOnEventNavigate", selectResourceOnScheduleClick: "selectResourceOnScheduleClick", span: "span", strictRecordMapping: "strictRecordMapping", timeRanges: "timeRanges", title: "title", tools: "tools", tooltip: "tooltip", useContextualRecurrenceRules: "useContextualRecurrenceRules", width: "width", x: "x", y: "y", activeSubView: "activeSubView", activeView: "activeView", anchorSize: "anchorSize", focusVisible: "focusVisible", hasChanges: "hasChanges", isEngineReady: "isEngineReady", isSettingValues: "isSettingValues", isValid: "isValid", parent: "parent", record: "record", selectedEvents: "selectedEvents", state: "state", values: "values", views: "views", dragFeature: "dragFeature", eventBufferFeature: "eventBufferFeature", eventCopyPasteFeature: "eventCopyPasteFeature", eventEditFeature: "eventEditFeature", eventMenuFeature: "eventMenuFeature", eventTooltipFeature: "eventTooltipFeature", excelExporterFeature: "excelExporterFeature", externalEventSourceFeature: "externalEventSourceFeature", loadOnDemandFeature: "loadOnDemandFeature", printFeature: "printFeature", scheduleMenuFeature: "scheduleMenuFeature", scheduleTooltipFeature: "scheduleTooltipFeature", timeRangesFeature: "timeRangesFeature", weekExpanderFeature: "weekExpanderFeature" }, outputs: { onActiveItemChange: "onActiveItemChange", onAfterEventEdit: "onAfterEventEdit", onAfterEventSave: "onAfterEventSave", onBeforeActiveItemChange: "onBeforeActiveItemChange", onBeforeAssignmentDelete: "onBeforeAssignmentDelete", onBeforeAssignmentSelectionChange: "onBeforeAssignmentSelectionChange", onBeforeAutoCreate: "onBeforeAutoCreate", onBeforeCopy: "onBeforeCopy", onBeforeCreateMode: "onBeforeCreateMode", onBeforeCSVExport: "onBeforeCSVExport", onBeforeDestroy: "onBeforeDestroy", onBeforeDragCreate: "onBeforeDragCreate", onBeforeDragCreateEnd: "onBeforeDragCreateEnd", onBeforeDragMove: "onBeforeDragMove", onBeforeDragMoveEnd: "onBeforeDragMoveEnd", onBeforeDragResize: "onBeforeDragResize", onBeforeDragResizeEnd: "onBeforeDragResizeEnd", onBeforeDropExternal: "onBeforeDropExternal", onBeforeEventDelete: "onBeforeEventDelete", onBeforeEventEdit: "onBeforeEventEdit", onBeforeEventEditShow: "onBeforeEventEditShow", onBeforeEventSave: "onBeforeEventSave", onBeforeEventSelectionChange: "onBeforeEventSelectionChange", onBeforeExcelExport: "onBeforeExcelExport", onBeforeHide: "onBeforeHide", onBeforePaste: "onBeforePaste", onBeforePrint: "onBeforePrint", onBeforeResponsiveStateChange: "onBeforeResponsiveStateChange", onBeforeSetRecord: "onBeforeSetRecord", onBeforeShow: "onBeforeShow", onBeforeStateApply: "onBeforeStateApply", onBeforeStateSave: "onBeforeStateSave", onCatchAll: "onCatchAll", onCellOverflowClick: "onCellOverflowClick", onCollapse: "onCollapse", onContextMenuItem: "onContextMenuItem", onContextMenuToggleItem: "onContextMenuToggleItem", onCopy: "onCopy", onCurrentTimelineUpdate: "onCurrentTimelineUpdate", onDataChange: "onDataChange", onDateChange: "onDateChange", onDateRangeChange: "onDateRangeChange", onDateRangeLoad: "onDateRangeLoad", onDateRangeRequested: "onDateRangeRequested", onDayCellPopulated: "onDayCellPopulated", onDayNumberClick: "onDayNumberClick", onDestroy: "onDestroy", onDirtyStateChange: "onDirtyStateChange", onDragCreateEnd: "onDragCreateEnd", onDragMoveEnd: "onDragMoveEnd", onDragMoveExternal: "onDragMoveExternal", onDragResizeEnd: "onDragResizeEnd", onDropExternal: "onDropExternal", onElementCreated: "onElementCreated", onEmptyCellClick: "onEmptyCellClick", onEventAutoCreated: "onEventAutoCreated", onEventClick: "onEventClick", onEventContextMenu: "onEventContextMenu", onEventDblClick: "onEventDblClick", onEventEditBeforeSetRecord: "onEventEditBeforeSetRecord", onEventKeyDown: "onEventKeyDown", onEventMenuBeforeShow: "onEventMenuBeforeShow", onEventMenuItem: "onEventMenuItem", onEventMenuShow: "onEventMenuShow", onEventMouseDown: "onEventMouseDown", onEventMouseEnter: "onEventMouseEnter", onEventMouseLeave: "onEventMouseLeave", onEventMouseOut: "onEventMouseOut", onEventMouseOver: "onEventMouseOver", onEventMouseUp: "onEventMouseUp", onEventPropagate: "onEventPropagate", onExpand: "onExpand", onFocusIn: "onFocusIn", onFocusOut: "onFocusOut", onHide: "onHide", onLoadOnDemandFail: "onLoadOnDemandFail", onMonthNameClick: "onMonthNameClick", onNavigate: "onNavigate", onPaint: "onPaint", onPaste: "onPaste", onPasteNotAllowed: "onPasteNotAllowed", onReadOnly: "onReadOnly", onRecompose: "onRecompose", onRefresh: "onRefresh", onResize: "onResize", onResourceClick: "onResourceClick", onResponsiveStateChange: "onResponsiveStateChange", onScheduleClick: "onScheduleClick", onScheduleContextMenu: "onScheduleContextMenu", onScheduleDblClick: "onScheduleDblClick", onScheduleMenuBeforeShow: "onScheduleMenuBeforeShow", onScheduleMenuItem: "onScheduleMenuItem", onScheduleMenuShow: "onScheduleMenuShow", onScheduleMouseDown: "onScheduleMouseDown", onScheduleMouseOut: "onScheduleMouseOut", onScheduleMouseOver: "onScheduleMouseOver", onScheduleMouseUp: "onScheduleMouseUp", onSelectionChange: "onSelectionChange", onShow: "onShow", onSidebarCollapse: "onSidebarCollapse", onSidebarExpand: "onSidebarExpand", onTimeAxisClick: "onTimeAxisClick", onTimeRangeHeaderClick: "onTimeRangeHeaderClick", onTimeRangeHeaderContextMenu: "onTimeRangeHeaderContextMenu", onTimeRangeHeaderDblClick: "onTimeRangeHeaderDblClick", onToolClick: "onToolClick", onViewPaint: "onViewPaint", onWeekNumberClick: "onWeekNumberClick" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumCalendarComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bryntum-calendar',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { adopt: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], anchor: [{
+                type: Input
+            }], ariaDescription: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], assignmentStore: [{
+                type: Input
+            }], autoCreate: [{
+                type: Input
+            }], bbar: [{
+                type: Input
+            }], bodyCls: [{
+                type: Input
+            }], bubbleEvents: [{
+                type: Input
+            }], centered: [{
+                type: Input
+            }], collapsible: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], constrainTo: [{
+                type: Input
+            }], contentElementCls: [{
+                type: Input
+            }], contextMenuTriggerEvent: [{
+                type: Input
+            }], crudManagerClass: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], datePicker: [{
+                type: Input
+            }], defaultBindProperty: [{
+                type: Input
+            }], defaultFocus: [{
+                type: Input
+            }], defaults: [{
+                type: Input
+            }], deselectOnClick: [{
+                type: Input
+            }], destroyStores: [{
+                type: Input
+            }], detectCSSCompatibilityIssues: [{
+                type: Input
+            }], dock: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], drawer: [{
+                type: Input
+            }], elementAttributes: [{
+                type: Input
+            }], enableDeleteKey: [{
+                type: Input
+            }], enableRecurringEvents: [{
+                type: Input
+            }], enableUndoRedoKeys: [{
+                type: Input
+            }], eventSelectionDisabled: [{
+                type: Input
+            }], eventStore: [{
+                type: Input
+            }], filterEventResources: [{
+                type: Input
+            }], floating: [{
+                type: Input
+            }], footer: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], hideAnimation: [{
+                type: Input
+            }], hideWhenEmpty: [{
+                type: Input
+            }], highlightDate: [{
+                type: Input
+            }], highlightPredecessors: [{
+                type: Input
+            }], highlightSuccessors: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], ignoreParentReadOnly: [{
+                type: Input
+            }], includeWeekendsButton: [{
+                type: Input
+            }], itemCls: [{
+                type: Input
+            }], lazyItems: [{
+                type: Input
+            }], listeners: [{
+                type: Input
+            }], loadMask: [{
+                type: Input
+            }], loadMaskDefaults: [{
+                type: Input
+            }], loadMaskError: [{
+                type: Input
+            }], localeClass: [{
+                type: Input
+            }], localizable: [{
+                type: Input
+            }], localizableProperties: [{
+                type: Input
+            }], maintainSelectionOnDatasetChange: [{
+                type: Input
+            }], maskDefaults: [{
+                type: Input
+            }], masked: [{
+                type: Input
+            }], monitorResize: [{
+                type: Input
+            }], multiEventSelect: [{
+                type: Input
+            }], namedItems: [{
+                type: Input
+            }], navigatorPlacement: [{
+                type: Input
+            }], overlaySidebar: [{
+                type: Input
+            }], owner: [{
+                type: Input
+            }], positioned: [{
+                type: Input
+            }], preventTooltipOnTouch: [{
+                type: Input
+            }], propagatedConfigs: [{
+                type: Input
+            }], relayStoreEvents: [{
+                type: Input
+            }], resourceImagePath: [{
+                type: Input
+            }], resourceStore: [{
+                type: Input
+            }], resourceTimeRangeStore: [{
+                type: Input
+            }], responsive: [{
+                type: Input
+            }], responsiveRoot: [{
+                type: Input
+            }], responsiveState: [{
+                type: Input
+            }], responsiveTarget: [{
+                type: Input
+            }], ripple: [{
+                type: Input
+            }], rootElement: [{
+                type: Input
+            }], scrollAction: [{
+                type: Input
+            }], showAnimation: [{
+                type: Input
+            }], showRecurringUI: [{
+                type: Input
+            }], showTooltipWhenDisabled: [{
+                type: Input
+            }], sidebar: [{
+                type: Input
+            }], stateful: [{
+                type: Input
+            }], statefulEvents: [{
+                type: Input
+            }], stateId: [{
+                type: Input
+            }], stateProvider: [{
+                type: Input
+            }], strips: [{
+                type: Input
+            }], syncMask: [{
+                type: Input
+            }], tab: [{
+                type: Input
+            }], tabBarItems: [{
+                type: Input
+            }], tag: [{
+                type: Input
+            }], tbar: [{
+                type: Input
+            }], textAlign: [{
+                type: Input
+            }], timeRangeStore: [{
+                type: Input
+            }], timeZone: [{
+                type: Input
+            }], trapFocus: [{
+                type: Input
+            }], triggerSelectionChangeOnRemove: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], ui: [{
+                type: Input
+            }], viewContainer: [{
+                type: Input
+            }], weekStartDay: [{
+                type: Input
+            }], weight: [{
+                type: Input
+            }], activeDateCls: [{
+                type: Input
+            }], alignSelf: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], assignments: [{
+                type: Input
+            }], callOnFunctions: [{
+                type: Input
+            }], catchEventHandlerExceptions: [{
+                type: Input
+            }], cls: [{
+                type: Input
+            }], collapsed: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], crudManager: [{
+                type: Input
+            }], dataset: [{
+                type: Input
+            }], date: [{
+                type: Input
+            }], dateFormat: [{
+                type: Input
+            }], defaultCalendar: [{
+                type: Input
+            }], deselectAllOnScheduleClick: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], events: [{
+                type: Input
+            }], extraData: [{
+                type: Input
+            }], flex: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], hideNonWorkingDays: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], inputFieldAlign: [{
+                type: Input
+            }], insertBefore: [{
+                type: Input
+            }], insertFirst: [{
+                type: Input
+            }], isEventSelectable: [{
+                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
+            }], minHeight: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], mode: [{
+                type: Input
+            }], modeDefaults: [{
+                type: Input
+            }], modes: [{
+                type: Input
+            }], nonWorkingDays: [{
+                type: Input
+            }], project: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], recurrenceConfirmationPopup: [{
+                type: Input
+            }], rendition: [{
+                type: Input
+            }], resources: [{
+                type: Input
+            }], resourceTimeRanges: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], selectResourceOnEventNavigate: [{
+                type: Input
+            }], selectResourceOnScheduleClick: [{
+                type: Input
+            }], span: [{
+                type: Input
+            }], strictRecordMapping: [{
+                type: Input
+            }], timeRanges: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], tools: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], useContextualRecurrenceRules: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], x: [{
+                type: Input
+            }], y: [{
+                type: Input
+            }], activeSubView: [{
+                type: Input
+            }], activeView: [{
+                type: Input
+            }], anchorSize: [{
+                type: Input
+            }], focusVisible: [{
+                type: Input
+            }], hasChanges: [{
+                type: Input
+            }], isEngineReady: [{
+                type: Input
+            }], isSettingValues: [{
+                type: Input
+            }], isValid: [{
+                type: Input
+            }], parent: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], selectedEvents: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], values: [{
+                type: Input
+            }], views: [{
+                type: Input
+            }], dragFeature: [{
+                type: Input
+            }], eventBufferFeature: [{
+                type: Input
+            }], eventCopyPasteFeature: [{
+                type: Input
+            }], eventEditFeature: [{
+                type: Input
+            }], eventMenuFeature: [{
+                type: Input
+            }], eventTooltipFeature: [{
+                type: Input
+            }], excelExporterFeature: [{
+                type: Input
+            }], externalEventSourceFeature: [{
+                type: Input
+            }], loadOnDemandFeature: [{
+                type: Input
+            }], printFeature: [{
+                type: Input
+            }], scheduleMenuFeature: [{
+                type: Input
+            }], scheduleTooltipFeature: [{
+                type: Input
+            }], timeRangesFeature: [{
+                type: Input
+            }], weekExpanderFeature: [{
+                type: Input
+            }], onActiveItemChange: [{
+                type: Output
+            }], onAfterEventEdit: [{
+                type: Output
+            }], onAfterEventSave: [{
+                type: Output
+            }], onBeforeActiveItemChange: [{
+                type: Output
+            }], onBeforeAssignmentDelete: [{
+                type: Output
+            }], onBeforeAssignmentSelectionChange: [{
+                type: Output
+            }], onBeforeAutoCreate: [{
+                type: Output
+            }], onBeforeCopy: [{
+                type: Output
+            }], onBeforeCreateMode: [{
+                type: Output
+            }], onBeforeCSVExport: [{
+                type: Output
+            }], onBeforeDestroy: [{
+                type: Output
+            }], onBeforeDragCreate: [{
+                type: Output
+            }], onBeforeDragCreateEnd: [{
+                type: Output
+            }], onBeforeDragMove: [{
+                type: Output
+            }], onBeforeDragMoveEnd: [{
+                type: Output
+            }], onBeforeDragResize: [{
+                type: Output
+            }], onBeforeDragResizeEnd: [{
+                type: Output
+            }], onBeforeDropExternal: [{
+                type: Output
+            }], onBeforeEventDelete: [{
+                type: Output
+            }], onBeforeEventEdit: [{
+                type: Output
+            }], onBeforeEventEditShow: [{
+                type: Output
+            }], onBeforeEventSave: [{
+                type: Output
+            }], onBeforeEventSelectionChange: [{
+                type: Output
+            }], onBeforeExcelExport: [{
+                type: Output
+            }], onBeforeHide: [{
+                type: Output
+            }], onBeforePaste: [{
+                type: Output
+            }], onBeforePrint: [{
+                type: Output
+            }], onBeforeResponsiveStateChange: [{
+                type: Output
+            }], onBeforeSetRecord: [{
+                type: Output
+            }], onBeforeShow: [{
+                type: Output
+            }], onBeforeStateApply: [{
+                type: Output
+            }], onBeforeStateSave: [{
+                type: Output
+            }], onCatchAll: [{
+                type: Output
+            }], onCellOverflowClick: [{
+                type: Output
+            }], onCollapse: [{
+                type: Output
+            }], onContextMenuItem: [{
+                type: Output
+            }], onContextMenuToggleItem: [{
+                type: Output
+            }], onCopy: [{
+                type: Output
+            }], onCurrentTimelineUpdate: [{
+                type: Output
+            }], onDataChange: [{
+                type: Output
+            }], onDateChange: [{
+                type: Output
+            }], onDateRangeChange: [{
+                type: Output
+            }], onDateRangeLoad: [{
+                type: Output
+            }], onDateRangeRequested: [{
+                type: Output
+            }], onDayCellPopulated: [{
+                type: Output
+            }], onDayNumberClick: [{
+                type: Output
+            }], onDestroy: [{
+                type: Output
+            }], onDirtyStateChange: [{
+                type: Output
+            }], onDragCreateEnd: [{
+                type: Output
+            }], onDragMoveEnd: [{
+                type: Output
+            }], onDragMoveExternal: [{
+                type: Output
+            }], onDragResizeEnd: [{
+                type: Output
+            }], onDropExternal: [{
+                type: Output
+            }], onElementCreated: [{
+                type: Output
+            }], onEmptyCellClick: [{
+                type: Output
+            }], onEventAutoCreated: [{
+                type: Output
+            }], onEventClick: [{
+                type: Output
+            }], onEventContextMenu: [{
+                type: Output
+            }], onEventDblClick: [{
+                type: Output
+            }], onEventEditBeforeSetRecord: [{
+                type: Output
+            }], onEventKeyDown: [{
+                type: Output
+            }], onEventMenuBeforeShow: [{
+                type: Output
+            }], onEventMenuItem: [{
+                type: Output
+            }], onEventMenuShow: [{
+                type: Output
+            }], onEventMouseDown: [{
+                type: Output
+            }], onEventMouseEnter: [{
+                type: Output
+            }], onEventMouseLeave: [{
+                type: Output
+            }], onEventMouseOut: [{
+                type: Output
+            }], onEventMouseOver: [{
+                type: Output
+            }], onEventMouseUp: [{
+                type: Output
+            }], onEventPropagate: [{
+                type: Output
+            }], onExpand: [{
+                type: Output
+            }], onFocusIn: [{
+                type: Output
+            }], onFocusOut: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onLoadOnDemandFail: [{
+                type: Output
+            }], onMonthNameClick: [{
+                type: Output
+            }], onNavigate: [{
+                type: Output
+            }], onPaint: [{
+                type: Output
+            }], onPaste: [{
+                type: Output
+            }], onPasteNotAllowed: [{
+                type: Output
+            }], onReadOnly: [{
+                type: Output
+            }], onRecompose: [{
+                type: Output
+            }], onRefresh: [{
+                type: Output
+            }], onResize: [{
+                type: Output
+            }], onResourceClick: [{
+                type: Output
+            }], onResponsiveStateChange: [{
+                type: Output
+            }], onScheduleClick: [{
+                type: Output
+            }], onScheduleContextMenu: [{
+                type: Output
+            }], onScheduleDblClick: [{
+                type: Output
+            }], onScheduleMenuBeforeShow: [{
+                type: Output
+            }], onScheduleMenuItem: [{
+                type: Output
+            }], onScheduleMenuShow: [{
+                type: Output
+            }], onScheduleMouseDown: [{
+                type: Output
+            }], onScheduleMouseOut: [{
+                type: Output
+            }], onScheduleMouseOver: [{
+                type: Output
+            }], onScheduleMouseUp: [{
+                type: Output
+            }], onSelectionChange: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onSidebarCollapse: [{
+                type: Output
+            }], onSidebarExpand: [{
+                type: Output
+            }], onTimeAxisClick: [{
+                type: Output
+            }], onTimeRangeHeaderClick: [{
+                type: Output
+            }], onTimeRangeHeaderContextMenu: [{
+                type: Output
+            }], onTimeRangeHeaderDblClick: [{
+                type: Output
+            }], onToolClick: [{
+                type: Output
+            }], onViewPaint: [{
+                type: Output
+            }], onWeekNumberClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bryntum-calendar.component.js","sourceRoot":"","sources":["../../../component/src/lib/bryntum-calendar.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Angular wrapper for Bryntum Calendar\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, ButtonConfig, Container, ContainerConfig, DatePickerConfig, DomConfig, DragContext, KeyMapConfig, Layout, Mask, MaskConfig, Menu, MenuItem, MenuItemConfig, MenuItemEntry, Model, PagingToolbarConfig, Panel, PanelCollapserConfig, PanelCollapserOverlayConfig, PanelHeader, Popup, Rectangle, Scroller, ScrollerConfig, StateProvider, Store, TabConfig, TextFieldConfig, Tool, ToolConfig, ToolbarConfig, ToolbarItems, TooltipConfig, Widget, WidgetConfig } from '@bryntum/core-thin';\nimport { Column, ExportConfig, XLSColumn } from '@bryntum/grid-thin';\nimport { AssignmentModel, AssignmentModelConfig, AssignmentStore, AssignmentStoreConfig, CrudManager as SchedulerCrudManager, EventEdit as SchedulerEventEdit, EventModel, EventModelConfig, EventStore, EventStoreConfig, ProjectConsumer, ProjectModelMixin, RecurrenceConfirmationPopup, RecurrenceConfirmationPopupConfig, ResourceFilterConfig, ResourceModel, ResourceModelConfig, ResourceStore, ResourceStoreConfig, ResourceTimeRangeModel, ResourceTimeRangeModelConfig, ResourceTimeRangeStore, ResourceTimeRangeStoreConfig, Scheduler, TimeSpan } from '@bryntum/scheduler-thin';\nimport { AgendaViewConfig, Calendar, CalendarDatePickerConfig, CalendarDrag, CalendarDragConfig, CalendarListeners, CalendarToolbarConfig, CalendarView, CalendarContainerItemConfig, CalendarContainerLayoutConfig, CrudManagerConfig, DayAgendaViewConfig, DayCell, DayResourceViewConfig, DayViewConfig, EventBuffer, EventBufferConfig, EventCopyPaste, EventCopyPasteConfig, EventEdit, EventEditConfig, EventListConfig, EventMenu, EventMenuConfig, EventTooltip, EventTooltipConfig, ExcelExporter, ExcelExporterConfig, ExternalEventSource, ExternalEventSourceConfig, LoadOnDemand, LoadOnDemandConfig, MonthAgendaViewConfig, MonthGridConfig, MonthViewConfig, Print, PrintConfig, ProjectModel, ProjectModelConfig, ResourceViewConfig, ScheduleMenu, ScheduleMenuConfig, ScheduleTooltip, ScheduleTooltipConfig, TimeRangeModel, TimeRangeModelConfig, TimeRangeStore, TimeRangeStoreConfig, TimeRanges, TimeRangesConfig, ValidateCreateResult, WeekExpander, WeekExpanderConfig, WeekViewConfig, YearViewConfig } from '@bryntum/calendar-thin';\n\nimport { StringHelper } from '@bryntum/core-thin';\n\nexport type BryntumCalendarProps = {\n    // Configs\n    /**\n     * An optional CSS class name to add to calendar date cells which encapsulate the calendar's\n     * active [date](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#property-date).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-activeDateCls)\n     */\n    activeDateCls ? : 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/view/Calendar#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/view/Calendar#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     * *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     * 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/view/Calendar#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/view/Calendar#config-ariaLabel)\n     */\n    ariaLabel ? : string\n    /**\n     * Inline assignments, will be loaded into the [assignmentStore](https://bryntum.com/products/calendar/docs/api/Calendar/mixin/CalendarStores#property-assignmentStore).\n     */\n    assignments ? : AssignmentModel[]|AssignmentModelConfig[]\n    /**\n     * The [AssignmentStore](https://bryntum.com/products/calendar/docs/api/Scheduler/data/AssignmentStore) or a reconfiguring object for a store which will hold assignments linking resources to events.\n     */\n    assignmentStore ? : AssignmentStore|AssignmentStoreConfig\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/view/Calendar#config-autoCreate)\n     */\n    autoCreate ? : {\n        gesture?: string\n        newName?: Function|string\n        step?: string\n        duration?: string\n        startHour?: number|string\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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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    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/view/Calendar#config-contentElementCls)\n     */\n    contentElementCls ? : string|object\n    /**\n     * Event which is used to show context menus via the context menu features\n     * [EventMenu](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventMenu) and [ScheduleMenu](#Calendar/feature/ScheduleMenu).\n     * Available options are: 'contextmenu', 'click', 'dblclick'.\n     */\n    contextMenuTriggerEvent ? : 'contextmenu'|'click'|'dblclick'\n    /**\n     * Supply a [CrudManager](https://bryntum.com/products/calendar/docs/api/Scheduler/data/CrudManager) instance or a config object if you want to use\n     * CrudManager for handling data.\n     */\n    crudManager ? : CrudManagerConfig|SchedulerCrudManager\n    /**\n     * Class that should be used to instantiate a CrudManager in case it's provided as a simple object to\n     * [crudManager](https://bryntum.com/products/calendar/docs/api/Calendar/mixin/CalendarStores#config-crudManager) config.\n     */\n    crudManagerClass ? : SchedulerCrudManager\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 which the Calendar, its [sidebar](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#property-sidebar)'s date picker, and\n     * its active view should encapsulate upon creation.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-date)\n     */\n    date ? : Date|string\n    /**\n     * A [DateHelper](https://bryntum.com/products/calendar/docs/api/Core/helper/DateHelper) format string to use to create date output for\n     * view descriptions.\n     */\n    dateFormat ? : string\n    /**\n     * An optional config object to configure the [CalendarDatePicker](https://bryntum.com/products/calendar/docs/api/Calendar/widget/CalendarDatePicker) which is\n     * shown in the [sidebar](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#property-sidebar) next to the calendar views.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-datePicker)\n     * @param {boolean,'count','dots'} datePicker.showEvents Displays the presence of events in each cell. values may be:  * `false` - Do not show events in cells. * `true` - Show a themeable bullet to indicate the presence of events for a date. * `'count'` - Show a themeable badge containing the event count for a date. * '`dots'` - Show small event-coloured bullets (to a maximum of three) below the date.\n     * @param {boolean} datePicker.collapsible `true` to enable collapse into a header.\n     * @param {string} datePicker.title The text to place in a header above the picker.\n     * @param {boolean} datePicker.editMonth `true` to enable setting the date using the controls in the DatePicker header.\n     * @param {boolean,'range'} multiSelect The DatePicker can select [multiple dates](https://bryntum.com/products/calendar/docs/api/Core/widget/DatePicker#config-multiSelect) in two modes:  * `true` to mean many discontiguous dates may be selected. * `'range'` to mean that a start date and end date may be selected.  If set up to multi select, views which are not fixed to a date duration will obey the date selection by using a [dateFilter](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView#property-dateFilter) to skip days which are not selected. These include:  * AgendaView      (mode type `'agenda'`) * DayViews        (view type `'dayview'`) which you add to the modes - The default `day` and `week` modes have a fixed duration. * ResourceView    (view type `'resourceview'`) * DayResourceView (view type `'dayresourceview'`)  The `MonthView`, and the `WeekView` and the built-in single day `DayView` <strong>mode</strong> all have fixed duration and will not participate in this. If you select a discontiguous range, then the views which are amenable to being controlled in this way will switch their range to encompass what you have selected. For example, if you select the first to the last days of a month, the view's [range](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#property-range) will be set to `'1 month'`. This choice will be maintained, and by navigating using the next and previous tbar buttons, the views will move by exactly one month. If your set of selected dates is enclosed within a two week block, then the [range](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#property-range) of the views will be set to `{ unit : 'week', magnitude : 2 }`. If you select the 1st, 3th and 5th of the month, and those days are all on one week row, the [range](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DateRangeOwner#property-range) of the views will be set to `{ unit : 'week', magnitude : 1 }`. For selection ranges other than exactly one month, navigation in time will be in increments of one week for intuitive navigation up and down the date picker. When navigating in time, the selected block of dates moves and *follows the time navigation* so that there are always dates in view, even if they are empty.\n     */\n    datePicker ? : CalendarDatePickerConfig|boolean|null\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     * The calendar ([Resource](https://bryntum.com/products/calendar/docs/api/Scheduler/model/ResourceModel)), (or its `id`) to use as the\n     * default calendar for new events created using [dblclick](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-autoCreate)\n     * or [drag-create](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag), or [dragging in](#Calendar/feature/ExternalEventSource).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-defaultCalendar)\n     */\n    defaultCalendar ? : string|ResourceModel\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/view/Calendar#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     * Configure as `false` to preserve selection when clicking the empty schedule area.\n     */\n    deselectAllOnScheduleClick ? : boolean\n    /**\n     * Configure as `true` to deselect a selected event upon click.\n     */\n    deselectOnClick ? : boolean\n    /**\n     * Configure as `true` to destroy the Project and stores when `this` is destroyed.\n     */\n    destroyStores ? : boolean\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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#config-draggable)\n     */\n    draggable ? : boolean|{\n        handleSelector?: string\n    }\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/view/Calendar#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/view/Calendar#config-elementAttributes)\n     */\n    elementAttributes ? : Record<string, string|null>\n    /**\n     * Allow using [Delete] and [Backspace] to remove events/assignments\n     */\n    enableDeleteKey ? : boolean\n    /**\n     * Enables events being recurring and also adds extra recurrence UI fields in the built-in event editor.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-enableRecurringEvents)\n     */\n    enableRecurringEvents ? : boolean|{\n        defaultAction?: 'single'|'future'\n    }\n    /**\n     * Set to `true` to listen for CTRL-Z (CMD-Z on Mac OS) keyboard event and trigger undo (redo when SHIFT is pressed).\n     * Only applicable when using a [StateTrackingManager](https://bryntum.com/products/calendar/docs/api/Core/data/stm/StateTrackingManager).\n     */\n    enableUndoRedoKeys ? : boolean\n    /**\n     * Inline events, will be loaded into the [eventStore](https://bryntum.com/products/calendar/docs/api/Calendar/mixin/CalendarStores#property-eventStore).\n     */\n    events ? : EventModel[]|EventModelConfig[]\n    /**\n     * Configure as `true`, or set property to `true` to disable event selection.\n     */\n    eventSelectionDisabled ? : boolean\n    /**\n     * The [EventStore](https://bryntum.com/products/calendar/docs/api/Scheduler/data/EventStore) or a reconfiguring object for a store which will hold\n     * the events to be rendered into the Calendar.\n     */\n    eventStore ? : EventStore|EventStoreConfig\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/view/Calendar#config-filterEventResources)\n     */\n    filterEventResources ? : 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/view/Calendar#config-footer)\n     */\n    footer ? : {\n        dock?: 'top'|'right'|'bottom'|'left'|'start'|'end'\n        html?: string\n        cls?: string\n    }|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/view/Calendar#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/view/Calendar#config-hideAnimation)\n     */\n    hideAnimation ? : boolean|object\n    /**\n     * Configure as `true` to hide [nonWorkingDays](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-nonWorkingDays) for each calendar view\n     */\n    hideNonWorkingDays ? : 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/view/Calendar#config-hideWhenEmpty)\n     */\n    hideWhenEmpty ? : boolean\n    /**\n     * Configure this as `true` to make picking a date in the [sidebar](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-sidebar)'s\n     * date picker highlight the date cell in the active view.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-highlightDate)\n     * @param {Date} date Cell date\n     * @returns {boolean} Returns `true` to make picking a date in a date picker\n     */\n    highlightDate ? : boolean|((date: Date) => boolean)\n    /**\n     * Configure as `true`, or set property to `true` to highlight dependent events as well when selecting an event.\n     */\n    highlightPredecessors ? : boolean\n    /**\n     * Configure as `true`, or set property to `true` to highlight dependent events as well when selecting an event.\n     */\n    highlightSuccessors ? : boolean\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/view/Calendar#config-ignoreParentReadOnly)\n     */\n    ignoreParentReadOnly ? : boolean\n    /**\n     * Set to `true` to show the \"Weekends\" toggle button of the mode selector. Alternatively, this config\n     * can be a [Button](https://bryntum.com/products/calendar/docs/api/Core/widget/Button) config object to configure the button.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-includeWeekendsButton)\n     */\n    includeWeekendsButton ? : boolean|ButtonConfig\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/view/Calendar#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     * A template method (empty by default) allowing you to control if an event can be selected or not.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-isEventSelectable)\n     * @param {Scheduler.model.EventModel} event The event record\n     * @returns {boolean} true if event can be selected, otherwise false\n     */\n    isEventSelectable ? : (event: EventModel) => boolean\n    /**\n     * An optional CSS class to add to child items of this container.\n     */\n    itemCls ? : string\n    /**\n     * The child items of the Calendar view.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-items)\n     */\n    items ? : object\n    /**\n     * The default key shortcuts for the Calendar.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#config-listeners)\n     */\n    listeners ? : CalendarListeners\n    /**\n     * A [Mask](https://bryntum.com/products/calendar/docs/api/Core/widget/Mask) config object, or a message to be shown when a store is performing a remote\n     * operation, or Crud Manager is loading data from the sever. Set to `null` to disable default load mask.\n     */\n    loadMask ? : string|MaskConfig|null\n    /**\n     * A [Mask](https://bryntum.com/products/calendar/docs/api/Core/widget/Mask) config object to adjust the [maskDefaults](#Core/widget/Widget#config-maskDefaults)\n     * when data is loading. The message and optional configuration from the\n     * [loadMask](https://bryntum.com/products/calendar/docs/api/Core/mixin/LoadMaskable#config-loadMask) config take priority over these options, just as they do\n     * for `maskDefaults`, respectively.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-loadMaskDefaults)\n     */\n    loadMaskDefaults ? : MaskConfig\n    /**\n     * A [Mask](https://bryntum.com/products/calendar/docs/api/Core/widget/Mask) config object to adjust the [maskDefaults](#Core/widget/Widget#config-maskDefaults)\n     * when an error occurs loading data.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-loadMaskError)\n     */\n    loadMaskError ? : MaskConfig|Mask|boolean\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/view/Calendar#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/view/Calendar#config-localizableProperties)\n     */\n    localizableProperties ? : string[]\n    /**\n     * This flag controls whether Scheduler should preserve its selection of events when loading a new dataset\n     * (if selected event ids are included in the newly loaded dataset).\n     */\n    maintainSelectionOnDatasetChange ? : boolean\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 date to which the `endDate` of any child 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/view/Calendar#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 any child view may be navigated.\n     */\n    minDate ? : Date|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 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     * Which of the built-in [modes](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-modes) should be the initially active view.\n     */\n    mode ? : 'agenda'|'year'|'month'|'week'|'day'|'list'|'resource'|'dayresource'|'dayagenda'|'monthagenda'|'monthgrid'|string\n    /**\n     * An object to use to configure common properties for all [modes](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-modes) prior to their construction.\n     */\n    modeDefaults ? : object\n    /**\n     * Configures the view modes which are to be available in this Calendar.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-modes)\n     */\n    modes ? : {\n        [mode: string]: CalendarContainerItemConfig|boolean|null|undefined\n        agenda?: AgendaViewConfig|boolean|null\n        year?: YearViewConfig|boolean|null\n        month?: MonthViewConfig|boolean|null\n        week?: WeekViewConfig|boolean|null\n        day?: DayViewConfig|boolean|null\n        list?: EventListConfig|boolean|null\n        resource?: ResourceViewConfig|boolean|null\n        dayresourceview?: DayResourceViewConfig|boolean|null\n        dayagenda?: DayAgendaViewConfig|boolean|null\n        monthagenda?: MonthAgendaViewConfig|boolean|null\n        monthgrid?: MonthGridConfig|boolean|null\n    }\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/view/Calendar#config-monitorResize)\n     */\n    monitorResize ? : boolean|{\n        immediate?: boolean\n    }\n    /**\n     * Configure as `true` to allow `CTRL/CMD+click` to select multiple events in the scheduler.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-multiEventSelect)\n     */\n    multiEventSelect ? : boolean|{\n        ctrlKey?: boolean\n        altKey?: boolean\n        shiftKey?: 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/view/Calendar#config-namedItems)\n     */\n    namedItems ? : Record<string, CalendarContainerItemConfig>\n    /**\n     * Indicates where the Next/Previous/Today buttons should be placed.\n     */\n    navigatorPlacement ? : 'toolbar'|'sidebar'\n    /**\n     * Non-working days as an object where keys are day indices, 0-6 (Sunday-Saturday), and the value is `true`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-nonWorkingDays)\n     */\n    nonWorkingDays ? : Record<number, boolean>\n    /**\n     * By default, the [sidebar](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#property-sidebar) expands and collapses taking width from the\n     * calendar UI. Configure `overlaySidebar` as `true` to have it start collapsed, and then\n     * <strong>overlay</strong> the calendar UI when the expand/collapse button is toggled.\n     */\n    overlaySidebar ? : boolean\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/view/Calendar#config-owner)\n     */\n    owner ? : Widget|any\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/view/Calendar#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     * A [ProjectModel](https://bryntum.com/products/calendar/docs/api/Scheduler/model/ProjectModel) instance or a config object. The project holds all Scheduler data.\n     * Can be omitted in favor of individual store configs or [crudManager](https://bryntum.com/products/calendar/docs/api/Scheduler/view/mixin/SchedulerStores#config-crudManager) config.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-project)\n     */\n    project ? : ProjectModel|ProjectModelConfig|object\n    /**\n     * The names of properties which are propagated down from the Calendar to child views\n     * unless the view has its own value for that property.\n     */\n    propagatedConfigs ? : string[]\n    /**\n     * Configure as `true` to make the calendar read-only, by disabling any UIs for modifying data.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-readOnly)\n     */\n    readOnly ? : boolean\n    /**\n     * The confirmation dialog shown when a recurring event is edited.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-recurrenceConfirmationPopup)\n     */\n    recurrenceConfirmationPopup ? : RecurrenceConfirmationPopupConfig|RecurrenceConfirmationPopup\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/view/Calendar#config-rendition)\n     */\n    rendition ? : string|Record<string, string>|null\n    /**\n     * Path to load resource images from. Used by the resource headers in ResourceView and by\n     * [showResourceAvatars](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-showResourceAvatars) in event-displaying\n     * modes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-resourceImagePath)\n     */\n    resourceImagePath ? : string\n    /**\n     * Inline resources, will be loaded into the [resourceStore](https://bryntum.com/products/calendar/docs/api/Calendar/mixin/CalendarStores#property-resourceStore).\n     */\n    resources ? : ResourceModel[]|ResourceModelConfig[]\n    /**\n     * The [ResourceStore](https://bryntum.com/products/calendar/docs/api/Scheduler/data/ResourceStore) or a reconfiguring object for a store which will hold the resources to be rendered into the Calendar.\n     */\n    resourceStore ? : ResourceStore|ResourceStoreConfig\n    /**\n     * Inline resource time ranges, will be loaded into [resourceTimeRangeStore](https://bryntum.com/products/calendar/docs/api/Calendar/mixin/CalendarStores#property-resourceTimeRangeStore).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-resourceTimeRanges)\n     */\n    resourceTimeRanges ? : ResourceTimeRangeModel[]|ResourceTimeRangeModelConfig[]\n    /**\n     * The [ResourceTimeRangeStore](https://bryntum.com/products/calendar/docs/api/Scheduler/data/ResourceTimeRangeStore) or a reconfiguring object for a store which will hold resource time ranges.\n     * These may be used by the [TimeRanges](https://bryntum.com/products/calendar/docs/api/Calendar/feature/TimeRanges) feature.\n     */\n    resourceTimeRangeStore ? : ResourceTimeRangeStore|ResourceTimeRangeStoreConfig\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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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     * Set to `false` to not select the resource of the event when clicking an event bar.\n     */\n    selectResourceOnEventNavigate ? : boolean\n    /**\n     * Set to `false` to not select the row/resource when clicking the empty area in a time axis cell.\n     */\n    selectResourceOnScheduleClick ? : 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/view/Calendar#config-showAnimation)\n     */\n    showAnimation ? : boolean|object\n    /**\n     * Set to `false` to hide recurring fields in event editor, even if the\n     * [Recurring Events](https://bryntum.com/products/calendar/docs/api/Scheduler/view/mixin/RecurringEvents#config-enableRecurringEvents) is `true`\n     * and a recurring event is being edited.\n     */\n    showRecurringUI ? : boolean\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     * An optional config object to configure the [Sidebar](https://bryntum.com/products/calendar/docs/api/Calendar/widget/Sidebar) which is\n     * shown next to the calendar views specified by the [modes](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-modes).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-sidebar)\n     * @param {'left','right'} side Which [side](https://bryntum.com/products/calendar/docs/api/Calendar/widget/Sidebar#config-side) to dock to.\n     * @param {boolean} collapsed May be initially [collapsed](https://bryntum.com/products/calendar/docs/api/Calendar/widget/Sidebar#config-collapsed).\n     * @param {Record<string, CalendarContainerItemConfig>} items Reconfigure or add to the sidebar UI.\n     * @param {CalendarContainerItemConfig} items.custom Settings specific to custom item.\n     * @param {DatePickerConfig} items.datePicker The [DatePicker](https://bryntum.com/products/calendar/docs/api/Core/widget/DatePicker) may be reconfigured using an object, or configured away using `null`. Its default [weight](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-weight) is 100.\n     * @param {TextFieldConfig} items.eventFilter The eventFilter is a [TextField](https://bryntum.com/products/calendar/docs/api/Core/widget/TextField) which may be used to filter the events by matched name. It may be reconfigured using an object, or configured away using `null`. Its default [weight](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-weight) is 150.\n     * @param {ResourceFilterConfig} items.resourceFilter The [ResourceFilter](https://bryntum.com/products/calendar/docs/api/Scheduler/widget/ResourceFilter) may be reconfigured using an object, or configured away using `null`. Its default [weight](https://bryntum.com/products/calendar/docs/api/Core/widget/Widget#config-weight) is 200.\n     */\n    sidebar ? : {side?: 'left'|'right', collapsed?: boolean, items: { [mode: string]: CalendarContainerItemConfig|null|undefined, datePicker?: DatePickerConfig, eventFilter?: TextFieldConfig, resourceFilter?: ResourceFilterConfig }}|boolean\n    /**\n     * Programmatic control over how many columns to span when used in a grid layout.\n     */\n    span ? : number\n    /**\n     * This value can be one of the following:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#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/view/Calendar#config-strips)\n     */\n    strips ? : Record<string, CalendarContainerItemConfig>\n    /**\n     * A [Mask](https://bryntum.com/products/calendar/docs/api/Core/widget/Mask) config object, or a message to be shown when Crud Manager\n     * is persisting changes on the server. Set to `null` to disable default sync mask.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-syncMask)\n     */\n    syncMask ? : string|MaskConfig|null\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/view/Calendar#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/view/Calendar#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 containing definitions of the toolbar of the Calendar.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-tbar)\n     */\n    tbar ? : (CalendarContainerItemConfig|string)[]|ToolbarConfig|CalendarToolbarConfig|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/view/Calendar#config-textAlign)\n     */\n    textAlign ? : 'left'|'center'|'right'|'start'|'end'\n    /**\n     * Inline time ranges, will be loaded into the [timeRangeStore](https://bryntum.com/products/calendar/docs/api/Calendar/mixin/CalendarStores#property-timeRangeStore).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-timeRanges)\n     */\n    timeRanges ? : TimeRangeModel[]|TimeRangeModelConfig[]\n    /**\n     * The [TimeRangeStore](https://bryntum.com/products/calendar/docs/api/Calendar/data/TimeRangeStore) or a reconfiguring object for a store which will hold time ranges.\n     * These may be used by the [TimeRanges](https://bryntum.com/products/calendar/docs/api/Calendar/feature/TimeRanges) feature.\n     */\n    timeRangeStore ? : TimeRangeStore|TimeRangeStoreConfig\n    /**\n     * Set to a time zone or a UTC offset. This will set the project's\n     * [timeZone](https://bryntum.com/products/calendar/docs/api/Scheduler/model/ProjectModel#config-timeZone) config accordingly. As this config is only a referer,\n     * please see project's config [documentation](https://bryntum.com/products/calendar/docs/api/Scheduler/model/ProjectModel#config-timeZone) for more\n     * information.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-timeZone)\n     */\n    timeZone ? : string|number\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/view/Calendar#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/view/Calendar#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/view/Calendar#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    /**\n     * Configure as `true` to trigger `selectionChange` when removing a selected event/assignment.\n     */\n    triggerSelectionChangeOnRemove ? : boolean\n    type ? : 'calendar'\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/view/Calendar#config-ui)\n     */\n    ui ? : 'plain'|'toolbar'|string|object\n    /**\n     * By default, the day of week and week of month of the event's start date are used to create\n     * helpful contextual recurrence types when editing a non-recurring event record and choosing\n     * an initial recurrence type.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-useContextualRecurrenceRules)\n     */\n    useContextualRecurrenceRules ? : boolean\n    /**\n     * Configuration options to change how the subordinate [Container](https://bryntum.com/products/calendar/docs/api/Core/widget/Container) which contains\n     * the calendar's child views is created.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-viewContainer)\n     */\n    viewContainer ? : ContainerConfig\n    /**\n     * The week start day to be used throughout this Calendar, 0 meaning Sunday, 6 meaning Saturday.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#config-weekStartDay)\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/view/Calendar#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/view/Calendar#config-y)\n     */\n    y ? : number\n\n    // Features\n    /**\n     * This feature provides drag-based event creation and modification for Calendars. When enabled (which is the default\n     * for calendars), the user can do the following via the mouse or touch screen:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag)\n     */\n    dragFeature ? : object|boolean|string|CalendarDrag|CalendarDragConfig\n    /**\n     * A Feature that allows showing additional time before &amp; after an event, to visualize things like travel time - or the time you\n     * need to prepare a room for a meeting + clean it up after.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventBuffer)\n     */\n    eventBufferFeature ? : object|boolean|string|EventBuffer|EventBufferConfig\n    /**\n     * Allow using [Ctrl/CMD + C/X/V] to copy/cut-and-paste events.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventCopyPaste)\n     */\n    eventCopyPasteFeature ? : object|boolean|string|EventCopyPaste|EventCopyPasteConfig\n    /**\n     * Feature that displays a popup containing fields for editing event data.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventEdit)\n     */\n    eventEditFeature ? : object|boolean|string|EventEdit|EventEditConfig\n    /**\n     * A feature which shows a context menu when right-clicking events in the calendar.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventMenu)\n     */\n    eventMenuFeature ? : object|boolean|string|EventMenu|EventMenuConfig\n    /**\n     * A feature which displays a [tooltip](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventTooltip#config-tooltip) containing extra information. The tooltip can\n     * be triggered by clicking or hovering an event bar element (see [showOn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventTooltip#config-showOn)).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/EventTooltip)\n     */\n    eventTooltipFeature ? : object|boolean|string|EventTooltip|EventTooltipConfig\n    /**\n     * A feature that allows exporting Calendar data to Excel or CSV without involving the server. It uses\n     * [TableExporter](https://bryntum.com/products/calendar/docs/api/Grid/util/TableExporter) class as data provider, 3rd party provider to generate XLS files, and\n     * [Microsoft XML specification](https://msdn.microsoft.com/en-us/library/office/documentformat.openxml.spreadsheet.aspx).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/experimental/ExcelExporter)\n     */\n    excelExporterFeature ? : object|boolean|string|ExcelExporter|ExcelExporterConfig\n    /**\n     * A Calendar feature which allows new events to be dragged into the Calendar from an external source.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource)\n     */\n    externalEventSourceFeature ? : object|boolean|string|ExternalEventSource|ExternalEventSourceConfig\n    /**\n     * Loads the host Calendar's [CrudManager](https://bryntum.com/products/calendar/docs/api/Scheduler/view/mixin/SchedulerStores#config-crudManager) on demand\n     * as the date range required to produce the UI changes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/LoadOnDemand)\n     */\n    loadOnDemandFeature ? : object|boolean|string|LoadOnDemand|LoadOnDemandConfig\n    /**\n     * This feature enables printing of the current Calendar mode.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/print/Print)\n     */\n    printFeature ? : object|boolean|string|Print|PrintConfig\n    /**\n     * A feature which adds a context menu to the unoccupied parts of calendar views.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ScheduleMenu)\n     */\n    scheduleMenuFeature ? : object|boolean|string|ScheduleMenu|ScheduleMenuConfig\n    /**\n     * A feature that displays a tooltip containing the time at the mouse position when hovering empty parts of the schedule.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ScheduleTooltip)\n     */\n    scheduleTooltipFeature ? : object|boolean|string|ScheduleTooltip|ScheduleTooltipConfig\n    /**\n     * This feature provides an easy way to highlight ranges of time in a calendar's day and week views. Each time range is\n     * represented using the [TimeRangeModel](https://bryntum.com/products/calendar/docs/api/Calendar/model/TimeRangeModel).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/TimeRanges)\n     */\n    timeRangesFeature ? : object|boolean|string|TimeRanges|TimeRangesConfig\n    /**\n     * A Feature which, when present, adds a week row expansion tool to week rows in\n     * [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView)s so that a row which contains overflowing cells\n     * can be expanded to show all events with no overflow.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/feature/WeekExpander)\n     */\n    weekExpanderFeature ? : object|boolean|string|WeekExpander|WeekExpanderConfig\n\n}\n\n@Component({\n    selector : 'bryntum-calendar',\n    template : ''\n})\nexport class BryntumCalendarComponent implements OnInit, OnDestroy {\n\n    public static instanceClass = Calendar;\n\n    public static instanceName = 'Calendar';\n\n    private static bryntumEvents: string[] = [\n        'onActiveItemChange',\n        'onAfterEventEdit',\n        'onAfterEventSave',\n        'onBeforeActiveItemChange',\n        'onBeforeAssignmentDelete',\n        'onBeforeAssignmentSelectionChange',\n        'onBeforeAutoCreate',\n        'onBeforeCopy',\n        'onBeforeCreateMode',\n        'onBeforeCSVExport',\n        'onBeforeDestroy',\n        'onBeforeDragCreate',\n        'onBeforeDragCreateEnd',\n        'onBeforeDragMove',\n        'onBeforeDragMoveEnd',\n        'onBeforeDragResize',\n        'onBeforeDragResizeEnd',\n        'onBeforeDropExternal',\n        'onBeforeEventDelete',\n        'onBeforeEventEdit',\n        'onBeforeEventEditShow',\n        'onBeforeEventSave',\n        'onBeforeEventSelectionChange',\n        'onBeforeExcelExport',\n        'onBeforeHide',\n        'onBeforePaste',\n        'onBeforePrint',\n        'onBeforeResponsiveStateChange',\n        'onBeforeSetRecord',\n        'onBeforeShow',\n        'onBeforeStateApply',\n        'onBeforeStateSave',\n        'onCatchAll',\n        'onCellOverflowClick',\n        'onCollapse',\n        'onContextMenuItem',\n        'onContextMenuToggleItem',\n        'onCopy',\n        'onCurrentTimelineUpdate',\n        'onDataChange',\n        'onDateChange',\n        'onDateRangeChange',\n        'onDateRangeLoad',\n        'onDateRangeRequested',\n        'onDayCellPopulated',\n        'onDayNumberClick',\n        'onDestroy',\n        'onDirtyStateChange',\n        'onDragCreateEnd',\n        'onDragMoveEnd',\n        'onDragMoveExternal',\n        'onDragResizeEnd',\n        'onDropExternal',\n        'onElementCreated',\n        'onEmptyCellClick',\n        'onEventAutoCreated',\n        'onEventClick',\n        'onEventContextMenu',\n        'onEventDblClick',\n        'onEventEditBeforeSetRecord',\n        'onEventKeyDown',\n        'onEventMenuBeforeShow',\n        'onEventMenuItem',\n        'onEventMenuShow',\n        'onEventMouseDown',\n        'onEventMouseEnter',\n        'onEventMouseLeave',\n        'onEventMouseOut',\n        'onEventMouseOver',\n        'onEventMouseUp',\n        'onEventPropagate',\n        'onExpand',\n        'onFocusIn',\n        'onFocusOut',\n        'onHide',\n        'onLoadOnDemandFail',\n        'onMonthNameClick',\n        'onNavigate',\n        'onPaint',\n        'onPaste',\n        'onPasteNotAllowed',\n        'onReadOnly',\n        'onRecompose',\n        'onRefresh',\n        'onResize',\n        'onResourceClick',\n        'onResponsiveStateChange',\n        'onScheduleClick',\n        'onScheduleContextMenu',\n        'onScheduleDblClick',\n        'onScheduleMenuBeforeShow',\n        'onScheduleMenuItem',\n        'onScheduleMenuShow',\n        'onScheduleMouseDown',\n        'onScheduleMouseOut',\n        'onScheduleMouseOver',\n        'onScheduleMouseUp',\n        'onSelectionChange',\n        'onShow',\n        'onSidebarCollapse',\n        'onSidebarExpand',\n        'onTimeAxisClick',\n        'onTimeRangeHeaderClick',\n        'onTimeRangeHeaderContextMenu',\n        'onTimeRangeHeaderDblClick',\n        'onToolClick',\n        'onViewPaint',\n        'onWeekNumberClick'\n    ];\n\n    private static bryntumFeatureNames: string[] = [\n        'dragFeature',\n        'eventBufferFeature',\n        'eventCopyPasteFeature',\n        'eventEditFeature',\n        'eventMenuFeature',\n        'eventTooltipFeature',\n        'excelExporterFeature',\n        'externalEventSourceFeature',\n        'loadOnDemandFeature',\n        'printFeature',\n        'scheduleMenuFeature',\n        'scheduleTooltipFeature',\n        'timeRangesFeature',\n        'weekExpanderFeature'\n    ];\n\n    private static bryntumConfigs: string[] = BryntumCalendarComponent.bryntumFeatureNames.concat([\n        'activeDateCls',\n        'adopt',\n        'align',\n        'alignSelf',\n        'anchor',\n        'appendTo',\n        'ariaDescription',\n        'ariaLabel',\n        'assignments',\n        'assignmentStore',\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        'config',\n        'constrainTo',\n        'contentElementCls',\n        'contextMenuTriggerEvent',\n        'crudManager',\n        'crudManagerClass',\n        'dataField',\n        'dataset',\n        'date',\n        'dateFormat',\n        'datePicker',\n        'defaultBindProperty',\n        'defaultCalendar',\n        'defaultFocus',\n        'defaults',\n        'deselectAllOnScheduleClick',\n        'deselectOnClick',\n        'destroyStores',\n        'detectCSSCompatibilityIssues',\n        'disabled',\n        'dock',\n        'draggable',\n        'drawer',\n        'elementAttributes',\n        'enableDeleteKey',\n        'enableRecurringEvents',\n        'enableUndoRedoKeys',\n        'events',\n        'eventSelectionDisabled',\n        'eventStore',\n        'extraData',\n        'filterEventResources',\n        'flex',\n        'floating',\n        'footer',\n        'header',\n        'height',\n        'hidden',\n        'hideAnimation',\n        'hideNonWorkingDays',\n        'hideWhenEmpty',\n        'highlightDate',\n        'highlightPredecessors',\n        'highlightSuccessors',\n        'icon',\n        'id',\n        'ignoreParentReadOnly',\n        'includeWeekendsButton',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'isEventSelectable',\n        'itemCls',\n        'items',\n        'keyMap',\n        'labelPosition',\n        'layout',\n        'layoutStyle',\n        'lazyItems',\n        'listeners',\n        'loadMask',\n        'loadMaskDefaults',\n        'loadMaskError',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'maintainSelectionOnDatasetChange',\n        'margin',\n        'maskDefaults',\n        'masked',\n        'maxDate',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minDate',\n        'minHeight',\n        'minWidth',\n        'mode',\n        'modeDefaults',\n        'modes',\n        'monitorResize',\n        'multiEventSelect',\n        'namedItems',\n        'navigatorPlacement',\n        'nonWorkingDays',\n        'overlaySidebar',\n        'owner',\n        'positioned',\n        'preventTooltipOnTouch',\n        'project',\n        'propagatedConfigs',\n        'readOnly',\n        'recurrenceConfirmationPopup',\n        'relayStoreEvents',\n        'rendition',\n        'resourceImagePath',\n        'resources',\n        'resourceStore',\n        'resourceTimeRanges',\n        'resourceTimeRangeStore',\n        'responsive',\n        'responsiveRoot',\n        'responsiveState',\n        'responsiveTarget',\n        'ripple',\n        'rootElement',\n        'rtl',\n        'scrollable',\n        'scrollAction',\n        'selectResourceOnEventNavigate',\n        'selectResourceOnScheduleClick',\n        'showAnimation',\n        'showRecurringUI',\n        'showTooltipWhenDisabled',\n        'sidebar',\n        'span',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'strictRecordMapping',\n        'strips',\n        'syncMask',\n        'tab',\n        'tabBarItems',\n        'tag',\n        'tbar',\n        'textAlign',\n        'timeRanges',\n        'timeRangeStore',\n        'timeZone',\n        'title',\n        'tools',\n        'tooltip',\n        'trapFocus',\n        'triggerSelectionChangeOnRemove',\n        'type',\n        'ui',\n        'useContextualRecurrenceRules',\n        'viewContainer',\n        'weekStartDay',\n        'weight',\n        'width',\n        'x',\n        'y'\n    ]);\n\n    private static bryntumConfigsOnly: string[] = [\n        'adopt',\n        'align',\n        'anchor',\n        'ariaDescription',\n        'ariaLabel',\n        'assignmentStore',\n        'autoCreate',\n        'bbar',\n        'bodyCls',\n        'bubbleEvents',\n        'centered',\n        'collapsible',\n        'color',\n        'config',\n        'constrainTo',\n        'contentElementCls',\n        'contextMenuTriggerEvent',\n        'crudManagerClass',\n        'dataField',\n        'datePicker',\n        'defaultBindProperty',\n        'defaultFocus',\n        'defaults',\n        'deselectOnClick',\n        'destroyStores',\n        'detectCSSCompatibilityIssues',\n        'dock',\n        'draggable',\n        'drawer',\n        'elementAttributes',\n        'enableDeleteKey',\n        'enableRecurringEvents',\n        'enableUndoRedoKeys',\n        'eventSelectionDisabled',\n        'eventStore',\n        'filterEventResources',\n        'floating',\n        'footer',\n        'header',\n        'hideAnimation',\n        'hideWhenEmpty',\n        'highlightDate',\n        'highlightPredecessors',\n        'highlightSuccessors',\n        'icon',\n        'ignoreParentReadOnly',\n        'includeWeekendsButton',\n        'itemCls',\n        'lazyItems',\n        'listeners',\n        'loadMask',\n        'loadMaskDefaults',\n        'loadMaskError',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'maintainSelectionOnDatasetChange',\n        'maskDefaults',\n        'masked',\n        'monitorResize',\n        'multiEventSelect',\n        'namedItems',\n        'navigatorPlacement',\n        'overlaySidebar',\n        'owner',\n        'positioned',\n        'preventTooltipOnTouch',\n        'propagatedConfigs',\n        'relayStoreEvents',\n        'resourceImagePath',\n        'resourceStore',\n        'resourceTimeRangeStore',\n        'responsive',\n        'responsiveRoot',\n        'responsiveState',\n        'responsiveTarget',\n        'ripple',\n        'rootElement',\n        'scrollAction',\n        'showAnimation',\n        'showRecurringUI',\n        'showTooltipWhenDisabled',\n        'sidebar',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'strips',\n        'syncMask',\n        'tab',\n        'tabBarItems',\n        'tag',\n        'tbar',\n        'textAlign',\n        'timeRangeStore',\n        'timeZone',\n        'trapFocus',\n        'triggerSelectionChangeOnRemove',\n        'type',\n        'ui',\n        'viewContainer',\n        'weekStartDay',\n        'weight'\n    ];\n\n    private static bryntumProps: string[] = BryntumCalendarComponent.bryntumFeatureNames.concat([\n        'activeDateCls',\n        'activeSubView',\n        'activeView',\n        'alignSelf',\n        'anchorSize',\n        'appendTo',\n        'assignments',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'cls',\n        'collapsed',\n        'column',\n        'crudManager',\n        'dataset',\n        'date',\n        'dateFormat',\n        'defaultCalendar',\n        'deselectAllOnScheduleClick',\n        'disabled',\n        'events',\n        'extraData',\n        'flex',\n        'focusVisible',\n        'hasChanges',\n        'height',\n        'hidden',\n        'hideNonWorkingDays',\n        'id',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'isEngineReady',\n        'isEventSelectable',\n        'isSettingValues',\n        'isValid',\n        'items',\n        'keyMap',\n        'labelPosition',\n        'layout',\n        'layoutStyle',\n        'margin',\n        'maxDate',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minDate',\n        'minHeight',\n        'minWidth',\n        'mode',\n        'modeDefaults',\n        'modes',\n        'nonWorkingDays',\n        'parent',\n        'project',\n        'readOnly',\n        'record',\n        'recurrenceConfirmationPopup',\n        'rendition',\n        'resources',\n        'resourceTimeRanges',\n        'rtl',\n        'scrollable',\n        'selectedEvents',\n        'selectResourceOnEventNavigate',\n        'selectResourceOnScheduleClick',\n        'span',\n        'state',\n        'strictRecordMapping',\n        'timeRanges',\n        'title',\n        'tools',\n        'tooltip',\n        'useContextualRecurrenceRules',\n        'values',\n        'views',\n        'width',\n        'x',\n        'y'\n    ]);\n\n    private elementRef: ElementRef;\n    public instance!: Calendar;\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() adopt                            ! : HTMLElement|string;\n    @Input() align                            ! : AlignSpec|string;\n    @Input() anchor                           ! : boolean;\n    @Input() ariaDescription                  ! : string;\n    @Input() ariaLabel                        ! : string;\n    @Input() assignmentStore                  ! : AssignmentStore|AssignmentStoreConfig;\n    @Input() autoCreate                       ! : {\n        gesture?: string\n        newName?: Function|string\n        step?: string\n        duration?: string\n        startHour?: number|string\n    }|string|boolean;\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() config                           ! : object;\n    @Input() constrainTo                      ! : HTMLElement|Widget|Rectangle;\n    @Input() contentElementCls                ! : string|object;\n    @Input() contextMenuTriggerEvent          ! : 'contextmenu'|'click'|'dblclick';\n    @Input() crudManagerClass                 ! : SchedulerCrudManager;\n    @Input() dataField                        ! : string;\n    @Input() datePicker                       ! : CalendarDatePickerConfig|boolean|null;\n    @Input() defaultBindProperty              ! : string;\n    @Input() defaultFocus                     ! : ((widget: Widget) => boolean)|string;\n    @Input() defaults                         ! : CalendarContainerItemConfig;\n    @Input() deselectOnClick                  ! : boolean;\n    @Input() destroyStores                    ! : boolean;\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() enableDeleteKey                  ! : boolean;\n    @Input() enableRecurringEvents            ! : boolean|{\n        defaultAction?: 'single'|'future'\n    };\n    @Input() enableUndoRedoKeys               ! : boolean;\n    @Input() eventSelectionDisabled           ! : boolean;\n    @Input() eventStore                       ! : EventStore|EventStoreConfig;\n    @Input() filterEventResources             ! : boolean;\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() header                           ! : string|boolean|PanelHeader;\n    @Input() hideAnimation                    ! : boolean|object;\n    @Input() hideWhenEmpty                    ! : boolean;\n    @Input() highlightDate                    ! : boolean|((date: Date) => boolean);\n    @Input() highlightPredecessors            ! : boolean;\n    @Input() highlightSuccessors              ! : boolean;\n    @Input() icon                             ! : string|DomConfig;\n    @Input() ignoreParentReadOnly             ! : boolean;\n    @Input() includeWeekendsButton            ! : boolean|ButtonConfig;\n    @Input() itemCls                          ! : string;\n    @Input() lazyItems                        ! : Record<string, CalendarContainerItemConfig>|CalendarContainerItemConfig[]|Widget[];\n    @Input() listeners                        ! : CalendarListeners;\n    @Input() loadMask                         ! : string|MaskConfig|null;\n    @Input() loadMaskDefaults                 ! : MaskConfig;\n    @Input() loadMaskError                    ! : MaskConfig|Mask|boolean;\n    @Input() localeClass                      ! : typeof Base;\n    @Input() localizable                      ! : boolean;\n    @Input() localizableProperties            ! : string[];\n    @Input() maintainSelectionOnDatasetChange ! : boolean;\n    @Input() maskDefaults                     ! : MaskConfig;\n    @Input() masked                           ! : boolean|string|MaskConfig;\n    @Input() monitorResize                    ! : boolean|{\n        immediate?: boolean\n    };\n    @Input() multiEventSelect                 ! : boolean|{\n        ctrlKey?: boolean\n        altKey?: boolean\n        shiftKey?: boolean\n    };\n    @Input() namedItems                       ! : Record<string, CalendarContainerItemConfig>;\n    @Input() navigatorPlacement               ! : 'toolbar'|'sidebar';\n    @Input() overlaySidebar                   ! : boolean;\n    @Input() owner                            ! : Widget|any;\n    @Input() positioned                       ! : boolean;\n    @Input() preventTooltipOnTouch            ! : boolean;\n    @Input() propagatedConfigs                ! : string[];\n    @Input() relayStoreEvents                 ! : boolean;\n    @Input() resourceImagePath                ! : string;\n    @Input() resourceStore                    ! : ResourceStore|ResourceStoreConfig;\n    @Input() resourceTimeRangeStore           ! : ResourceTimeRangeStore|ResourceTimeRangeStoreConfig;\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() showAnimation                    ! : boolean|object;\n    @Input() showRecurringUI                  ! : boolean;\n    @Input() showTooltipWhenDisabled          ! : boolean;\n    @Input() sidebar                          ! : {side?: 'left'|'right', collapsed?: boolean, items: { [mode: string]: CalendarContainerItemConfig|null|undefined, datePicker?: DatePickerConfig, eventFilter?: TextFieldConfig, resourceFilter?: ResourceFilterConfig }}|boolean;\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() syncMask                         ! : string|MaskConfig|null;\n    @Input() tab                              ! : boolean|TabConfig;\n    @Input() tabBarItems                      ! : ToolbarItems[]|Widget[];\n    @Input() tag                              ! : string;\n    @Input() tbar                             ! : (CalendarContainerItemConfig|string)[]|ToolbarConfig|CalendarToolbarConfig|null;\n    @Input() textAlign                        ! : 'left'|'center'|'right'|'start'|'end';\n    @Input() timeRangeStore                   ! : TimeRangeStore|TimeRangeStoreConfig;\n    @Input() timeZone                         ! : string|number;\n    @Input() trapFocus                        ! : boolean;\n    @Input() triggerSelectionChangeOnRemove   ! : boolean;\n    @Input() type                             ! : 'calendar';\n    @Input() ui                               ! : 'plain'|'toolbar'|string|object;\n    @Input() viewContainer                    ! : ContainerConfig;\n    @Input() weekStartDay                     ! : number;\n    @Input() weight                           ! : number;\n\n    // Configs and properties\n    @Input() activeDateCls                 ! : string;\n    @Input() alignSelf                     ! : string;\n    @Input() appendTo                      ! : HTMLElement|string;\n    @Input() assignments                   ! : AssignmentModel[]|AssignmentModelConfig[];\n    @Input() callOnFunctions               ! : boolean;\n    @Input() catchEventHandlerExceptions   ! : boolean;\n    @Input() cls                           ! : string|object;\n    @Input() collapsed                     ! : boolean;\n    @Input() column                        ! : number;\n    @Input() crudManager                   ! : SchedulerCrudManager|CrudManagerConfig;\n    @Input() dataset                       ! : object|Record<string, string>;\n    @Input() date                          ! : Date|string;\n    @Input() dateFormat                    ! : string;\n    @Input() defaultCalendar               ! : ResourceModel|string;\n    @Input() deselectAllOnScheduleClick    ! : boolean;\n    @Input() disabled                      ! : boolean|'inert';\n    @Input() events                        ! : EventModel[]|EventModelConfig[];\n    @Input() extraData                     ! : any;\n    @Input() flex                          ! : number|string;\n    @Input() height                        ! : number|string;\n    @Input() hidden                        ! : boolean;\n    @Input() hideNonWorkingDays            ! : boolean;\n    @Input() id                            ! : string;\n    @Input() inputFieldAlign               ! : 'start'|'end';\n    @Input() insertBefore                  ! : HTMLElement|string;\n    @Input() insertFirst                   ! : HTMLElement|string;\n    @Input() isEventSelectable             ! : (event: EventModel) => boolean;\n    @Input() items                         ! : (CalendarContainerItemConfig|MenuItemConfig|Widget)[]|Record<string, CalendarContainerItemConfig|MenuItemConfig>|Widget[]|object|WidgetConfig;\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() minHeight                     ! : string|number;\n    @Input() minWidth                      ! : string|number;\n    @Input() mode                          ! : string|'agenda'|'year'|'month'|'week'|'day'|'list'|'resource'|'dayresource'|'dayagenda'|'monthagenda'|'monthgrid';\n    @Input() modeDefaults                  ! : object;\n    @Input() modes                         ! : Record<string, CalendarView>|object;\n    @Input() nonWorkingDays                ! : Record<number, boolean>;\n    @Input() project                       ! : ProjectModel|ProjectModelConfig|object;\n    @Input() readOnly                      ! : boolean;\n    @Input() recurrenceConfirmationPopup   ! : RecurrenceConfirmationPopupConfig|RecurrenceConfirmationPopup;\n    @Input() rendition                     ! : string|Record<string, string>|null;\n    @Input() resources                     ! : ResourceModel[]|ResourceModelConfig[];\n    @Input() resourceTimeRanges            ! : ResourceTimeRangeModel[]|ResourceTimeRangeModelConfig[];\n    @Input() rtl                           ! : boolean;\n    @Input() scrollable                    ! : Scroller|boolean|ScrollerConfig;\n    @Input() selectResourceOnEventNavigate ! : boolean;\n    @Input() selectResourceOnScheduleClick ! : boolean;\n    @Input() span                          ! : number;\n    @Input() strictRecordMapping           ! : boolean;\n    @Input() timeRanges                    ! : TimeRangeModel[]|TimeRangeModelConfig[];\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() useContextualRecurrenceRules  ! : boolean;\n    @Input() width                         ! : number|string;\n    @Input() x                             ! : number;\n    @Input() y                             ! : number;\n\n    // Properties only\n    @Input() activeSubView   ! : CalendarView;\n    @Input() activeView      ! : CalendarView;\n    @Input() anchorSize      ! : number[];\n    @Input() focusVisible    ! : boolean;\n    @Input() hasChanges      ! : boolean;\n    @Input() isEngineReady   ! : boolean;\n    @Input() isSettingValues ! : boolean;\n    @Input() isValid         ! : boolean;\n    @Input() parent          ! : Widget;\n    @Input() record          ! : Model;\n    @Input() selectedEvents  ! : EventModel[];\n    @Input() state           ! : any;\n    @Input() values          ! : Record<string, object>;\n    @Input() views           ! : CalendarView[];\n\n    // Features\n    @Input() dragFeature                 ! : object|boolean|string|CalendarDrag|CalendarDragConfig;\n    @Input() eventBufferFeature          ! : object|boolean|string|EventBuffer|EventBufferConfig;\n    @Input() eventCopyPasteFeature       ! : object|boolean|string|EventCopyPaste|EventCopyPasteConfig;\n    @Input() eventEditFeature            ! : object|boolean|string|EventEdit|EventEditConfig;\n    @Input() eventMenuFeature            ! : object|boolean|string|EventMenu|EventMenuConfig;\n    @Input() eventTooltipFeature         ! : object|boolean|string|EventTooltip|EventTooltipConfig;\n    @Input() excelExporterFeature        ! : object|boolean|string|ExcelExporter|ExcelExporterConfig;\n    @Input() externalEventSourceFeature  ! : object|boolean|string|ExternalEventSource|ExternalEventSourceConfig;\n    @Input() loadOnDemandFeature         ! : object|boolean|string|LoadOnDemand|LoadOnDemandConfig;\n    @Input() printFeature                ! : object|boolean|string|Print|PrintConfig;\n    @Input() scheduleMenuFeature         ! : object|boolean|string|ScheduleMenu|ScheduleMenuConfig;\n    @Input() scheduleTooltipFeature      ! : object|boolean|string|ScheduleTooltip|ScheduleTooltipConfig;\n    @Input() timeRangesFeature           ! : object|boolean|string|TimeRanges|TimeRangesConfig;\n    @Input() weekExpanderFeature         ! : object|boolean|string|WeekExpander|WeekExpanderConfig;\n\n    // Events emitters\n    /**\n     * Fired when a change of view (Calendar mode) has completed. By default, view changes are animated and this\n     * event fires when the view is fully visible.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar instance.\n     * @param {CalendarView} event.prevActiveItem The previously active view.\n     * @param {CalendarView} event.activeItem The new active view.\n     * @param {boolean} event.containedFocus `true` if the outgoing view contained focus.\n     */\n    @Output() onActiveItemChange: any = new EventEmitter<((event: { source: Calendar, prevActiveItem: CalendarView, activeItem: CalendarView, containedFocus: boolean }) => void)|string>();\n    /**\n     * Fires on the owning Scheduler after editor is closed by any action - save, delete or cancel\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source The scheduler\n     * @param {'save','delete','cancel'} event.action The action that was taken to end the edit. One of 'save', 'delete' or 'cancel'\n     * @param {Scheduler.feature.SchedulerEventEdit} event.eventEdit The eventEdit feature\n     * @param {Scheduler.model.EventModel} event.eventRecord The record that has been edited.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The Resource record for the event. If the event is being created, it will not contain a resource, so this parameter specifies the resource the event is being created for.\n     * @param {HTMLElement} event.eventElement The element which represents the event in the scheduler display.\n     * @param {Core.widget.Popup} event.editor The editor\n     */\n    @Output() onAfterEventEdit: any = new EventEmitter<((event: { source: Scheduler, action: 'save'|'delete'|'cancel', eventEdit: SchedulerEventEdit, eventRecord: EventModel, resourceRecord: ResourceModel, eventElement: HTMLElement, editor: Popup }) => void)|string>();\n    /**\n     * Fires on the owning Scheduler after an event is successfully saved\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source The scheduler instance\n     * @param {Scheduler.model.EventModel} event.eventRecord The record about to be saved\n     */\n    @Output() onAfterEventSave: any = new EventEmitter<((event: { source: Scheduler, eventRecord: EventModel }) => void)|string>();\n    /**\n     * Fired before a change of view (Calendar mode) is initiated.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar instance.\n     * @param {CalendarView} event.prevActiveItem The previously active view.\n     * @param {CalendarView} event.activeItem The new active view.\n     */\n    @Output() onBeforeActiveItemChange: any = new EventEmitter<((event: { source: Calendar, prevActiveItem: CalendarView, activeItem: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before an assignment is removed. Can be triggered by user pressing [DELETE] or [BACKSPACE] or\n     * by the event editor. Can for example be used to display a custom dialog to confirm deletion, in which\n     * case records should be \"manually\" removed after confirmation:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeAssignmentDelete)\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source The Scheduler instance\n     * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment records about to be deleted\n     * @param {object} event.context Additional removal context:\n     * @param {Function} event.context.finalize Function to call to finalize the removal. Used to asynchronously decide to remove the records or not. Provide `false` to the function to prevent the removal.\n     * @param {boolean} event.context.finalize.removeRecords Provide `false` to the function to prevent the removal.\n     */\n    @Output() onBeforeAssignmentDelete: any = new EventEmitter<((event: { source: Scheduler, assignmentRecords: AssignmentModel[], context: { finalize: { removeRecords?: boolean } } }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired any time there is going to be a change to the assignments selected in the Scheduler.\n     * Returning `false` prevents the change\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source This Scheduler instance.\n     * @param {'select','deselect','update','clear'} event.action One of the actions 'select', 'deselect', 'update', 'clear'\n     * @param {Scheduler.model.AssignmentModel[]} event.selected An array of assignments that will be added to the selection.\n     * @param {Scheduler.model.AssignmentModel[]} event.deselected An array of assignments that will be removed from the selection.\n     * @param {Scheduler.model.AssignmentModel[]} event.selection The currently selected assignments, before applying `selected` and `deselected`.\n     */\n    @Output() onBeforeAssignmentSelectionChange: any = new EventEmitter<((event: { source: Scheduler, action: 'select'|'deselect'|'update'|'clear', selected: AssignmentModel[], deselected: AssignmentModel[], selection: AssignmentModel[] }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires whenever a child view's [autoCreate gesture](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate) is detected and also when a [drag-create](#Calendar/feature/CalendarDrag) gesture is detected.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeAutoCreate)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The child view on which the event was initiated.\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     */\n    @Output() onBeforeAutoCreate: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, startDate: Date, endDate: Date, resourceRecord: ResourceModel }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Scheduler before a copy action is performed, return `false` to prevent the action\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Owner scheduler\n     * @param {Scheduler.model.EventModel[]} event.eventRecords The event records about to be copied\n     * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment records about to be copied\n     * @param {boolean} event.isCut `true` if this is a cut action\n     * @param {string} event.entityName 'event' to distinguish this event from other beforeCopy events\n     */\n    @Output() onBeforeCopy: any = new EventEmitter<((event: { source: Scheduler, eventRecords: EventModel[], assignmentRecords: AssignmentModel[], isCut: boolean, entityName: string }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before a mode is created. The configuration block is passed to the handler for possible modification.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar\n     * @param {AgendaViewConfig,DayResourceViewConfig,DayViewConfig,EventListConfig,MonthViewConfig,ResourceViewConfig,WeekViewConfig,YearViewConfig,DayAgendaViewConfig,MonthAgendaViewConfig,CalendarContainerItemConfig} event.config The configuration block of the mode about to be created. Any property, including the `type` may be changed.\n     */\n    @Output() onBeforeCreateMode: any = new EventEmitter<((event: { source: Calendar, config: AgendaViewConfig|DayResourceViewConfig|DayViewConfig|EventListConfig|MonthViewConfig|ResourceViewConfig|WeekViewConfig|YearViewConfig|DayAgendaViewConfig|MonthAgendaViewConfig|CalendarContainerItemConfig }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before CSV export starts. Return `false` to cancel the export.\n     * @param {object} event Event object\n     * @param {ExportConfig} event.config Export config\n     * @param {Grid.column.Column[]} event.columns An array of columns to export\n     * @param {Core.data.Model[]} event.rows An array of records to export\n     * @param {string} event.lineDelimiter The CSV delimiter to separate lines\n     * @param {string} event.columnDelimiter The CSV delimiter to separate values on one line\n     */\n    @Output() onBeforeCSVExport: any = new EventEmitter<((event: { config: ExportConfig, columns: Column[], rows: Model[], lineDelimiter: string, columnDelimiter: string }) => 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     * This event fires on the owning Calendar before a drag creation gesture is started. Return `false` to\n     * veto the operation.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag create context.\n     * @param {Event} event.domEvent The browser event.\n     * @param {Date} event.date The date at the drag DOM event position.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {CalendarView} event.view The Calendar widget in which the drag is being started.\n     */\n    @Output() onBeforeDragCreate: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, domEvent: Event, date: Date, resourceRecord?: ResourceModel, feature: CalendarDrag, view: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Calendar before a drag creation gesture is completed. Return `false` to\n     * immediately veto the operation or a Promise yielding `true` or `false` for async vetoing.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag create context.\n     * @param {Event} event.event The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record being created that has not yet been added in the store.\n     * @param {Date} event.newStartDate The new start date.\n     * @param {Date} event.newEndDate The new end date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {boolean,ValidateCreateResult} event.validation The result of the [validateCreateFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateCreateFn) if one was provided.\n     * @param {CalendarView} event.view The Calendar widget in which the drag completed.\n     */\n    @Output() onBeforeDragCreateEnd: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, event: Event, eventRecord: EventModel, newStartDate: Date, newEndDate: Date, resourceRecord?: ResourceModel, feature: CalendarDrag, validation: boolean|ValidateCreateResult, view: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Calendar before a drag move gesture is started. Return `false` to\n     * veto the operation.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag move context.\n     * @param {Event} event.domEvent The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record being moved.\n     * @param {Date} event.date The date at the drag DOM event position.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {CalendarView} event.view The Calendar widget in which the drag is being started.\n     */\n    @Output() onBeforeDragMove: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, domEvent: Event, eventRecord: EventModel, date: Date, resourceRecord?: ResourceModel, feature: CalendarDrag, view: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Calendar before a drag move gesture is completed. Return `false` to immediately veto the operation\n     * or a Promise yielding `true` or `false` for async vetoing.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag create context.\n     * @param {Event} event.event The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record that has *not yet been updated* in the store.\n     * @param {Scheduler.model.EventModel} event.proxyEventRecord The `EventModel` record that is being used as a proxy for the drag operation and being updated on every pointer move. This will contain changed values based on the drag position.\n     * @param {Date} event.newStartDate The new start date.\n     * @param {Date} event.newEndDate The new end date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {boolean,ValidateCreateResult} event.validation The result of the [validateMoveFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateMoveFn) if one was provided.\n     * @param {CalendarView} event.view The Calendar widget in which the drag completed.\n     */\n    @Output() onBeforeDragMoveEnd: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, event: Event, eventRecord: EventModel, proxyEventRecord: EventModel, newStartDate: Date, newEndDate: Date, resourceRecord?: ResourceModel, feature: CalendarDrag, validation: boolean|ValidateCreateResult, view: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Calendar before a drag resize gesture is started. Return `false` to\n     * veto the operation.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag resize context.\n     * @param {Event} event.domEvent The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record being resized.\n     * @param {Date} event.date The date at the drag DOM event position.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {CalendarView} event.view The Calendar widget in which the drag is being started.\n     */\n    @Output() onBeforeDragResize: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, domEvent: Event, eventRecord: EventModel, date: Date, resourceRecord?: ResourceModel, feature: CalendarDrag, view: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Calendar before a drag resize gesture is completed. Return `false` to immediately veto the operation\n     * or a Promise yielding `true` or `false` for async vetoing.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag create context.\n     * @param {Event} event.event The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The `EventModel` record that has *not yet been updated* in the store.\n     * @param {Scheduler.model.EventModel} event.proxyEventRecord The `EventModel` record that is being used as a proxy for the drag operation and being updated on every pointer move. This will contain changed values based on the drag position.\n     * @param {Date} event.newStartDate The new start date.\n     * @param {Date} event.newEndDate The new end date.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {boolean,ValidateCreateResult} event.validation The result of the [validateResizeFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateResizeFn) if one was provided.\n     * @param {CalendarView} event.view The Calendar widget in which the drag completed.\n     */\n    @Output() onBeforeDragResizeEnd: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, event: Event, eventRecord: EventModel, proxyEventRecord: EventModel, newStartDate: Date, newEndDate: Date, feature: CalendarDrag, validation: boolean|ValidateCreateResult, view: CalendarView }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event is fired on the owning Calendar when dropping an event from the calendar on the\n     * external source <strong>if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) was configured</strong>. Returning `false`\n     * prevents the gesture from being completed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeDropExternal)\n     * @param {object} event Event object\n     * @param {Scheduler.model.EventModel} event.eventRecord The event record being dragged.\n     * @param {boolean} event.dropOnCalendar `true` if the drop gesture is over the client Calendar. This feature also allows drag *out* of the Calendar and onto the external event source if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) config is set.\n     * @param {HTMLElement} event.itemElement The element in which the drag gesture started.\n     * @param {HTMLElement} event.targetElement The current over element.\n     * @param {Event} event.domEvent The pointer event associated with the drag point.\n     * @param {number} event.overIndex *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the index of the row being moved over;\n     * @param {Core.data.Model} event.overRecord *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the record being moved over;\n     * @param {boolean} event.isAbove *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, `true` if the pointer position is above the halfway line of the over row.\n     * @param {boolean} event.altKey `true` if the Alt key was down when the last event was processed.\n     * @param {boolean} event.ctrlKey `true` if the Ctrl key was down when the last event was processed.\n     * @param {boolean} event.metaKey `true` if the Meta key was down when the last event was processed.\n     * @param {boolean} event.shiftKey `true` if the Shift key was down when the last event was processed.\n     */\n    @Output() onBeforeDropExternal: any = new EventEmitter<((event: { eventRecord: EventModel, dropOnCalendar: boolean, itemElement: HTMLElement, targetElement: HTMLElement, domEvent: Event, overIndex: number, overRecord: Model, isAbove: boolean, altKey: boolean, ctrlKey: boolean, metaKey: boolean, shiftKey: boolean }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before an event is removed. Can be triggered by user pressing [DELETE] or [BACKSPACE] or by the\n     * event editor. Can for example be used to display a custom dialog to confirm deletion, in which case\n     * records should be \"manually\" removed after confirmation:\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeEventDelete)\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance\n     * @param {Scheduler.model.EventModel[]} event.eventRecords The records about to be deleted\n     * @param {object} event.context Additional removal context:\n     * @param {Function} event.context.finalize Function to call to finalize the removal. Used to asynchronously decide to remove the records or not. Provide `false` to the function to prevent the removal.\n     * @param {boolean} event.context.finalize.removeRecords Provide `false` to the function to prevent the removal.\n     */\n    @Output() onBeforeEventDelete: any = new EventEmitter<((event: { source: Calendar, eventRecords: EventModel[], context: { finalize: { removeRecords?: boolean } } }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Scheduler before an event is displayed in an editor.\n     * This may be listened for to allow an application to take over event editing duties. Returning `false`\n     * stops the default editing UI from being shown.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeEventEdit)\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source The scheduler\n     * @param {Scheduler.feature.SchedulerEventEdit} event.eventEdit The eventEdit feature\n     * @param {Scheduler.model.EventModel} event.eventRecord The record about to be shown in the event editor.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The Resource record for the event. If the event is being created, it will not contain a resource, so this parameter specifies the resource the event is being created for.\n     * @param {HTMLElement} event.eventElement The element which represents the event in the scheduler display.\n     */\n    @Output() onBeforeEventEdit: any = new EventEmitter<((event: { source: Scheduler, eventEdit: SchedulerEventEdit, eventRecord: EventModel, resourceRecord: ResourceModel, eventElement: HTMLElement }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Scheduler when the editor for an event is available but before it is populated with\n     * data and shown. Allows manipulating fields etc.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source The scheduler\n     * @param {Scheduler.feature.SchedulerEventEdit} event.eventEdit The eventEdit feature\n     * @param {Scheduler.model.EventModel} event.eventRecord The record about to be shown in the event editor.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The Resource record for the event. If the event is being created, it will not contain a resource, so this parameter specifies the resource the event is being created for.\n     * @param {HTMLElement} event.eventElement The element which represents the event in the scheduler display.\n     * @param {Core.widget.Popup} event.editor The editor\n     */\n    @Output() onBeforeEventEditShow: any = new EventEmitter<((event: { source: Scheduler, eventEdit: SchedulerEventEdit, eventRecord: EventModel, resourceRecord: ResourceModel, eventElement: HTMLElement, editor: Popup }) => void)|string>();\n    /**\n     * Fires on the owning Scheduler before an event is saved.\n     * Return `false` to immediately prevent saving\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-beforeEventSave)\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source The scheduler instance\n     * @param {Scheduler.model.EventModel} event.eventRecord The record about to be saved\n     * @param {Scheduler.model.ResourceModel[]} event.resourceRecords The resources to which the event is assigned\n     * @param {object} event.values The new values\n     * @param {object} event.context Extended save context:\n     * @param {boolean} event.context.async Set this to `true` in a listener to indicate that the listener will asynchronously decide to prevent or not the event save.\n     * @param {Function} event.context.finalize Function to call to finalize the save. Used when `async` is `true`. Provide `false` to the function to prevent the save.\n     */\n    @Output() onBeforeEventSave: any = new EventEmitter<((event: { source: Scheduler, eventRecord: EventModel, resourceRecords: ResourceModel[], values: object, context: { async?: boolean, finalize: Function } }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired any time there is going to be a change to the events selected in the Scheduler.\n     * Returning `false` prevents the change\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source This Scheduler instance.\n     * @param {'select','deselect','update','clear'} event.action One of the actions 'select', 'deselect', 'update', 'clear'\n     * @param {Scheduler.model.EventModel[]} event.selected An array of events that will be added to the selection.\n     * @param {Scheduler.model.EventModel[]} event.deselected An array of events that will be removed from the selection.\n     * @param {Scheduler.model.EventModel[]} event.selection The currently selected events, before applying `selected` and `deselected`.\n     */\n    @Output() onBeforeEventSelectionChange: any = new EventEmitter<((event: { source: Scheduler, action: 'select'|'deselect'|'update'|'clear', selected: EventModel[], deselected: EventModel[], selection: EventModel[] }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before Excel export starts. Return `false` to cancel the export.\n     * @param {object} event Event object\n     * @param {ExportConfig} event.config Export config\n     * @param {XLSColumn[]} event.columns An array of columns to export\n     * @param {any[][]} event.rows An array of records to export\n     */\n    @Output() onBeforeExcelExport: any = new EventEmitter<((event: { config: ExportConfig, columns: XLSColumn[], rows: any[] }) => Promise<boolean>|boolean|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     * Fires on the owning Scheduler before a paste action is performed, return `false` to prevent the action.\n     * Depending on if the EventStore is using [singleAssignment](https://bryntum.com/products/calendar/docs/api/Scheduler/data/EventStore#config-singleAssignment) or the\n     * configuration of [copyPasteAction](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/EventCopyPaste#config-copyPasteAction), either the `eventRecords` or the `assignmentRecords` param\n     * will be populated with record copies.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Owner scheduler\n     * @param {Scheduler.model.EventModel[]} event.eventRecords The events about to be pasted\n     * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignments about to be pasted\n     * @param {Scheduler.model.EventModel[]} event.originalEventRecords The original event records\n     * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecords The original assignment record\n     * @param {Date} event.date The date when the pasted events will be scheduled\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The target resource record, the clipboard event records will be assigned to this resource.\n     * @param {boolean} event.isCut `true` if this is a cut action\n     * @param {string} event.entityName 'event' to distinguish this event from other beforePaste events\n     */\n    @Output() onBeforePaste: any = new EventEmitter<((event: { source: Scheduler, eventRecords: EventModel[], assignmentRecords: AssignmentModel[], originalEventRecords: EventModel[], originalAssignmentRecords: AssignmentModel[], date: Date, resourceRecord: ResourceModel, isCut: boolean, entityName: string }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Calendar before print starts. Return `false` to cancel the print.\n     * @param {object} event Event object\n     * @param {object} event.config Print config\n     */\n    @Output() onBeforePrint: any = new EventEmitter<((event: { config: object }) => 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/view/Calendar#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     * Fires when a cell overflow indicator is clicked or activated by the <kbd>ENTER</kbd> key in any view. This will include\n     * the cells of a [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView) and the `+ n more` overflow\n     * indicator of cells in a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView), and \"all day\" events section\n     * of a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView).\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date clicked on.\n     */\n    @Output() onCellOverflowClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date }) => 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     * This event fires on the owning widget when an item is selected in the context menu.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The owning widget\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     */\n    @Output() onContextMenuItem: any = new EventEmitter<((event: { source: Widget, menu: Menu, item: MenuItem }) => void)|string>();\n    /**\n     * This event fires on the owning widget when a check item is toggled in the context menu.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The owning widget\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     * @param {boolean} event.checked Checked or not\n     */\n    @Output() onContextMenuToggleItem: any = new EventEmitter<((event: { source: Widget, menu: Menu, item: MenuItem, checked: boolean }) => void)|string>();\n    /**\n     * Fires on the owning Scheduler after a copy action is performed. Depending on if the EventStore is using\n     * [singleAssignment](https://bryntum.com/products/calendar/docs/api/Scheduler/data/EventStore#config-singleAssignment) or the configuration of\n     * [copyPasteAction](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/EventCopyPaste#config-copyPasteAction), either the `eventRecords` or the `assignmentRecords` param will be populated\n     * with record copies.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Owner scheduler\n     * @param {Scheduler.model.EventModel[]} event.eventRecords The event record copies\n     * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment record copies\n     * @param {Scheduler.model.EventModel[]} event.originalEventRecords The event records that were copied\n     * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecord The assignment records that were copied\n     * @param {boolean} event.isCut `true` if this is a cut action\n     * @param {string} event.entityName 'event' to distinguish this event from other copy events\n     */\n    @Output() onCopy: any = new EventEmitter<((event: { source: Scheduler, eventRecords: EventModel[], assignmentRecords: AssignmentModel[], originalEventRecords: EventModel[], originalAssignmentRecord: AssignmentModel[], isCut: boolean, entityName: string }) => void)|string>();\n    /**\n     * Fires on the owning Scheduler/Gantt when the line indicating the current time is updated (see [currentTimeLineUpdateInterval](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/TimeRanges#config-currentTimeLineUpdateInterval)).\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source The scheduler\n     * @param {Date} event.date The current date\n     */\n    @Output() onCurrentTimelineUpdate: any = new EventEmitter<((event: { source: Scheduler, date: Date }) => void)|string>();\n    /**\n     * Fired when data in any of the projects stores changes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dataChange)\n     * @param {object} event Event object\n     * @param {typeof Scheduler.data.mixin.ProjectConsumer,any} event.source Owning component\n     * @param {typeof Scheduler.model.mixin.ProjectModelMixin,any} event.project Project model\n     * @param {Core.data.Store} event.store Affected store\n     * @param {'remove','removeAll','add','clearchanges','filter','update','dataset','replace'} event.action Name of action which triggered the change. May be one of:  * `'remove'` * `'removeAll'` * `'add'` * `'clearchanges'` * `'filter'` * `'update'` * `'dataset'` * `'replace'`\n     * @param {Core.data.Model} event.record Changed record, for actions that affects exactly one record (`'update'`)\n     * @param {Core.data.Model[]} event.records Changed records, passed for all actions except `'removeAll'`\n     * @param {object} event.changes Passed for the `'update'` action, info on which record fields changed\n     */\n    @Output() onDataChange: any = new EventEmitter<((event: { source: typeof ProjectConsumer|any, project: typeof ProjectModelMixin|any, store: Store, action: 'remove'|'removeAll'|'add'|'clearchanges'|'filter'|'update'|'dataset'|'replace', record: Model, records: Model[], changes: object }) => void)|string>();\n    /**\n     * Fires when the calendar changes the date that it orientates its views around.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dateChange)\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar.\n     * @param {Date} event.oldDate The previous Calendar date.\n     * @param {Date} event.date The new Calendar date.\n     */\n    @Output() onDateChange: any = new EventEmitter<((event: { source: Calendar, oldDate: Date, date: Date }) => void)|string>();\n    /**\n     * Fired when the eventStore is queried for events by date range, and the date range\n     * requested is different from the last time the store was queried.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dateRangeChange)\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar instance\n     * @param {object} event.old The old date range\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() onDateRangeChange: any = new EventEmitter<((event: { source: Calendar, old: { startDate: Date, endDate: Date }, new: { startDate: Date, endDate: Date } }) => void)|string>();\n    /**\n     * Fires when the [LoadOnDemand](https://bryntum.com/products/calendar/docs/api/Calendar/feature/LoadOnDemand) feature has loaded a range of events.\n     * @param {object} event Event object\n     * @param {object} event.response The decoded JSON response.\n     * @param {object} event.options The options object passed into the CrudManager [CrudManager](https://bryntum.com/products/calendar/docs/api/Scheduler/data/CrudManager) [load](https://bryntum.com/products/calendar/docs/api/Scheduler/crud/AbstractCrudManagerMixin#function-load) method.\n     * @param {Date} event.startDate The start date of the range to request.\n     * @param {Date} event.endDate The end date of the range to request. <strong>Note that Dates are timestamps</strong>.\n     */\n    @Output() onDateRangeLoad: any = new EventEmitter<((event: { response: object, options: object, startDate: Date, endDate: Date }) => void)|string>();\n    /**\n     * Fired <strong>every</strong> time the eventStore is queried for events by date range.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dateRangeRequested)\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar instance\n     * @param {object} event.old The old date range\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     * @param {boolean} event.changed `true` if the date range is different from the last time a request was made\n     */\n    @Output() onDateRangeRequested: any = new EventEmitter<((event: { source: Calendar, old: { startDate: Date, endDate: Date }, new: { startDate: Date, endDate: Date }, changed: boolean }) => void)|string>();\n    /**\n     * Fired by the active view 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/view/Calendar#event-dayCellPopulated)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\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: { source: CalendarView, events: EventModel[], The: Date }) => void)|string>();\n    /**\n     * Fires when a day number is clicked or activated by the <kbd>ENTER</kbd> key in a view which shows day numbers.\n     * This will include the cells of a [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView), the cell header of cells\n     * in a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView), and the day header in a [DayView](#Calendar/widget/DayView).\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dayNumberClick)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date clicked on.\n     * @param {DayCell} event.cellData An object that contains data about the calendar cell for the date.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onDayNumberClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, cellData: DayCell, fromOverflowPopup: boolean }) => Promise<boolean>|boolean|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     * This event fires on the owning Calendar when a drag creation gesture is completed.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag create context.\n     * @param {Event} event.event The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The new `EventModel` record added in the store.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {boolean,ValidateCreateResult} event.validation The result of the [validateCreateFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateCreateFn) if one was provided.\n     * @param {CalendarView} event.view The Calendar widget in which the drag completed.\n     */\n    @Output() onDragCreateEnd: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, event: Event, eventRecord: EventModel, resourceRecord?: ResourceModel, feature: CalendarDrag, validation: boolean|ValidateCreateResult, view: CalendarView }) => void)|string>();\n    /**\n     * This event fires on the owning Calendar when a drag move gesture is completed. The `eventRecord` has already been added\n     * to the `eventStore` of the owning calendar.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag create context.\n     * @param {Event} event.event The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The updated `EventModel` record.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The `ResourceModel` record if the gesture was performed in a resource-type view.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {boolean,ValidateCreateResult} event.validation The result of the [validateMoveFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateMoveFn) if one was provided.\n     * @param {CalendarView} event.view The Calendar widget in which the drag completed.\n     */\n    @Output() onDragMoveEnd: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, event: Event, eventRecord: EventModel, resourceRecord?: ResourceModel, feature: CalendarDrag, validation: boolean|ValidateCreateResult, view: CalendarView }) => void)|string>();\n    /**\n     * This event is fired on the owning Calendar when dragging an event from the calendar over the\n     * external source <strong>if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) was configured</strong>.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dragMoveExternal)\n     * @param {object} event Event object\n     * @param {Scheduler.model.EventModel} event.eventRecord The event record being dragged.\n     * @param {HTMLElement} event.itemElement The element in which the drag gesture started.\n     * @param {HTMLElement} event.targetElement The current over element.\n     * @param {Event} event.domEvent The pointer event associated with the drag point.\n     * @param {number} event.overIndex *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the index of the row being moved over;\n     * @param {Core.data.Model} event.overRecord *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the record being moved over;\n     * @param {boolean} event.isAbove *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, `true` if the pointer position is above the halfway line of the over row.\n     * @param {boolean} event.altKey `true` if the Alt key was down when the last event was processed.\n     * @param {boolean} event.ctrlKey `true` if the Ctrl key was down when the last event was processed.\n     * @param {boolean} event.metaKey `true` if the Meta key was down when the last event was processed.\n     * @param {boolean} event.shiftKey `true` if the Shift key was down when the last event was processed.\n     */\n    @Output() onDragMoveExternal: any = new EventEmitter<((event: { eventRecord: EventModel, itemElement: HTMLElement, targetElement: HTMLElement, domEvent: Event, overIndex: number, overRecord: Model, isAbove: boolean, altKey: boolean, ctrlKey: boolean, metaKey: boolean, shiftKey: boolean }) => void)|string>();\n    /**\n     * This event fires on the owning Calendar when a drag resize gesture is completed.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance that fired the event.\n     * @param {Core.util.drag.DragContext} event.drag The drag create context.\n     * @param {Event} event.event The browser event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The updated `EventModel` record.\n     * @param {Calendar.feature.CalendarDrag} event.feature The Calendar drag feature instance.\n     * @param {boolean,ValidateCreateResult} event.validation The result of the [validateResizeFn](https://bryntum.com/products/calendar/docs/api/Calendar/feature/CalendarDrag#config-validateResizeFn) if one was provided.\n     * @param {CalendarView} event.view The Calendar widget in which the drag completed.\n     */\n    @Output() onDragResizeEnd: any = new EventEmitter<((event: { source: Calendar, drag: DragContext, event: Event, eventRecord: EventModel, feature: CalendarDrag, validation: boolean|ValidateCreateResult, view: CalendarView }) => void)|string>();\n    /**\n     * This event is fired on the owning Calendar after dropping an event from the calendar on the\n     * external source has been completed <strong>if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) was configured</strong>.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-dropExternal)\n     * @param {object} event Event object\n     * @param {Scheduler.model.EventModel} event.eventRecord The event record that was dropped.\n     * @param {boolean} event.dropOnCalendar `true` if the drop gesture is over the client Calendar. This feature also allows drag *out* of the Calendar and onto the external event source if the [droppable](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-droppable) config is set.\n     * @param {HTMLElement} event.itemElement The element in which the drag gesture started.\n     * @param {HTMLElement} event.targetElement The current over element.\n     * @param {Event} event.domEvent The pointer event associated with the drag point.\n     * @param {number} event.overIndex *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the index of the row being moved over;\n     * @param {Core.data.Model} event.overRecord *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, the record being moved over;\n     * @param {boolean} event.isAbove *If [grid](https://bryntum.com/products/calendar/docs/api/Calendar/feature/ExternalEventSource#config-grid) was specified*, `true` if the pointer position is above the halfway line of the over row.\n     * @param {boolean} event.altKey `true` if the Alt key was down when the last event was processed.\n     * @param {boolean} event.ctrlKey `true` if the Ctrl key was down when the last event was processed.\n     * @param {boolean} event.metaKey `true` if the Meta key was down when the last event was processed.\n     * @param {boolean} event.shiftKey `true` if the Shift key was down when the last event was processed.\n     */\n    @Output() onDropExternal: any = new EventEmitter<((event: { eventRecord: EventModel, dropOnCalendar: boolean, itemElement: HTMLElement, targetElement: HTMLElement, domEvent: Event, overIndex: number, overRecord: Model, isAbove: boolean, altKey: boolean, ctrlKey: boolean, metaKey: boolean, shiftKey: 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 empty cell content area is clicked on in a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView) or a\n     * [CalendarRow](https://bryntum.com/products/calendar/docs/api/Calendar/widget/CalendarRow).\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The child view on which the event was initiated.\n     * @param {Event} event.domEvent The triggering DOM event.\n     * @param {Date} event.date The date which has no visible events\n     */\n    @Output() onEmptyCellClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date }) => void)|string>();\n    /**\n     * Fired when an [autoCreate](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/CalendarMixin#config-autoCreate) gesture has\n     * created a new event and added it to the event store.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-eventAutoCreated)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The child view on which the event was initiated.\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 an event bar is clicked in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event clicked on.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource clicked on if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fires when an event bar is right-clicked in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event right-clicked on.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource right-clicked on if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventContextMenu: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fires when an event bar is double clicked in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event double clicked on.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource double clicked on if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventDblClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fired before the editor will load the event record data into its input fields. This is useful if you\n     * want to modify the fields 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 editor widget\n     * @param {Scheduler.model.EventModel} event.record The record\n     */\n    @Output() onEventEditBeforeSetRecord: any = new EventEmitter<((event: { source: Container, record: EventModel }) => void)|string>();\n    /**\n     * Fires when a key is pressed while an event bar is focused.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event in which the key event was detected.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource in which the key event was detected if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventKeyDown: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * This event fires on the owning Scheduler before the context menu is shown for an event. Allows manipulation of the items\n     * to show in the same way as in `processItems`. Returning `false` from a listener prevents the menu from\n     * being shown.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source\n     * @param {Record<string, MenuItemEntry>} event.items Menu item configs\n     * @param {Scheduler.model.EventModel} event.eventRecord Event record for which the menu was triggered\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord Resource record\n     * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used\n     * @param {HTMLElement} event.eventElement\n     * @param {MouseEvent} event.event Pointer event which triggered the context menu (if any)\n     */\n    @Output() onEventMenuBeforeShow: any = new EventEmitter<((event: { source: Scheduler, items: Record<string, MenuItemEntry>, eventRecord: EventModel, resourceRecord: ResourceModel, assignmentRecord: AssignmentModel, eventElement: HTMLElement, event?: MouseEvent }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Scheduler when an item is selected in the context menu.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source\n     * @param {Core.widget.MenuItem} event.item\n     * @param {Scheduler.model.EventModel} event.eventRecord\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord\n     * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used\n     * @param {HTMLElement} event.eventElement\n     */\n    @Output() onEventMenuItem: any = new EventEmitter<((event: { source: Scheduler, item: MenuItem, eventRecord: EventModel, resourceRecord: ResourceModel, assignmentRecord: AssignmentModel, eventElement: HTMLElement }) => void)|string>();\n    /**\n     * This event fires on the owning Scheduler after showing the context menu for an event\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Scheduler.model.EventModel} event.eventRecord Event record for which the menu was triggered\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord Resource record\n     * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used\n     * @param {HTMLElement} event.eventElement\n     */\n    @Output() onEventMenuShow: any = new EventEmitter<((event: { source: Scheduler, menu: Menu, eventRecord: EventModel, resourceRecord: ResourceModel, assignmentRecord: AssignmentModel, eventElement: HTMLElement }) => void)|string>();\n    /**\n     * Fires when an event bar is mousedowned in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event mousedowned on.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mousedowned on if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventMouseDown: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fires when cursor enters an event bar in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event record.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventMouseEnter: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fires when cursor leaves an event bar in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event record.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventMouseLeave: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fires when an event bar is mouseouted in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event mouseouted.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mouseouted if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventMouseOut: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fires when an event bar is mouseovered in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event mouseovered.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mouseovered if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventMouseOver: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => void)|string>();\n    /**\n     * Fires when an event bar is mouseupped in any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement The UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord The event mouseupped.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource mouseupped if the UI includes a resource.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onEventMouseUp: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => 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/view/Calendar#event-eventPropagate)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\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: { source: CalendarView, 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 the [LoadOnDemand](https://bryntum.com/products/calendar/docs/api/Calendar/feature/LoadOnDemand) feature detects that a request\n     * for data from the server has failed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-loadOnDemandFail)\n     * @param {object} event Event object\n     * @param {Response} event.rawResponse The HTTP `fetch` response object.\n     * @param {object} event.request The CrudManager load data block.\n     * @param {object} event.response The decoded JSON response.\n     */\n    @Output() onLoadOnDemandFail: any = new EventEmitter<((event: { rawResponse: any, request: object, response: object }) => void)|string>();\n    /**\n     * Fires when a month name header in a [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView) or a [MonthGrid](#Calendar/widget/MonthGrid) is clicked\n     * or activated by the <kbd>ENTER</kbd> key.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-monthNameClick)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {number} event.month The month index *(zero based)* clicked on.\n     * @param {Date} event.date The date of the first of the month clicked on.\n     */\n    @Output() onMonthNameClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, month: number, date: Date }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired when a user gesture causes the active item to change.\n     * @param {object} event Event object\n     * @param {Event} event.event The browser event which instigated navigation. May be a click or key or focus event.\n     * @param {HTMLElement,null} event.item The newly active item, or `null` if focus moved out.\n     * @param {HTMLElement,null} event.oldItem The previously active item, or `null` if focus is moving in.\n     */\n    @Output() onNavigate: any = new EventEmitter<((event: { event: Event, item: HTMLElement|null, oldItem: HTMLElement|null }) => 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/view/Calendar#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     * Fires on the owning Scheduler after a paste action is performed.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Owner scheduler\n     * @param {Scheduler.model.EventModel[]} event.eventRecords The pasted event records\n     * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The pasted assignment records\n     * @param {Scheduler.model.EventModel[]} event.pastedEventRecords (DEPRECATED) Use eventRecords instead\n     * @param {Scheduler.model.EventModel[]} event.originalEventRecords The original copied event records\n     * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecords The original copied assignment records\n     * @param {Date} event.date date Pasted to this date\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The target resource record\n     * @param {boolean} event.isCut `true` if this is a cut action\n     * @param {string} event.entityName 'event' to distinguish this event from other paste events\n     */\n    @Output() onPaste: any = new EventEmitter<((event: { source: Scheduler, eventRecords: EventModel[], assignmentRecords: AssignmentModel[], pastedEventRecords: EventModel[], originalEventRecords: EventModel[], originalAssignmentRecords: AssignmentModel[], date: Date, resourceRecord: ResourceModel, isCut: boolean, entityName: string }) => void)|string>();\n    /**\n     * Fires on the owning Scheduler if a paste action is not allowed. Depending on if the EventStore is using\n     * [singleAssignment](https://bryntum.com/products/calendar/docs/api/Scheduler/data/EventStore#config-singleAssignment) or the configuration of\n     * [copyPasteAction](https://bryntum.com/products/calendar/docs/api/Scheduler/feature/EventCopyPaste#config-copyPasteAction), either the `eventRecords` or the `assignmentRecords` param will be populated\n     * with record copies.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Owner scheduler\n     * @param {Scheduler.model.EventModel[]} event.eventRecords The event records about to be pasted\n     * @param {Scheduler.model.AssignmentModel[]} event.assignmentRecords The assignment records about to be pasted\n     * @param {Scheduler.model.EventModel[]} event.originalEventRecords The event records that were copied\n     * @param {Scheduler.model.AssignmentModel[]} event.originalAssignmentRecords The assignment records that were copied\n     * @param {Date} event.date The paste date\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The target resource record\n     * @param {boolean} event.isCut `true` if this is a cut action\n     * @param {string} event.entityName 'event' to distinguish this event from other `pasteNotAllowed` events\n     * @param {'overlappingEvents','resourceReadOnly'} event.reason A string id to use for displaying an error message to the user.\n     */\n    @Output() onPasteNotAllowed: any = new EventEmitter<((event: { source: Scheduler, eventRecords: EventModel[], assignmentRecords: AssignmentModel[], originalEventRecords: EventModel[], originalAssignmentRecords: AssignmentModel[], date: Date, resourceRecord: ResourceModel, isCut: boolean, entityName: string, reason: 'overlappingEvents'|'resourceReadOnly' }) => 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 one of the views in this Calendar refreshes.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which refreshed.\n     */\n    @Output() onRefresh: any = new EventEmitter<((event: { source: CalendarView }) => 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     * Fires when a click event is received by a view which supports resources.\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-resourceClick)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date of the UI element which contains the event.\n     * @param {HTMLElement} event.eventElement *If* an event was interacted with, the UI element which represents the event.\n     * @param {Scheduler.model.EventModel} event.eventRecord *If* an event was interacted with.\n     * @param {HTMLElement} event.resourceElement The UI element which encapsulates the resource.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the target element.\n     * @param {boolean} event.fromOverflowPopup `true` if the interaction was through the source view's [overflowPopup](https://bryntum.com/products/calendar/docs/api/Calendar/widget/mixin/DayCellRenderer#property-overflowPopup).\n     */\n    @Output() onResourceClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, eventElement: HTMLElement, eventRecord: EventModel, resourceElement: HTMLElement, resourceRecord: ResourceModel, fromOverflowPopup: boolean }) => 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     * Fires when a click made its way through to an empty part of any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date clicked on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.\n     */\n    @Output() onScheduleClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, resourceRecord: ResourceModel }) => void)|string>();\n    /**\n     * Fires when a context menu made its way through to an empty part of any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date clicked on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.\n     */\n    @Output() onScheduleContextMenu: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, resourceRecord: ResourceModel }) => void)|string>();\n    /**\n     * Fires when a dblclick made its way through to an empty part of any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date double clicked on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.\n     */\n    @Output() onScheduleDblClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, resourceRecord: ResourceModel }) => void)|string>();\n    /**\n     * This event fires on the owning Scheduler or Gantt widget before the context menu is shown for the schedule.\n     * Allows manipulation of the items to show in the same way as in `processItems`. Returning `false` from a listener\n     * prevents the menu from being shown.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source\n     * @param {Record<string, MenuItemEntry>} event.items Menu item configs\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord Resource record\n     * @param {Date} event.date Clicked date, rounded according to viewPreset's settings\n     * @param {Scheduler.model.AssignmentModel} event.assignmentRecord Assignment record, if assignments are used\n     * @param {HTMLElement} event.eventElement\n     */\n    @Output() onScheduleMenuBeforeShow: any = new EventEmitter<((event: { source: Scheduler, items: Record<string, MenuItemEntry>, resourceRecord: ResourceModel, date: Date, assignmentRecord: AssignmentModel, eventElement: HTMLElement }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Scheduler or Gantt widget when an item is selected in the context menu.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source\n     * @param {Core.widget.MenuItem} event.item\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord\n     * @param {Date} event.date Clicked date, rounded according to viewPreset's settings\n     * @param {HTMLElement} event.element\n     */\n    @Output() onScheduleMenuItem: any = new EventEmitter<((event: { source: Scheduler, item: MenuItem, resourceRecord: ResourceModel, date: Date, element: HTMLElement }) => void)|string>();\n    /**\n     * This event fires on the owning Scheduler or Gantt widget after showing the context menu for the schedule.\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source\n     * @param {Record<string, MenuItemEntry>} event.items Menu item configs\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord\n     * @param {Date} event.date Clicked date, rounded according to viewPreset's settings\n     * @param {HTMLElement} event.targetElement\n     */\n    @Output() onScheduleMenuShow: any = new EventEmitter<((event: { source: Scheduler, items: Record<string, MenuItemEntry>, menu: Menu, resourceRecord: ResourceModel, date: Date, targetElement: HTMLElement }) => void)|string>();\n    /**\n     * Fires when a mousedown made its way through to an empty part of any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date mousedowned on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.\n     */\n    @Output() onScheduleMouseDown: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, resourceRecord: ResourceModel }) => void)|string>();\n    /**\n     * Fires when a mouseout made it's way through to an empty part of any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date mouseouted. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.\n     */\n    @Output() onScheduleMouseOut: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, resourceRecord: ResourceModel }) => void)|string>();\n    /**\n     * Fires when a mouseover made its way through to an empty part of any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date mouseovered. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.\n     */\n    @Output() onScheduleMouseOver: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, resourceRecord: ResourceModel }) => void)|string>();\n    /**\n     * Fires when a mouseup made its way through to an empty part of any view.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {Date} event.date The date mouseupped on. _Note that in a [DayView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/DayView), this will include granular time information. For other views, this is the *start* of the date.\n     * @param {Scheduler.model.ResourceModel} event.resourceRecord The resource associated with the view if any. Only [ResourceView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/ResourceView) or a [DayResourceView](#Calendar/widget/DayResourceView) will include this.\n     */\n    @Output() onScheduleMouseUp: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, date: Date, resourceRecord: ResourceModel }) => void)|string>();\n    /**\n     * Fired any time there is a change to the events selected in the Calendar.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source The Calendar instance.\n     * @param {'select','deselect','update','clear'} event.action One of the actions 'select', 'deselect', 'update', 'clear'\n     * @param {Scheduler.model.EventModel[]} event.selected An array of the Events added to the selection.\n     * @param {Scheduler.model.EventModel[]} event.deselected An array of the Event removed from the selection.\n     * @param {Scheduler.model.EventModel[]} event.selection The new selection.\n     */\n    @Output() onSelectionChange: any = new EventEmitter<((event: { source: Calendar, action: 'select'|'deselect'|'update'|'clear', selected: EventModel[], deselected: EventModel[], selection: EventModel[] }) => 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     * Fired when the sidebar is collapsed either through the UI or programatically.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar instance\n     */\n    @Output() onSidebarCollapse: any = new EventEmitter<((event: { source: Calendar }) => void)|string>();\n    /**\n     * Fired when the sidebar is expanded either through the UI or programatically.\n     * @param {object} event Event object\n     * @param {Calendar.view.Calendar} event.source This Calendar instance\n     */\n    @Output() onSidebarExpand: any = new EventEmitter<((event: { source: Calendar }) => void)|string>();\n    /**\n     * Fired when a time axis of a DayView or WeekView 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 {CalendarView} event.source The view which triggered the event.\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: { source: CalendarView, domEvent: Event, preciseTime: Date, time: Date }) => void)|string>();\n    /**\n     * Fired on the owning Scheduler or Gantt widget when a click happens on a time range header element\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Scheduler instance\n     * @param {Scheduler.model.TimeSpan} event.timeRangeRecord The record\n     * @param {MouseEvent} event.domEvent Browser event\n     */\n    @Output() onTimeRangeHeaderClick: any = new EventEmitter<((event: { source: Scheduler, timeRangeRecord: TimeSpan, domEvent: MouseEvent }) => void)|string>();\n    /**\n     * Fired on the owning Scheduler or Gantt widget when a right click happens on a time range header element\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Scheduler instance\n     * @param {Scheduler.model.TimeSpan} event.timeRangeRecord The record\n     * @param {MouseEvent} event.domEvent Browser event\n     */\n    @Output() onTimeRangeHeaderContextMenu: any = new EventEmitter<((event: { source: Scheduler, timeRangeRecord: TimeSpan, domEvent: MouseEvent }) => void)|string>();\n    /**\n     * Fired on the owning Scheduler or Gantt widget when a double click happens on a time range header element\n     * @param {object} event Event object\n     * @param {Scheduler.view.Scheduler} event.source Scheduler instance\n     * @param {Scheduler.model.TimeSpan} event.timeRangeRecord The record\n     * @param {MouseEvent} event.domEvent Browser event\n     */\n    @Output() onTimeRangeHeaderDblClick: any = new EventEmitter<((event: { source: Scheduler, timeRangeRecord: TimeSpan, domEvent: MouseEvent }) => 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     * Fires when one of the child views is painted. That is when it becomes visible.\n     * Note that due to the slide-in animation, while the view is visible, it will not\n     * yet be in its final position.\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The widget being painted\n     * @param {boolean} event.firstPaint `true` if this is the first paint\n     */\n    @Output() onViewPaint: any = new EventEmitter<((event: { source: CalendarView, firstPaint: boolean }) => void)|string>();\n    /**\n     * Fires when a week number is clicked or activated by the <kbd>ENTER</kbd> key. This will include the week number cells of a\n     * [YearView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/YearView), the week number in the first cell\n     * in each row of a [MonthView](https://bryntum.com/products/calendar/docs/api/Calendar/widget/MonthView)\n     * ...\n     * [View online docs...](https://bryntum.com/products/calendar/docs/api/Calendar/view/Calendar#event-weekNumberClick)\n     * @param {object} event Event object\n     * @param {CalendarView} event.source The view which triggered the event.\n     * @param {Event} event.domEvent The initiating DOM event.\n     * @param {number[]} event.week The `[year, week]` clicked on.\n     * @param {Date} event.date The date clicked on.\n     */\n    @Output() onWeekNumberClick: any = new EventEmitter<((event: { source: CalendarView, domEvent: Event, week: number[], date: Date }) => Promise<boolean>|boolean|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            } = BryntumCalendarComponent;\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        // Backwards compatibility for gridInstance, schedulerInstance etc.\n        // @ts-ignore\n        me[StringHelper.uncapitalize(instanceName) + 'Instance'] = me.instance;\n        // \n    }\n\n    /**\n     * Watch for changes\n     * @param changes\n     */\n    ngOnChanges(changes: SimpleChanges): void {\n        const\n            { instance } = this,\n            { instanceName } = BryntumCalendarComponent;\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 } = BryntumCalendarComponent;\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"]}