@bryntum/taskboard-angular-thin 7.1.1

package/esm2015/lib/bryntum-task-board.component.js

@@ -0,0 +1,1683 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Angular wrapper for Bryntum TaskBoard
+ */
+import { Component, EventEmitter, Output, Input } from '@angular/core';
+import WrapperHelper from './wrapper.helper';
+import { Widget } from '@bryntum/core-thin';
+import { TaskBoard } from '@bryntum/taskboard-thin';
+import { StringHelper } from '@bryntum/core-thin';
+import * as i0 from "@angular/core";
+export class BryntumTaskBoardComponent {
+    constructor(element) {
+        this.bryntumConfig = {
+            adopt: undefined,
+            appendTo: undefined,
+            href: undefined,
+            angularComponent: this,
+            features: {},
+            listeners: {}
+        };
+        // Events emitters
+        /**
+         * Triggered when a task is "activated" by pressing `Enter` or double clicking it.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-activateTask)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Task record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onActivateTask = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard before column dragging starts. Return `false` to prevent the action
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column to be dragged
+         */
+        this.onBeforeColumnDrag = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when dropping a column, before the operation completes. Handles async
+         * listeners, returning `false` from one will abort the operation
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeColumnDrop)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Dropped column
+         * @param {TaskBoard.model.ColumnModel} event.beforeColumn Dropped before this column
+         */
+        this.onBeforeColumnDrop = new EventEmitter();
+        /**
+         * This event is fired prior to starting a column resize gesture. The resize is canceled if a listener returns
+         * `false`.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The TaskBoard instance
+         * @param {TaskBoard.model.ColumnModel} event.column The column
+         * @param {Event} event.domEvent The browser event
+         */
+        this.onBeforeColumnResize = new EventEmitter();
+        /**
+         * Fires before an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onBeforeDestroy = new EventEmitter();
+        /**
+         * Triggered before a widget is hidden. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being hidden.
+         */
+        this.onBeforeHide = new EventEmitter();
+        /**
+         * Triggered before a new [responsiveState](https://bryntum.com/products/taskboard/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();
+        /**
+         * 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();
+        /**
+         * Fires on the owning TaskBoard before displaying an inline editor. Returning `false` stops the editor from
+         * being shown.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeSimpleTaskEdit)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The task board
+         * @param {TaskBoard.feature.SimpleTaskEdit} event.simpleTaskEdit The simpleTaskEdit feature
+         * @param {TaskBoard.model.TaskModel} event.taskRecord The record about to be shown in the editor
+         * @param {string} event.field Field name being edited
+         */
+        this.onBeforeSimpleTaskEdit = 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 on the owning TaskBoard before task dragging starts. Return `false` to prevent the action
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Tasks to be dragged
+         * @param {Event} event.domEvent The mouse event
+         */
+        this.onBeforeTaskDrag = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when tasks are dropped, before the operation completes. Handles async
+         * listeners, returning `false` from one will abort the operation
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskDrop)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dropped tasks
+         * @param {TaskBoard.model.ColumnModel} event.targetColumn Dropped on this column
+         * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Dropped in this swimlane (if used)
+         * @param {Event} event.domEvent The mouse event
+         */
+        this.onBeforeTaskDrop = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard before a task is displayed in an editor.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskEdit)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The owning TaskBoard
+         * @param {TaskBoard.model.TaskModel} event.taskRecord The record about to be shown in the task editor
+         */
+        this.onBeforeTaskEdit = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when the editor for a task is available, but before it is populated with data
+         * and shown. Allows manipulating fields etc.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskEditShow)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The owning TaskBoard
+         * @param {TaskBoard.model.TaskModel} event.taskRecord The record about to be shown in the task editor
+         * @param {TaskBoard.widget.TaskEditor} event.editor The editor
+         */
+        this.onBeforeTaskEditShow = new EventEmitter();
+        /**
+         * Triggered when one or more tasks are to be removed by a call to `removeTask()`.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskRemove)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Task records to be removed
+         */
+        this.onBeforeTaskRemove = new EventEmitter();
+        /**
+         * Fires when any other event is fired from the object.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#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();
+        /**
+         * This event fires on the owning TaskBoard when an item is selected in the column header menu.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord The column
+         */
+        this.onCellMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning TaskBoard after the context menu is shown for a column header.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord The column
+         */
+        this.onCellMenuShow = new EventEmitter();
+        /**
+         * This event fires on the owning TaskBoard when a check item is toggled in the column header menu.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord The column
+         * @param {boolean} event.checked Checked or not
+         */
+        this.onCellMenuToggleItem = new EventEmitter();
+        /**
+         * Fires when a Panel is collapsed using the [collapsible](https://bryntum.com/products/taskboard/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();
+        /**
+         * Triggered when a column is collapsed.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         */
+        this.onColumnCollapse = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when a column is dragged, if the drag leads to a change compared to
+         * the last columnDrag event.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnDrag)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column being dragged
+         * @param {TaskBoard.model.ColumnModel} event.beforeColumn Insert before this column on drop, `null` if last
+         */
+        this.onColumnDrag = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when a drag operation is aborted (invalid drop or aborted using ESC)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Dragged column
+         */
+        this.onColumnDragAbort = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when a previously started drag operation ends, no matter the
+         * outcome of it (whether valid, invalid or aborted)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Affected column
+         */
+        this.onColumnDragEnd = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when column dragging starts
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column to be dragged
+         */
+        this.onColumnDragStart = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when a column is successfully dropped (after the drop transition
+         * has finished)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Dropped column
+         * @param {TaskBoard.model.ColumnModel} event.beforeColumn Dropped before this column (`null` if last)
+         * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Dropped in this swimlane (if used)
+         */
+        this.onColumnDrop = new EventEmitter();
+        /**
+         * Triggered when a column is expanded.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         */
+        this.onColumnExpand = new EventEmitter();
+        /**
+         * Triggered when the column filter is hidden.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         */
+        this.onColumnFilterHide = new EventEmitter();
+        /**
+         * Triggered when the column filter is displayed.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         */
+        this.onColumnFilterShow = new EventEmitter();
+        /**
+         * Triggered when the column filter visibility is toggled.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {boolean} event.visible True if filter popup is visible, false otherwise
+         */
+        this.onColumnFilterToggle = new EventEmitter();
+        /**
+         * Triggered when a column header is clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onColumnHeaderClick = new EventEmitter();
+        /**
+         * Triggered when a column header is right-clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderContextMenu)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onColumnHeaderContextMenu = new EventEmitter();
+        /**
+         * Triggered when a column header is double-clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderDblClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onColumnHeaderDblClick = new EventEmitter();
+        /**
+         * This event fires on the owning TaskBoard before the menu is shown for a column header.
+         * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnHeaderMenu#config-processItems).
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderMenuBeforeShow)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord The column
+         */
+        this.onColumnHeaderMenuBeforeShow = new EventEmitter();
+        /**
+         * This event is fired after a resize gesture is completed.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The TaskBoard instance
+         * @param {TaskBoard.model.ColumnModel} event.column The column
+         * @param {Event} event.domEvent The browser event
+         */
+        this.onColumnResize = new EventEmitter();
+        /**
+         * This event is fired when a column resize gesture starts.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The TaskBoard instance
+         * @param {TaskBoard.model.ColumnModel} event.column The column
+         * @param {Event} event.domEvent The browser event
+         */
+        this.onColumnResizeStart = new EventEmitter();
+        /**
+         * Triggered when a column title element is clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnTitleClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onColumnTitleClick = new EventEmitter();
+        /**
+         * Triggered when a column title element is right-clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnTitleContextMenu)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onColumnTitleContextMenu = new EventEmitter();
+        /**
+         * Triggered when a column title element is double-clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnTitleDblClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onColumnTitleDblClick = new EventEmitter();
+        /**
+         * Triggered when the column collapsed state is toggled.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record
+         * @param {boolean} event.collapse `true` if the column is being collapsed.
+         */
+        this.onColumnToggle = 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/taskboard/docs/api/Core/widget/Container#property-hasChanges) property changes
+         * @param {object} event Event object
+         * @param {Core.widget.Container} event.source The container.
+         * @param {boolean} event.dirty The dirty state of the Container - `true` if there are any fields which have been changed since initial load.
+         */
+        this.onDirtyStateChange = new EventEmitter();
+        /**
+         * Triggered when a widget's [element](https://bryntum.com/products/taskboard/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();
+        /**
+         * Fires when a Panel is expanded using the [collapsible](https://bryntum.com/products/taskboard/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();
+        /**
+         * Triggered when a widget which had been in a non-visible state for any reason
+         * achieves visibility.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-paint)
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being painted.
+         * @param {boolean} event.firstPaint `true` if this is the first paint.
+         */
+        this.onPaint = new EventEmitter();
+        /**
+         * Fired when 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/taskboard/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.
+         */
+        this.onRecompose = new EventEmitter();
+        /**
+         * Triggered when a tasks element is removed.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-removeTaskElement)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance
+         * @param {string,number} event.taskId Id of the task (not the record itself since it might be removed)
+         * @param {HTMLElement} event.element Tasks element
+         */
+        this.onRemoveTaskElement = new EventEmitter();
+        /**
+         * Triggered when a task is rendered.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-renderTask)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Task being rendered
+         * @param {boolean} event.isRefresh `true` if the element was updated, `false` if it was added
+         * @param {HTMLElement} event.element Tasks element
+         */
+        this.onRenderTask = new EventEmitter();
+        /**
+         * Triggered when all tasks in the task board are rendered
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Tasks being rendered
+         */
+        this.onRenderTasks = new EventEmitter();
+        /**
+         * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-monitorResize) is `true`*.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source This Widget
+         * @param {number} event.width The new width
+         * @param {number} event.height The new height
+         * @param {number} event.oldWidth The old width
+         * @param {number} event.oldHeight The old height
+         */
+        this.onResize = new EventEmitter();
+        /**
+         * Triggered when a new [responsiveState](https://bryntum.com/products/taskboard/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();
+        /**
+         * Triggered when task selection changes.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance
+         * @param {'select','deselect'} event.action Either 'select' or 'deselect', depending on operation
+         * @param {TaskBoard.model.TaskModel[]} event.selection All currently selected tasks
+         * @param {TaskBoard.model.TaskModel[]} event.select Tasks selected by the operation
+         * @param {TaskBoard.model.TaskModel[]} event.deselect Tasks deselected by the operation
+         */
+        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();
+        /**
+         * Fires on the owning TaskBoard when inline editing of a field is cancelled (by pressing ESC).
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-simpleTaskEditCancel)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The task board
+         * @param {TaskBoard.feature.SimpleTaskEdit} event.simpleTaskEdit The simpleTaskEdit feature
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Record that was edited
+         * @param {string} event.field Field name being edited
+         */
+        this.onSimpleTaskEditCancel = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when inline editing of a field has successfully finished.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-simpleTaskEditComplete)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The task board
+         * @param {TaskBoard.feature.SimpleTaskEdit} event.simpleTaskEdit The simpleTaskEdit feature
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Record that was edited
+         * @param {string} event.field Field name being edited
+         */
+        this.onSimpleTaskEditComplete = new EventEmitter();
+        /**
+         * Triggered when a swimlane is collapsed.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record
+         */
+        this.onSwimlaneCollapse = new EventEmitter();
+        /**
+         * Triggered when a swimlane is expanded.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record
+         */
+        this.onSwimlaneExpand = new EventEmitter();
+        /**
+         * Triggered when a swimlane header is clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-swimlaneHeaderClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onSwimlaneHeaderClick = new EventEmitter();
+        /**
+         * Triggered when a swimlane header is right-clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-swimlaneHeaderContextMenu)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onSwimlaneHeaderContextMenu = new EventEmitter();
+        /**
+         * Triggered when a swimlane header is double-clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-swimlaneHeaderDblClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onSwimlaneHeaderDblClick = new EventEmitter();
+        /**
+         * Triggered when the swimlane collapsed state is toggled.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record
+         * @param {boolean} event.collapse `true` if the column is being collapsed.
+         */
+        this.onSwimlaneToggle = new EventEmitter();
+        /**
+         * Triggered when a card is clicked.
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Task record
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onTaskClick = new EventEmitter();
+        /**
+         * Triggered when a card is double-clicked
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskDblClick)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Task record
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onTaskDblClick = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when tasks are dragged, if the drag leads to any changes compared to
+         * the last taskDrag event (moved to a new column or changed order within a column).
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskDrag)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dragged tasks
+         * @param {TaskBoard.model.ColumnModel} event.targetColumn Currently over this column
+         * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Currently over this swimlane (if used)
+         * @param {Event} event.domEvent The mouse event
+         */
+        this.onTaskDrag = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when a drag operation is aborted (invalid drop or aborted using ESC)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dragged tasks
+         */
+        this.onTaskDragAbort = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when a previously started drag operation ends, no matter the
+         * outcome of it (whether valid, invalid or aborted)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Affected tasks
+         * @param {Event} event.domEvent The mouse event
+         */
+        this.onTaskDragEnd = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when task dragging starts
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Tasks to be dragged
+         * @param {Event} event.domEvent The mouse event
+         */
+        this.onTaskDragStart = new EventEmitter();
+        /**
+         * Fires on the owning TaskBoard when tasks are successfully dropped (after the drop transition has
+         * finished)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard
+         * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dropped tasks
+         * @param {TaskBoard.model.ColumnModel} event.targetColumn Dropped on this column
+         * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Dropped in this swimlane (if used)
+         * @param {Event} event.domEvent The mouse event
+         */
+        this.onTaskDrop = new EventEmitter();
+        /**
+         * This event fires on the owning TaskBoard before the context menu is shown for a task.
+         * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/TaskMenu#config-processItems).
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskMenuBeforeShow)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {TaskBoard.model.TaskModel} event.taskRecord The task
+         */
+        this.onTaskMenuBeforeShow = new EventEmitter();
+        /**
+         * This event fires on the owning TaskBoard when an item is selected in the task context menu.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {TaskBoard.model.TaskModel} event.taskRecord The task
+         */
+        this.onTaskMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning TaskBoard after the context menu is shown for a task.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {TaskBoard.model.TaskModel} event.taskRecord The task
+         */
+        this.onTaskMenuShow = new EventEmitter();
+        /**
+         * This event fires on the owning TaskBoard when a check item is toggled in the task context menu.
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {TaskBoard.model.TaskModel} event.taskRecord The task
+         * @param {boolean} event.checked Checked or not
+         */
+        this.onTaskMenuToggleItem = new EventEmitter();
+        /**
+         * Triggered when the mouse enters a card
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskMouseEnter)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Task record
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onTaskMouseEnter = new EventEmitter();
+        /**
+         * Triggered when the mouse leaves a card
+         * ...
+         * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskMouseLeave)
+         * @param {object} event Event object
+         * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard
+         * @param {TaskBoard.model.TaskModel} event.taskRecord Task record
+         * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column
+         * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)
+         * @param {MouseEvent} event.event Browser event
+         */
+        this.onTaskMouseLeave = new EventEmitter();
+        /**
+         * A header [tool](https://bryntum.com/products/taskboard/docs/api/Core/widget/Panel#config-tools) has been clicked.
+         * @param {object} event Event object
+         * @param {Core.widget.Tool} event.source This Panel.
+         * @param {Core.widget.Tool} event.tool The tool which is being clicked.
+         */
+        this.onToolClick = new EventEmitter();
+        this.elementRef = element;
+    }
+    /**
+     * Create and append the underlying widget
+     */
+    ngOnInit() {
+        const me = this, { elementRef, bryntumConfig } = me, { instanceClass, instanceName, bryntumConfigs, bryntumEvents } = BryntumTaskBoardComponent;
+        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 } = BryntumTaskBoardComponent;
+        if (!instance) {
+            return;
+        }
+        // Iterate over all changes
+        Object.entries(changes).forEach(([prop, change]) => {
+            const newValue = change.currentValue, { instance } = this, { bryntumConfigsOnly, bryntumProps } = BryntumTaskBoardComponent;
+            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();
+        }
+    }
+}
+BryntumTaskBoardComponent.instanceClass = TaskBoard;
+BryntumTaskBoardComponent.instanceName = 'TaskBoard';
+BryntumTaskBoardComponent.bryntumEvents = [
+    'onActivateTask',
+    'onBeforeColumnDrag',
+    'onBeforeColumnDrop',
+    'onBeforeColumnResize',
+    'onBeforeDestroy',
+    'onBeforeHide',
+    'onBeforeResponsiveStateChange',
+    'onBeforeShow',
+    'onBeforeSimpleTaskEdit',
+    'onBeforeStateApply',
+    'onBeforeStateSave',
+    'onBeforeTaskDrag',
+    'onBeforeTaskDrop',
+    'onBeforeTaskEdit',
+    'onBeforeTaskEditShow',
+    'onBeforeTaskRemove',
+    'onCatchAll',
+    'onCellMenuItem',
+    'onCellMenuShow',
+    'onCellMenuToggleItem',
+    'onCollapse',
+    'onColumnCollapse',
+    'onColumnDrag',
+    'onColumnDragAbort',
+    'onColumnDragEnd',
+    'onColumnDragStart',
+    'onColumnDrop',
+    'onColumnExpand',
+    'onColumnFilterHide',
+    'onColumnFilterShow',
+    'onColumnFilterToggle',
+    'onColumnHeaderClick',
+    'onColumnHeaderContextMenu',
+    'onColumnHeaderDblClick',
+    'onColumnHeaderMenuBeforeShow',
+    'onColumnResize',
+    'onColumnResizeStart',
+    'onColumnTitleClick',
+    'onColumnTitleContextMenu',
+    'onColumnTitleDblClick',
+    'onColumnToggle',
+    'onDestroy',
+    'onDirtyStateChange',
+    'onElementCreated',
+    'onExpand',
+    'onFocusIn',
+    'onFocusOut',
+    'onHide',
+    'onPaint',
+    'onReadOnly',
+    'onRecompose',
+    'onRemoveTaskElement',
+    'onRenderTask',
+    'onRenderTasks',
+    'onResize',
+    'onResponsiveStateChange',
+    'onSelectionChange',
+    'onShow',
+    'onSimpleTaskEditCancel',
+    'onSimpleTaskEditComplete',
+    'onSwimlaneCollapse',
+    'onSwimlaneExpand',
+    'onSwimlaneHeaderClick',
+    'onSwimlaneHeaderContextMenu',
+    'onSwimlaneHeaderDblClick',
+    'onSwimlaneToggle',
+    'onTaskClick',
+    'onTaskDblClick',
+    'onTaskDrag',
+    'onTaskDragAbort',
+    'onTaskDragEnd',
+    'onTaskDragStart',
+    'onTaskDrop',
+    'onTaskMenuBeforeShow',
+    'onTaskMenuItem',
+    'onTaskMenuShow',
+    'onTaskMenuToggleItem',
+    'onTaskMouseEnter',
+    'onTaskMouseLeave',
+    'onToolClick'
+];
+BryntumTaskBoardComponent.bryntumFeatureNames = [
+    'columnDragFeature',
+    'columnFilterFeature',
+    'columnHeaderMenuFeature',
+    'columnLockFeature',
+    'columnRenameFeature',
+    'columnResizeFeature',
+    'columnSortFeature',
+    'columnToolbarsFeature',
+    'filterBarFeature',
+    'simpleTaskEditFeature',
+    'swimlaneDragFeature',
+    'taskDragFeature',
+    'taskDragSelectFeature',
+    'taskEditFeature',
+    'taskMenuFeature',
+    'taskTooltipFeature'
+];
+BryntumTaskBoardComponent.bryntumConfigs = BryntumTaskBoardComponent.bryntumFeatureNames.concat([
+    'activateTaskEvent',
+    'adopt',
+    'align',
+    'alignSelf',
+    'anchor',
+    'appendTo',
+    'ariaDescription',
+    'ariaLabel',
+    'assignments',
+    'autoGenerateColumns',
+    'autoGenerateSwimlanes',
+    'bbar',
+    'bodyCls',
+    'bodyItems',
+    'bubbleEvents',
+    'callOnFunctions',
+    'cardSizes',
+    'catchEventHandlerExceptions',
+    'centered',
+    'chainFilters',
+    'cls',
+    'collapsed',
+    'collapseTitle',
+    'collapsible',
+    'color',
+    'column',
+    'columnField',
+    'columns',
+    'columnTitleRenderer',
+    'config',
+    'constrainTo',
+    'css',
+    'cssVarPrefix',
+    'dataField',
+    'dataset',
+    'detectCSSCompatibilityIssues',
+    'disabled',
+    'dock',
+    'draggable',
+    'drawer',
+    'drawOnScroll',
+    'elementAttributes',
+    'extraData',
+    'flex',
+    'floating',
+    'footer',
+    'footerItems',
+    'getTaskHeight',
+    'header',
+    'headerItems',
+    'height',
+    'hidden',
+    'hideAnimation',
+    'htmlEncodeHeaderText',
+    'icon',
+    'id',
+    'ignoreParentReadOnly',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'isTaskSelectable',
+    'keyMap',
+    'labelPosition',
+    'listeners',
+    'loadMask',
+    'loadMaskDefaults',
+    'loadMaskError',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'margin',
+    'maskDefaults',
+    'masked',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minHeight',
+    'minWidth',
+    'newTaskDefaults',
+    'owner',
+    'plugins',
+    'positioned',
+    'processItems',
+    'project',
+    'readOnly',
+    'record',
+    'relayStoreEvents',
+    'rendition',
+    'resourceImagePath',
+    'resources',
+    'responsive',
+    'responsiveRoot',
+    'responsiveState',
+    'responsiveTarget',
+    'rootElement',
+    'rtl',
+    'scrollable',
+    'scrollAction',
+    'scrollManager',
+    'scrollOptions',
+    'selectedTasks',
+    'selectOnNavigation',
+    'showAnimation',
+    'showCollapseInHeader',
+    'showCollapseTooltip',
+    'showCountInHeader',
+    'span',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'stickyHeaders',
+    'stretchCards',
+    'strictRecordMapping',
+    'strips',
+    'swimlaneField',
+    'swimlaneRenderer',
+    'swimlanes',
+    'syncMask',
+    'tab',
+    'tabBarItems',
+    'taskRenderer',
+    'tasks',
+    'taskSorterFn',
+    'tasksPerRow',
+    'tbar',
+    'title',
+    'tools',
+    'type',
+    'ui',
+    'useDomTransition',
+    'virtualize',
+    'weight',
+    'width',
+    'x',
+    'y'
+]);
+BryntumTaskBoardComponent.bryntumConfigsOnly = [
+    'activateTaskEvent',
+    'adopt',
+    'align',
+    'anchor',
+    'ariaDescription',
+    'ariaLabel',
+    'autoGenerateColumns',
+    'autoGenerateSwimlanes',
+    'bbar',
+    'bodyCls',
+    'bubbleEvents',
+    'cardSizes',
+    'centered',
+    'chainFilters',
+    'collapseTitle',
+    'collapsible',
+    'color',
+    'columnTitleRenderer',
+    'config',
+    'constrainTo',
+    'cssVarPrefix',
+    'dataField',
+    'detectCSSCompatibilityIssues',
+    'dock',
+    'draggable',
+    'drawer',
+    'elementAttributes',
+    'floating',
+    'footer',
+    'header',
+    'hideAnimation',
+    'htmlEncodeHeaderText',
+    'icon',
+    'ignoreParentReadOnly',
+    'listeners',
+    'loadMask',
+    'loadMaskDefaults',
+    'loadMaskError',
+    'localeClass',
+    'localizable',
+    'localizableProperties',
+    'maskDefaults',
+    'masked',
+    'newTaskDefaults',
+    'owner',
+    'plugins',
+    'positioned',
+    'processItems',
+    'record',
+    'relayStoreEvents',
+    'resourceImagePath',
+    'responsive',
+    'responsiveRoot',
+    'responsiveState',
+    'responsiveTarget',
+    'rootElement',
+    'scrollable',
+    'scrollAction',
+    'scrollManager',
+    'scrollOptions',
+    'selectOnNavigation',
+    'showAnimation',
+    'showCollapseInHeader',
+    'showCountInHeader',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'stickyHeaders',
+    'strips',
+    'swimlaneRenderer',
+    'syncMask',
+    'tab',
+    'tabBarItems',
+    'taskRenderer',
+    'taskSorterFn',
+    'tasksPerRow',
+    'tbar',
+    'type',
+    'ui',
+    'useDomTransition',
+    'weight'
+];
+BryntumTaskBoardComponent.bryntumProps = BryntumTaskBoardComponent.bryntumFeatureNames.concat([
+    'alignSelf',
+    'anchorSize',
+    'appendTo',
+    'assignments',
+    'bodyItems',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'cls',
+    'collapsed',
+    'column',
+    'columnField',
+    'columns',
+    'css',
+    'dataset',
+    'disabled',
+    'drawOnScroll',
+    'extraData',
+    'flex',
+    'focusVisible',
+    'footerItems',
+    'getTaskHeight',
+    'hasChanges',
+    'headerItems',
+    'height',
+    'hidden',
+    'id',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'isTaskSelectable',
+    'keyMap',
+    'labelPosition',
+    'margin',
+    'maxHeight',
+    'maximizeOnMobile',
+    'maxWidth',
+    'minHeight',
+    'minWidth',
+    'parent',
+    'project',
+    'readOnly',
+    'rendition',
+    'resources',
+    'rtl',
+    'selectedTasks',
+    'showCollapseTooltip',
+    'span',
+    'state',
+    'stretchCards',
+    'strictRecordMapping',
+    'swimlaneField',
+    'swimlanes',
+    'tasks',
+    'title',
+    'tools',
+    'virtualize',
+    'width',
+    'x',
+    'y'
+]);
+BryntumTaskBoardComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumTaskBoardComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+BryntumTaskBoardComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.0", type: BryntumTaskBoardComponent, selector: "bryntum-task-board", inputs: { activateTaskEvent: "activateTaskEvent", adopt: "adopt", align: "align", anchor: "anchor", ariaDescription: "ariaDescription", ariaLabel: "ariaLabel", autoGenerateColumns: "autoGenerateColumns", autoGenerateSwimlanes: "autoGenerateSwimlanes", bbar: "bbar", bodyCls: "bodyCls", bubbleEvents: "bubbleEvents", cardSizes: "cardSizes", centered: "centered", chainFilters: "chainFilters", collapseTitle: "collapseTitle", collapsible: "collapsible", color: "color", columnTitleRenderer: "columnTitleRenderer", config: "config", constrainTo: "constrainTo", cssVarPrefix: "cssVarPrefix", dataField: "dataField", detectCSSCompatibilityIssues: "detectCSSCompatibilityIssues", dock: "dock", draggable: "draggable", drawer: "drawer", elementAttributes: "elementAttributes", floating: "floating", footer: "footer", header: "header", hideAnimation: "hideAnimation", htmlEncodeHeaderText: "htmlEncodeHeaderText", icon: "icon", ignoreParentReadOnly: "ignoreParentReadOnly", listeners: "listeners", loadMask: "loadMask", loadMaskDefaults: "loadMaskDefaults", loadMaskError: "loadMaskError", localeClass: "localeClass", localizable: "localizable", localizableProperties: "localizableProperties", maskDefaults: "maskDefaults", masked: "masked", newTaskDefaults: "newTaskDefaults", owner: "owner", plugins: "plugins", positioned: "positioned", processItems: "processItems", record: "record", relayStoreEvents: "relayStoreEvents", resourceImagePath: "resourceImagePath", responsive: "responsive", responsiveRoot: "responsiveRoot", responsiveState: "responsiveState", responsiveTarget: "responsiveTarget", rootElement: "rootElement", scrollable: "scrollable", scrollAction: "scrollAction", scrollManager: "scrollManager", scrollOptions: "scrollOptions", selectOnNavigation: "selectOnNavigation", showAnimation: "showAnimation", showCollapseInHeader: "showCollapseInHeader", showCountInHeader: "showCountInHeader", stateful: "stateful", statefulEvents: "statefulEvents", stateId: "stateId", stateProvider: "stateProvider", stickyHeaders: "stickyHeaders", strips: "strips", swimlaneRenderer: "swimlaneRenderer", syncMask: "syncMask", tab: "tab", tabBarItems: "tabBarItems", taskRenderer: "taskRenderer", taskSorterFn: "taskSorterFn", tasksPerRow: "tasksPerRow", tbar: "tbar", type: "type", ui: "ui", useDomTransition: "useDomTransition", weight: "weight", alignSelf: "alignSelf", appendTo: "appendTo", assignments: "assignments", bodyItems: "bodyItems", callOnFunctions: "callOnFunctions", catchEventHandlerExceptions: "catchEventHandlerExceptions", cls: "cls", collapsed: "collapsed", column: "column", columnField: "columnField", columns: "columns", css: "css", dataset: "dataset", disabled: "disabled", drawOnScroll: "drawOnScroll", extraData: "extraData", flex: "flex", footerItems: "footerItems", getTaskHeight: "getTaskHeight", headerItems: "headerItems", height: "height", hidden: "hidden", id: "id", inputFieldAlign: "inputFieldAlign", insertBefore: "insertBefore", insertFirst: "insertFirst", isTaskSelectable: "isTaskSelectable", keyMap: "keyMap", labelPosition: "labelPosition", margin: "margin", maxHeight: "maxHeight", maximizeOnMobile: "maximizeOnMobile", maxWidth: "maxWidth", minHeight: "minHeight", minWidth: "minWidth", project: "project", readOnly: "readOnly", rendition: "rendition", resources: "resources", rtl: "rtl", selectedTasks: "selectedTasks", showCollapseTooltip: "showCollapseTooltip", span: "span", stretchCards: "stretchCards", strictRecordMapping: "strictRecordMapping", swimlaneField: "swimlaneField", swimlanes: "swimlanes", tasks: "tasks", title: "title", tools: "tools", virtualize: "virtualize", width: "width", x: "x", y: "y", anchorSize: "anchorSize", focusVisible: "focusVisible", hasChanges: "hasChanges", parent: "parent", state: "state", columnDragFeature: "columnDragFeature", columnFilterFeature: "columnFilterFeature", columnHeaderMenuFeature: "columnHeaderMenuFeature", columnLockFeature: "columnLockFeature", columnRenameFeature: "columnRenameFeature", columnResizeFeature: "columnResizeFeature", columnSortFeature: "columnSortFeature", columnToolbarsFeature: "columnToolbarsFeature", filterBarFeature: "filterBarFeature", simpleTaskEditFeature: "simpleTaskEditFeature", swimlaneDragFeature: "swimlaneDragFeature", taskDragFeature: "taskDragFeature", taskDragSelectFeature: "taskDragSelectFeature", taskEditFeature: "taskEditFeature", taskMenuFeature: "taskMenuFeature", taskTooltipFeature: "taskTooltipFeature" }, outputs: { onActivateTask: "onActivateTask", onBeforeColumnDrag: "onBeforeColumnDrag", onBeforeColumnDrop: "onBeforeColumnDrop", onBeforeColumnResize: "onBeforeColumnResize", onBeforeDestroy: "onBeforeDestroy", onBeforeHide: "onBeforeHide", onBeforeResponsiveStateChange: "onBeforeResponsiveStateChange", onBeforeShow: "onBeforeShow", onBeforeSimpleTaskEdit: "onBeforeSimpleTaskEdit", onBeforeStateApply: "onBeforeStateApply", onBeforeStateSave: "onBeforeStateSave", onBeforeTaskDrag: "onBeforeTaskDrag", onBeforeTaskDrop: "onBeforeTaskDrop", onBeforeTaskEdit: "onBeforeTaskEdit", onBeforeTaskEditShow: "onBeforeTaskEditShow", onBeforeTaskRemove: "onBeforeTaskRemove", onCatchAll: "onCatchAll", onCellMenuItem: "onCellMenuItem", onCellMenuShow: "onCellMenuShow", onCellMenuToggleItem: "onCellMenuToggleItem", onCollapse: "onCollapse", onColumnCollapse: "onColumnCollapse", onColumnDrag: "onColumnDrag", onColumnDragAbort: "onColumnDragAbort", onColumnDragEnd: "onColumnDragEnd", onColumnDragStart: "onColumnDragStart", onColumnDrop: "onColumnDrop", onColumnExpand: "onColumnExpand", onColumnFilterHide: "onColumnFilterHide", onColumnFilterShow: "onColumnFilterShow", onColumnFilterToggle: "onColumnFilterToggle", onColumnHeaderClick: "onColumnHeaderClick", onColumnHeaderContextMenu: "onColumnHeaderContextMenu", onColumnHeaderDblClick: "onColumnHeaderDblClick", onColumnHeaderMenuBeforeShow: "onColumnHeaderMenuBeforeShow", onColumnResize: "onColumnResize", onColumnResizeStart: "onColumnResizeStart", onColumnTitleClick: "onColumnTitleClick", onColumnTitleContextMenu: "onColumnTitleContextMenu", onColumnTitleDblClick: "onColumnTitleDblClick", onColumnToggle: "onColumnToggle", onDestroy: "onDestroy", onDirtyStateChange: "onDirtyStateChange", onElementCreated: "onElementCreated", onExpand: "onExpand", onFocusIn: "onFocusIn", onFocusOut: "onFocusOut", onHide: "onHide", onPaint: "onPaint", onReadOnly: "onReadOnly", onRecompose: "onRecompose", onRemoveTaskElement: "onRemoveTaskElement", onRenderTask: "onRenderTask", onRenderTasks: "onRenderTasks", onResize: "onResize", onResponsiveStateChange: "onResponsiveStateChange", onSelectionChange: "onSelectionChange", onShow: "onShow", onSimpleTaskEditCancel: "onSimpleTaskEditCancel", onSimpleTaskEditComplete: "onSimpleTaskEditComplete", onSwimlaneCollapse: "onSwimlaneCollapse", onSwimlaneExpand: "onSwimlaneExpand", onSwimlaneHeaderClick: "onSwimlaneHeaderClick", onSwimlaneHeaderContextMenu: "onSwimlaneHeaderContextMenu", onSwimlaneHeaderDblClick: "onSwimlaneHeaderDblClick", onSwimlaneToggle: "onSwimlaneToggle", onTaskClick: "onTaskClick", onTaskDblClick: "onTaskDblClick", onTaskDrag: "onTaskDrag", onTaskDragAbort: "onTaskDragAbort", onTaskDragEnd: "onTaskDragEnd", onTaskDragStart: "onTaskDragStart", onTaskDrop: "onTaskDrop", onTaskMenuBeforeShow: "onTaskMenuBeforeShow", onTaskMenuItem: "onTaskMenuItem", onTaskMenuShow: "onTaskMenuShow", onTaskMenuToggleItem: "onTaskMenuToggleItem", onTaskMouseEnter: "onTaskMouseEnter", onTaskMouseLeave: "onTaskMouseLeave", onToolClick: "onToolClick" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumTaskBoardComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bryntum-task-board',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { activateTaskEvent: [{
+                type: Input
+            }], adopt: [{
+                type: Input
+            }], align: [{
+                type: Input
+            }], anchor: [{
+                type: Input
+            }], ariaDescription: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], autoGenerateColumns: [{
+                type: Input
+            }], autoGenerateSwimlanes: [{
+                type: Input
+            }], bbar: [{
+                type: Input
+            }], bodyCls: [{
+                type: Input
+            }], bubbleEvents: [{
+                type: Input
+            }], cardSizes: [{
+                type: Input
+            }], centered: [{
+                type: Input
+            }], chainFilters: [{
+                type: Input
+            }], collapseTitle: [{
+                type: Input
+            }], collapsible: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], columnTitleRenderer: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], constrainTo: [{
+                type: Input
+            }], cssVarPrefix: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], detectCSSCompatibilityIssues: [{
+                type: Input
+            }], dock: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], drawer: [{
+                type: Input
+            }], elementAttributes: [{
+                type: Input
+            }], floating: [{
+                type: Input
+            }], footer: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], hideAnimation: [{
+                type: Input
+            }], htmlEncodeHeaderText: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], ignoreParentReadOnly: [{
+                type: Input
+            }], listeners: [{
+                type: Input
+            }], loadMask: [{
+                type: Input
+            }], loadMaskDefaults: [{
+                type: Input
+            }], loadMaskError: [{
+                type: Input
+            }], localeClass: [{
+                type: Input
+            }], localizable: [{
+                type: Input
+            }], localizableProperties: [{
+                type: Input
+            }], maskDefaults: [{
+                type: Input
+            }], masked: [{
+                type: Input
+            }], newTaskDefaults: [{
+                type: Input
+            }], owner: [{
+                type: Input
+            }], plugins: [{
+                type: Input
+            }], positioned: [{
+                type: Input
+            }], processItems: [{
+                type: Input
+            }], record: [{
+                type: Input
+            }], relayStoreEvents: [{
+                type: Input
+            }], resourceImagePath: [{
+                type: Input
+            }], responsive: [{
+                type: Input
+            }], responsiveRoot: [{
+                type: Input
+            }], responsiveState: [{
+                type: Input
+            }], responsiveTarget: [{
+                type: Input
+            }], rootElement: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], scrollAction: [{
+                type: Input
+            }], scrollManager: [{
+                type: Input
+            }], scrollOptions: [{
+                type: Input
+            }], selectOnNavigation: [{
+                type: Input
+            }], showAnimation: [{
+                type: Input
+            }], showCollapseInHeader: [{
+                type: Input
+            }], showCountInHeader: [{
+                type: Input
+            }], stateful: [{
+                type: Input
+            }], statefulEvents: [{
+                type: Input
+            }], stateId: [{
+                type: Input
+            }], stateProvider: [{
+                type: Input
+            }], stickyHeaders: [{
+                type: Input
+            }], strips: [{
+                type: Input
+            }], swimlaneRenderer: [{
+                type: Input
+            }], syncMask: [{
+                type: Input
+            }], tab: [{
+                type: Input
+            }], tabBarItems: [{
+                type: Input
+            }], taskRenderer: [{
+                type: Input
+            }], taskSorterFn: [{
+                type: Input
+            }], tasksPerRow: [{
+                type: Input
+            }], tbar: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], ui: [{
+                type: Input
+            }], useDomTransition: [{
+                type: Input
+            }], weight: [{
+                type: Input
+            }], alignSelf: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], assignments: [{
+                type: Input
+            }], bodyItems: [{
+                type: Input
+            }], callOnFunctions: [{
+                type: Input
+            }], catchEventHandlerExceptions: [{
+                type: Input
+            }], cls: [{
+                type: Input
+            }], collapsed: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], columnField: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], css: [{
+                type: Input
+            }], dataset: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], drawOnScroll: [{
+                type: Input
+            }], extraData: [{
+                type: Input
+            }], flex: [{
+                type: Input
+            }], footerItems: [{
+                type: Input
+            }], getTaskHeight: [{
+                type: Input
+            }], headerItems: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], inputFieldAlign: [{
+                type: Input
+            }], insertBefore: [{
+                type: Input
+            }], insertFirst: [{
+                type: Input
+            }], isTaskSelectable: [{
+                type: Input
+            }], keyMap: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], maximizeOnMobile: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], project: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], rendition: [{
+                type: Input
+            }], resources: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], selectedTasks: [{
+                type: Input
+            }], showCollapseTooltip: [{
+                type: Input
+            }], span: [{
+                type: Input
+            }], stretchCards: [{
+                type: Input
+            }], strictRecordMapping: [{
+                type: Input
+            }], swimlaneField: [{
+                type: Input
+            }], swimlanes: [{
+                type: Input
+            }], tasks: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], tools: [{
+                type: Input
+            }], virtualize: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], x: [{
+                type: Input
+            }], y: [{
+                type: Input
+            }], anchorSize: [{
+                type: Input
+            }], focusVisible: [{
+                type: Input
+            }], hasChanges: [{
+                type: Input
+            }], parent: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], columnDragFeature: [{
+                type: Input
+            }], columnFilterFeature: [{
+                type: Input
+            }], columnHeaderMenuFeature: [{
+                type: Input
+            }], columnLockFeature: [{
+                type: Input
+            }], columnRenameFeature: [{
+                type: Input
+            }], columnResizeFeature: [{
+                type: Input
+            }], columnSortFeature: [{
+                type: Input
+            }], columnToolbarsFeature: [{
+                type: Input
+            }], filterBarFeature: [{
+                type: Input
+            }], simpleTaskEditFeature: [{
+                type: Input
+            }], swimlaneDragFeature: [{
+                type: Input
+            }], taskDragFeature: [{
+                type: Input
+            }], taskDragSelectFeature: [{
+                type: Input
+            }], taskEditFeature: [{
+                type: Input
+            }], taskMenuFeature: [{
+                type: Input
+            }], taskTooltipFeature: [{
+                type: Input
+            }], onActivateTask: [{
+                type: Output
+            }], onBeforeColumnDrag: [{
+                type: Output
+            }], onBeforeColumnDrop: [{
+                type: Output
+            }], onBeforeColumnResize: [{
+                type: Output
+            }], onBeforeDestroy: [{
+                type: Output
+            }], onBeforeHide: [{
+                type: Output
+            }], onBeforeResponsiveStateChange: [{
+                type: Output
+            }], onBeforeShow: [{
+                type: Output
+            }], onBeforeSimpleTaskEdit: [{
+                type: Output
+            }], onBeforeStateApply: [{
+                type: Output
+            }], onBeforeStateSave: [{
+                type: Output
+            }], onBeforeTaskDrag: [{
+                type: Output
+            }], onBeforeTaskDrop: [{
+                type: Output
+            }], onBeforeTaskEdit: [{
+                type: Output
+            }], onBeforeTaskEditShow: [{
+                type: Output
+            }], onBeforeTaskRemove: [{
+                type: Output
+            }], onCatchAll: [{
+                type: Output
+            }], onCellMenuItem: [{
+                type: Output
+            }], onCellMenuShow: [{
+                type: Output
+            }], onCellMenuToggleItem: [{
+                type: Output
+            }], onCollapse: [{
+                type: Output
+            }], onColumnCollapse: [{
+                type: Output
+            }], onColumnDrag: [{
+                type: Output
+            }], onColumnDragAbort: [{
+                type: Output
+            }], onColumnDragEnd: [{
+                type: Output
+            }], onColumnDragStart: [{
+                type: Output
+            }], onColumnDrop: [{
+                type: Output
+            }], onColumnExpand: [{
+                type: Output
+            }], onColumnFilterHide: [{
+                type: Output
+            }], onColumnFilterShow: [{
+                type: Output
+            }], onColumnFilterToggle: [{
+                type: Output
+            }], onColumnHeaderClick: [{
+                type: Output
+            }], onColumnHeaderContextMenu: [{
+                type: Output
+            }], onColumnHeaderDblClick: [{
+                type: Output
+            }], onColumnHeaderMenuBeforeShow: [{
+                type: Output
+            }], onColumnResize: [{
+                type: Output
+            }], onColumnResizeStart: [{
+                type: Output
+            }], onColumnTitleClick: [{
+                type: Output
+            }], onColumnTitleContextMenu: [{
+                type: Output
+            }], onColumnTitleDblClick: [{
+                type: Output
+            }], onColumnToggle: [{
+                type: Output
+            }], onDestroy: [{
+                type: Output
+            }], onDirtyStateChange: [{
+                type: Output
+            }], onElementCreated: [{
+                type: Output
+            }], onExpand: [{
+                type: Output
+            }], onFocusIn: [{
+                type: Output
+            }], onFocusOut: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onPaint: [{
+                type: Output
+            }], onReadOnly: [{
+                type: Output
+            }], onRecompose: [{
+                type: Output
+            }], onRemoveTaskElement: [{
+                type: Output
+            }], onRenderTask: [{
+                type: Output
+            }], onRenderTasks: [{
+                type: Output
+            }], onResize: [{
+                type: Output
+            }], onResponsiveStateChange: [{
+                type: Output
+            }], onSelectionChange: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onSimpleTaskEditCancel: [{
+                type: Output
+            }], onSimpleTaskEditComplete: [{
+                type: Output
+            }], onSwimlaneCollapse: [{
+                type: Output
+            }], onSwimlaneExpand: [{
+                type: Output
+            }], onSwimlaneHeaderClick: [{
+                type: Output
+            }], onSwimlaneHeaderContextMenu: [{
+                type: Output
+            }], onSwimlaneHeaderDblClick: [{
+                type: Output
+            }], onSwimlaneToggle: [{
+                type: Output
+            }], onTaskClick: [{
+                type: Output
+            }], onTaskDblClick: [{
+                type: Output
+            }], onTaskDrag: [{
+                type: Output
+            }], onTaskDragAbort: [{
+                type: Output
+            }], onTaskDragEnd: [{
+                type: Output
+            }], onTaskDragStart: [{
+                type: Output
+            }], onTaskDrop: [{
+                type: Output
+            }], onTaskMenuBeforeShow: [{
+                type: Output
+            }], onTaskMenuItem: [{
+                type: Output
+            }], onTaskMenuShow: [{
+                type: Output
+            }], onTaskMenuToggleItem: [{
+                type: Output
+            }], onTaskMouseEnter: [{
+                type: Output
+            }], onTaskMouseLeave: [{
+                type: Output
+            }], onToolClick: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bryntum-task-board.component.js","sourceRoot":"","sources":["../../../component/src/lib/bryntum-task-board.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Angular wrapper for Bryntum TaskBoard\n */\n\nimport { Component, ElementRef, EventEmitter, Output, Input, SimpleChange, SimpleChanges, OnDestroy, OnInit } from '@angular/core';\n\nimport WrapperHelper from './wrapper.helper';\n\nimport { AlignSpec, Base, BryntumScrollOptions, Container, DomConfig, KeyMapConfig, Mask, MaskConfig, Menu, MenuItem, MenuItemEntry, Model, PagingToolbarConfig, Panel, PanelCollapserConfig, PanelCollapserOverlayConfig, PanelHeader, Rectangle, ScrollManagerConfig, Scroller, ScrollerConfig, StateProvider, Store, StoreConfig, TabConfig, Tool, ToolConfig, ToolbarConfig, ToolbarItems, Widget } from '@bryntum/core-thin';\nimport { AssignmentModel, AssignmentModelConfig, CardSize, ColumnDrag, ColumnDragConfig, ColumnFilter, ColumnFilterConfig, ColumnHeaderMenu, ColumnHeaderMenuConfig, ColumnLock, ColumnLockConfig, ColumnModel, ColumnModelConfig, ColumnRename, ColumnRenameConfig, ColumnResize, ColumnResizeConfig, ColumnSort, ColumnSortConfig, ColumnToolbars, ColumnToolbarsConfig, TaskBoardContainerItemConfig, FilterBar, FilterBarConfig, ProjectModel, ProjectModelConfig, ResourceModel, ResourceModelConfig, SimpleTaskEdit, SimpleTaskEditConfig, SwimlaneDrag, SwimlaneDragConfig, SwimlaneModel, SwimlaneModelConfig, TaskBoard, TaskBoardListeners, TaskDrag, TaskDragConfig, TaskDragSelect, TaskDragSelectConfig, TaskEdit, TaskEditConfig, TaskEditor, TaskItemOptions, TaskMenu, TaskMenuConfig, TaskModel, TaskModelConfig, TaskTooltip, TaskTooltipConfig } from '@bryntum/taskboard-thin';\n\nimport { StringHelper } from '@bryntum/core-thin';\n\nexport type BryntumTaskBoardProps = {\n    // Configs\n    /**\n     * The name of the event that should activate a task and trigger editing (if an editing feature is active).\n     * Available options are: 'taskClick', 'taskDblClick' or null (disable)\n     */\n    activateTaskEvent ? : 'taskClick'|'taskDblClick'|null\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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-adopt)\n     */\n    adopt ? : HTMLElement|string\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-align)\n     */\n    align ? : AlignSpec|string\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/taskboard/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/taskboard/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/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-ariaLabel)\n     */\n    ariaLabel ? : string\n    /**\n     * Inline [assignments](https://bryntum.com/products/scheduler/docs#Scheduler/model/AssignmentModel), will be loaded into an internally created\n     * [AssignmentStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/AssignmentStore)  as a part of a [project](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel).\n     */\n    assignments ? : AssignmentModel[]|object[]|AssignmentModelConfig[]\n    /**\n     * Set to `true` to auto generate columns when [columns](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/mixin/TaskBoardColumns#config-columns) is undefined.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-autoGenerateColumns)\n     */\n    autoGenerateColumns ? : boolean\n    /**\n     * Set to `true` to auto generate swimlanes when [swimlanes](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/mixin/TaskBoardSwimlanes#config-swimlanes) is undefined.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-autoGenerateSwimlanes)\n     */\n    autoGenerateSwimlanes ? : boolean\n    /**\n     * A Config object representing the configuration of a [Toolbar](https://bryntum.com/products/taskboard/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/taskboard/docs/api/Core/widget/Panel#config-strips).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-bbar)\n     */\n    bbar ? : (TaskBoardContainerItemConfig|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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-bodyCls)\n     */\n    bodyCls ? : string|object\n    /**\n     * Items to add to each card's body.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-bodyItems)\n     */\n    bodyItems ? : Record<string, TaskItemOptions>\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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-callOnFunctions)\n     */\n    callOnFunctions ? : boolean\n    /**\n     * An array of [CardSize](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/mixin/ResponsiveCards#typedef-CardSize) objects to use as responsive levels based on card widths.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-cardSizes)\n     */\n    cardSizes ? : CardSize\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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-catchEventHandlerExceptions)\n     */\n    catchEventHandlerExceptions ? : boolean\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/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     * Columns hold their tasks in stores chained off the project's task store. Filters applied to the project store\n     * are by default not applied to the column stores; they are only affected by their own filters. By configuring\n     * `chainFilters : true`, the filters from the project store will also be taken into account when filtering the\n     * columns.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-chainFilters)\n     */\n    chainFilters ? : 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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/Core/widget/Panel#config-collapsible).\n     */\n    collapsed ? : boolean\n    /**\n     * Specify `true` to hide the column title instead of rotating it on collapse.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-collapseTitle)\n     */\n    collapseTitle ? : boolean\n    /**\n     * This config enables collapsibility for the panel. See [collapsed](https://bryntum.com/products/taskboard/docs/api/Core/widget/Panel#config-collapsed).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-color)\n     */\n    color ? : string\n    /**\n     * Programmatic control over which column to start in when used in a grid layout.\n     */\n    column ? : number\n    /**\n     * Field on a task record used to determine which column the task belongs to.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-columnField)\n     */\n    columnField ? : string\n    /**\n     * Store containing the TaskBoard columns. A tasks [columnField](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/mixin/TaskBoardColumns#config-columnField) is matched against the `id` of a\n     * column to determine in which column it is displayed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-columns)\n     */\n    columns ? : ColumnModel[]|ColumnModelConfig[]|string[]|Store|string|StoreConfig\n    /**\n     * A function which renders the text, HTML, or `DomConfig` object to show as the column title. If you provide a\n     * `DomConfig` object, it will replace the title element and you are responsible for styling it + laying it out.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-columnTitleRenderer)\n     * @param {object} renderData\n     * @param {TaskBoard.model.ColumnModel} columnRecord The column instance\n     * @returns {string,DomConfig}\n     */\n    columnTitleRenderer ? : (renderData: object, columnRecord: ColumnModel) => string|DomConfig\n    config ? : object\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/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     * Initial CSS variables to set.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-css)\n     */\n    css ? : Record<string, string>\n    /**\n     * CSS variable prefix, appended to the keys used in [css](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoardBase#config-css).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-cssVarPrefix)\n     */\n    cssVarPrefix ? : string\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     * Check for CSS compatibility issues when upgrading to v7. Performs the following checks:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-detectCSSCompatibilityIssues)\n     */\n    detectCSSCompatibilityIssues ? : boolean\n    /**\n     * Disable or enable the widget. It is similar to [readOnly](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/Core/widget/Panel)\n     * [strips collection](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/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     * Whether to draw cards on scroll, or only when scrolling ends.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-drawOnScroll)\n     */\n    drawOnScroll ? : boolean\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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-elementAttributes)\n     */\n    elementAttributes ? : Record<string, string|null>\n    extraData ? : any\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/taskboard/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/taskboard/docs/api/Core/widget/Panel#config-strips).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-footer)\n     */\n    footer ? : {\n        dock?: 'top'|'right'|'bottom'|'left'|'start'|'end'\n        html?: string\n        cls?: string\n    }|string\n    /**\n     * Items to add to each card's footer.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-footerItems)\n     */\n    footerItems ? : Record<string, TaskItemOptions>\n    /**\n     * The function is called for each task as part of the render loop, and is expected to return the height in\n     * pixels for the task. Using this function is only recommended when using partial virtualized rendering, see\n     * the [virtualize](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/mixin/TaskBoardVirtualization#config-virtualize) setting.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-getTaskHeight)\n     * @param {TaskBoard.model.TaskModel} taskRecord The task record\n     * @returns {number} The height of the task in pixels\n     */\n    getTaskHeight ? : (taskRecord: TaskModel) => number\n    /**\n     * A config [object](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-header)\n     */\n    header ? : string|boolean|PanelHeader\n    /**\n     * Items to add to each card's header.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-headerItems)\n     */\n    headerItems ? : Record<string, TaskItemOptions>\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/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-hideAnimation)\n     */\n    hideAnimation ? : boolean|object\n    /**\n     * By default, the header text is HTML-encoded. Set this flag to `false` disable this and allow html\n     * elements in the column headers. Can also be specified on a single\n     * [column](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ColumnModel#field-htmlEncodeHeaderText).\n     */\n    htmlEncodeHeaderText ? : boolean\n    /**\n     * An icon to show before the [title](https://bryntum.com/products/taskboard/docs/api/Core/widget/Panel#config-title). Either pass a CSS class as a string, or pass a\n     * [DomConfig](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-ignoreParentReadOnly)\n     */\n    ignoreParentReadOnly ? : boolean\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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/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/taskboard/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 a task can be selected or not.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-isTaskSelectable)\n     * @param {TaskBoard.model.TaskModel} taskRecord The task record\n     * @returns {boolean} `true` if the task can be selected, otherwise `false`\n     */\n    isTaskSelectable ? : (taskRecord: TaskModel) => boolean\n    /**\n     * See [Keyboard shortcuts](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#keyboard-shortcuts) for details\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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-labelPosition)\n     */\n    labelPosition ? : 'before'|'above'|'align-before'|'auto'|null\n    /**\n     * The listener set for this object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-listeners)\n     */\n    listeners ? : TaskBoardListeners\n    /**\n     * A [Mask](https://bryntum.com/products/taskboard/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/taskboard/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/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-loadMaskDefaults)\n     */\n    loadMaskDefaults ? : MaskConfig\n    /**\n     * A [Mask](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-localizableProperties)\n     */\n    localizableProperties ? : string[]\n    /**\n     * Widget's margin. This may be configured as a single number or a `TRBL` format string.\n     * numeric-only values are interpreted as pixels.\n     */\n    margin ? : number|string\n    /**\n     * This config object contains the defaults for the [Mask](https://bryntum.com/products/taskboard/docs/api/Core/widget/Mask) created for the\n     * [masked](https://bryntum.com/products/taskboard/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/taskboard/docs/api/Core/widget/Mask) config object.\n     */\n    masked ? : boolean|string|MaskConfig\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/taskboard/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/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/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 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/taskboard/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/taskboard/docs/api/Core/widget/Widget#config-width), *reading* the value will return the numeric value in pixels.\n     */\n    minWidth ? : string|number\n    /**\n     * Default values to apply to task records created by task boards features (such as the column header menu and\n     * the column toolbar)\n     */\n    newTaskDefaults ? : TaskModelConfig\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/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-owner)\n     */\n    owner ? : Widget|any\n    /**\n     * Specify plugins (an array of classes) in config\n     */\n    plugins ? : Function[]\n    /**\n     * Set to `true` when a widget is rendered into another widget's [contentElement](https://bryntum.com/products/taskboard/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/taskboard/docs/api/Core/widget/Widget#property-contentElement).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-positioned)\n     */\n    positioned ? : boolean\n    /**\n     * A function called on each render before adding items to a tasks card, allowing runtime manipulation of them.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-processItems)\n     * @param {object} context\n     * @param {Record<string, TaskItemOptions>} context.headerItems Item config objects for the task header, keyed by ref\n     * @param {Record<string, TaskItemOptions>} context.bodyItems Item config objects for the task body, keyed by ref\n     * @param {Record<string, TaskItemOptions>} context.footerItems Item config objects for the task footer, keyed by ref\n     * @param {TaskBoard.model.TaskModel} context.taskRecord Record representing task to be rendered\n     * @returns {boolean,void} Returning `false` from this function prevents the menu being shown\n     */\n    processItems ? : (context: { headerItems: Record<string, TaskItemOptions>, bodyItems: Record<string, TaskItemOptions>, footerItems: Record<string, TaskItemOptions>, taskRecord: TaskModel }) => boolean|void\n    /**\n     * A [project config object](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel#configs) or an instance that holds all stores and\n     * data used by the TaskBoard.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-project)\n     */\n    project ? : ProjectModel|ProjectModelConfig|object\n    /**\n     * Whether this widget is read-only.  This is only valid if the widget is an input\n     * field, <strong>or contains input fields at any depth</strong>.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-readOnly)\n     */\n    readOnly ? : boolean\n    /**\n     * [Record](https://bryntum.com/products/taskboard/docs/api/Core/data/Model) whose values will be used to populate fields in the container.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-record)\n     */\n    record ? : Model\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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-rendition)\n     */\n    rendition ? : string|Record<string, string>|null\n    /**\n     * Path to load resource images from. Used by the for example the resource picker in the task editor and by the\n     * ResourceAvatars task item. Set this to display miniature images for each resource using their `image` field.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-resourceImagePath)\n     */\n    resourceImagePath ? : string\n    /**\n     * Inline [resources](https://bryntum.com/products/scheduler/docs#Scheduler/model/ResourceModel), will be loaded into an internally created\n     * [ResourceStore](https://bryntum.com/products/scheduler/docs#Scheduler/data/ResourceStore) as a part of a [project](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ProjectModel).\n     */\n    resources ? : ResourceModel[]|object[]|ResourceModelConfig[]\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/taskboard/docs/api/Core/widget/mixin/Responsive#config-responsiveState)) and its corresponding value is the\n     * associated [ResponsiveState](https://bryntum.com/products/taskboard/docs/api/Core/widget/mixin/Responsive#typedef-ResponsiveState) object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-responsive)\n     */\n    responsive ? : object\n    /**\n     * Set to `true` to mark this instance as the default [responsiveTarget](https://bryntum.com/products/taskboard/docs/api/Core/widget/mixin/Responsive#config-responsiveTarget) for descendants that do\n     * not specify an explicit [responsiveTarget](https://bryntum.com/products/taskboard/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/taskboard/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/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-responsiveTarget)\n     */\n    responsiveTarget ? : string|Widget\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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/TaskBoard/view/TaskBoard#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     * Configuration values for the [ScrollManager](https://bryntum.com/products/taskboard/docs/api/Core/util/ScrollManager) class. It is used to manage column/body\n     * scrolling during task, column or swimlane drag.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-scrollManager)\n     */\n    scrollManager ? : ScrollManagerConfig\n    /**\n     * Default scroll options, see the options for [scrollIntoView](https://bryntum.com/products/taskboard/docs/api/Core/helper/util/Scroller#function-scrollIntoView)\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-scrollOptions)\n     */\n    scrollOptions ? : BryntumScrollOptions\n    /**\n     * Selected tasks.\n     */\n    selectedTasks ? : TaskModel[]\n    /**\n     * Configure with `true` to change the default behaviour of keyboard navigation from moving focus to selecting\n     * tasks:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-selectOnNavigation)\n     */\n    selectOnNavigation ? : boolean|string\n    /**\n     * *Only valid if this Widget is [floating](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-floating).*\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-showAnimation)\n     */\n    showAnimation ? : boolean|object\n    /**\n     * Show an icon to expand/collapse columns and swimlanes in their headers.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-showCollapseInHeader)\n     */\n    showCollapseInHeader ? : boolean\n    /**\n     * By default, a tooltip showing `Expand XX`/`Collapse XX` is shown when hovering the expand/collapse icon for\n     * a column or swimlane. To disable the tooltip, set this to `false`.\n     */\n    showCollapseTooltip ? : boolean\n    /**\n     * Show task count for a column in its header, appended after the title\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-showCountInHeader)\n     */\n    showCountInHeader ? : 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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/Core/mixin/State#function-saveState).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/Core/mixin/State#config-stateProvider). If this config is\n     * not assigned, and [stateful](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-stateId)\n     */\n    stateId ? : string\n    /**\n     * The `StateProvider` to use to save and restore this object's [state](https://bryntum.com/products/taskboard/docs/api/Core/mixin/State#property-state). By default, `state`\n     * will be saved using the [default state provider](https://bryntum.com/products/taskboard/docs/api/Core/state/StateProvider#property-instance-static).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-stateProvider)\n     */\n    stateProvider ? : StateProvider\n    /**\n     * Makes column and swimlane headers sticky\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-stickyHeaders)\n     */\n    stickyHeaders ? : boolean\n    /**\n     * Setting this will cause cards to expand to share the available width if there are fewer than\n     * [tasksPerRow](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoardBase#config-tasksPerRow).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-stretchCards)\n     */\n    stretchCards ? : boolean\n    /**\n     * Specify `true` to match fields by their `name` property only when assigning a [record](https://bryntum.com/products/taskboard/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/taskboard/docs/api/Core/widget/Toolbar). If you want to pass an array, you can use\n     * the toolbar's [items](https://bryntum.com/products/taskboard/docs/api/Core/widget/Container#config-items).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-strips)\n     */\n    strips ? : Record<string, TaskBoardContainerItemConfig>\n    /**\n     * Field on a task record used to determine which swimlane the task belongs to.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-swimlaneField)\n     */\n    swimlaneField ? : string\n    /**\n     * An empty function by default, but provided so that you can override it. This function is called each time\n     * a swimlane is rendered into the task board. It allows you to manipulate the DOM config object used for the\n     * swimlane before it is synced to DOM, thus giving you control over styling and contents.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-swimlaneRenderer)\n     * @param {object} detail An object containing the information needed to render a swimlane.\n     * @param {TaskBoard.model.SwimlaneModel} detail.swimlaneRecord The swimlane.\n     * @param {DomConfig} detail.swimlaneConfig DOM config object for the swimlane\n     * @returns {void}\n     */\n    swimlaneRenderer ? : (detail: { swimlaneRecord: SwimlaneModel, swimlaneConfig: DomConfig }) => void\n    /**\n     * Store containing the TaskBoard swimlanes. A tasks [swimlaneField](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/mixin/TaskBoardSwimlanes#config-swimlaneField) is matched against the `id`\n     * of a swimlane to determine in which swimlane it is displayed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-swimlanes)\n     */\n    swimlanes ? : SwimlaneModel[]|SwimlaneModelConfig[]|Store|string|StoreConfig\n    /**\n     * TaskBoard does not use a sync mask by default. If you want one, see\n     * [syncMask](https://bryntum.com/products/taskboard/docs/api/Core/mixin/LoadMaskable#config-syncMask) for configuration options.\n     */\n    syncMask ? : string|object|null\n    /**\n     * A configuration for the [tab](https://bryntum.com/products/taskboard/docs/api/Core/widget/Tab) created for this widget when it is placed in a\n     * [TabPanel](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#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/taskboard/docs/api/Core/widget/TabBar) when this container is the active tab.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-tabBarItems)\n     */\n    tabBarItems ? : ToolbarItems[]|Widget[]\n    /**\n     * An empty function by default, but provided so that you can override it. This function is called each time\n     * a task is rendered into the task board. It allows you to manipulate the DOM config object used for the card\n     * before it is synced to DOM, thus giving you control over styling and contents.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-taskRenderer)\n     * @param {object} detail An object containing the information needed to render a task.\n     * @param {TaskBoard.model.TaskModel} detail.taskRecord The task record.\n     * @param {TaskBoard.model.ColumnModel} detail.columnRecord The column the task will be displayed in.\n     * @param {TaskBoard.model.SwimlaneModel} detail.swimlaneRecord The swimlane the task will be displayed in.\n     * @param {DomConfig} detail.cardConfig DOM config object for the cards element\n     * @returns {void}\n     */\n    taskRenderer ? : (detail: { taskRecord: TaskModel, columnRecord: ColumnModel, swimlaneRecord: SwimlaneModel, cardConfig: DomConfig }) => void\n    /**\n     * Inline [tasks](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/TaskModel), will be loaded into an internally created\n     * [TaskStore](https://bryntum.com/products/taskboard/docs/api/TaskBoard/store/TaskStore) as a part of a [project](#TaskBoard/model/ProjectModel).\n     */\n    tasks ? : TaskModel[]|object[]|TaskModelConfig[]\n    /**\n     * Allows sorting tasks in the UI independent of how they are sorted in the task store.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-taskSorterFn)\n     * @param {TaskBoard.model.TaskModel} first The first task to compare\n     * @param {TaskBoard.model.TaskModel} second The second task to compare\n     * @returns {number} Return `1` if first task is greater than second task, `-1` if the opposite is true or `0` if they are equal\n     */\n    taskSorterFn ? : boolean|((first: TaskModel, second: TaskModel) => number)\n    /**\n     * Controls how many cards are rendered to a row in each column. Can be controlled on a per column basis by\n     * setting [tasksPerRow](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ColumnModel#field-tasksPerRow)\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-tasksPerRow)\n     */\n    tasksPerRow ? : number\n    /**\n     * A Config object representing the configuration of a [Toolbar](https://bryntum.com/products/taskboard/docs/api/Core/widget/Toolbar),\n     * or array of config objects representing the child items of a Toolbar.\n     * This creates a toolbar docked to the top of the panel immediately below the header.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-tbar)\n     */\n    tbar ? : (TaskBoardContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null\n    /**\n     * A title to display in the header or owning TabPanel. Causes creation and docking of a header\n     * to the top if no header is configured.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-title)\n     */\n    title ? : string\n    /**\n     * The [tools](https://bryntum.com/products/taskboard/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/taskboard/docs/api/Core/widget/mixin/Toolable#property-tools)` property.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-tools)\n     */\n    tools ? : Record<string, ToolConfig>|null\n    type ? : 'taskboard'\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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-ui)\n     */\n    ui ? : 'plain'|'toolbar'|string|object\n    /**\n     * Experimental, animate actions that cannot be animated using CSS transitions. Currently includes:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-useDomTransition)\n     */\n    useDomTransition ? : boolean\n    /**\n     * By turning on this setting you enable partial virtualized rendering for the board, which reduces initial\n     * rendering time and makes interaction less sluggish when using thousands of tasks. The tradeoff is that\n     * scrolling in most cases will be slower.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-virtualize)\n     */\n    virtualize ? : boolean\n    /**\n     * A widgets weight determines its position among siblings when added to a [Container](https://bryntum.com/products/taskboard/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/taskboard/docs/api/TaskBoard/view/TaskBoard#config-x)\n     */\n    x ? : number\n    /**\n     * The y position for the widget.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#config-y)\n     */\n    y ? : number\n\n    // Features\n    /**\n     * This feature allows users to drag columns on the TaskBoard to change the column order. Drag is initiated upon\n     * mouse down in the column header. Try it out below!\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnDrag)\n     */\n    columnDragFeature ? : object|boolean|string|ColumnDrag|ColumnDragConfig\n    /**\n     * Adds the ability to filter each column of the TaskBoard.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnFilter)\n     */\n    columnFilterFeature ? : object|boolean|string|ColumnFilter|ColumnFilterConfig\n    /**\n     * Adds a menu button (`···`) to column headers, clicking it displays a menu. Items are populated by other features\n     * and/or application code.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnHeaderMenu)\n     */\n    columnHeaderMenuFeature ? : object|boolean|string|ColumnHeaderMenu|ColumnHeaderMenuConfig\n    /**\n     * Allows user to lock columns to the left or right using the new [locked](https://bryntum.com/products/taskboard/docs/api/TaskBoard/model/ColumnModel#field-locked) field\n     * on columns.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnLock)\n     */\n    columnLockFeature ? : object|boolean|string|ColumnLock|ColumnLockConfig\n    /**\n     * Allows user to rename columns by either double-clicking column text, or via the column header menu.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnRename)\n     */\n    columnRenameFeature ? : object|boolean|string|ColumnRename|ColumnRenameConfig\n    /**\n     * This feature allows users to change the width of individual TaskBoard columns. Resize is initiated upon mouse down on\n     * the separator element between column headers. Try it out below!\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnResize)\n     */\n    columnResizeFeature ? : object|boolean|string|ColumnResize|ColumnResizeConfig\n    /**\n     * Adds the ability to sort each column of the TaskBoard.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnSort)\n     */\n    columnSortFeature ? : object|boolean|string|ColumnSort|ColumnSortConfig\n    /**\n     * Adds toolbars to the top and/or bottom of each column. By default it adds a bottom toolbar containing a single button\n     * for adding events to that column/swimlane:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnToolbars)\n     */\n    columnToolbarsFeature ? : object|boolean|string|ColumnToolbars|ColumnToolbarsConfig\n    /**\n     * Adds the ability to quick search in configured fields of tasks.\n     * Renders a filter bar below each column's header.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/FilterBar)\n     */\n    filterBarFeature ? : object|boolean|string|FilterBar|FilterBarConfig\n    /**\n     * This feature allows inline editing of tasks. Double-clicking an item starts editing it:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/SimpleTaskEdit)\n     */\n    simpleTaskEditFeature ? : object|boolean|string|SimpleTaskEdit|SimpleTaskEditConfig\n    /**\n     * This feature allows users to drag drop swimlanes on the TaskBoard changing their order (by grabbing their header).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/SwimlaneDrag)\n     */\n    swimlaneDragFeature ? : object|boolean|string|SwimlaneDrag|SwimlaneDragConfig\n    /**\n     * This feature allows cards on the TaskBoard to be dragged across swimlanes and columns but also vertically in the\n     * same column to change the order:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/TaskDrag)\n     */\n    taskDragFeature ? : object|boolean|string|TaskDrag|TaskDragConfig\n    /**\n     * Enables users to click and drag to select cards on the TaskBoard (marquee selection).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/TaskDragSelect)\n     */\n    taskDragSelectFeature ? : object|boolean|string|TaskDragSelect|TaskDragSelectConfig\n    /**\n     * This features allows the user to edit tasks in a popup editor that can either be shown centered on screen (the\n     * default, double click a task to show the editor):\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/TaskEdit)\n     */\n    taskEditFeature ? : object|boolean|string|TaskEdit|TaskEditConfig\n    /**\n     * Displays a context menu for tasks. Items are populated by other features and/or application code.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/TaskMenu)\n     */\n    taskMenuFeature ? : object|boolean|string|TaskMenu|TaskMenuConfig\n    /**\n     * Displays a tooltip when hovering a task. By default the tooltip displays:\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/TaskTooltip)\n     */\n    taskTooltipFeature ? : object|boolean|string|TaskTooltip|TaskTooltipConfig\n\n}\n\n@Component({\n    selector : 'bryntum-task-board',\n    template : ''\n})\nexport class BryntumTaskBoardComponent implements OnInit, OnDestroy {\n\n    public static instanceClass = TaskBoard;\n\n    public static instanceName = 'TaskBoard';\n\n    private static bryntumEvents: string[] = [\n        'onActivateTask',\n        'onBeforeColumnDrag',\n        'onBeforeColumnDrop',\n        'onBeforeColumnResize',\n        'onBeforeDestroy',\n        'onBeforeHide',\n        'onBeforeResponsiveStateChange',\n        'onBeforeShow',\n        'onBeforeSimpleTaskEdit',\n        'onBeforeStateApply',\n        'onBeforeStateSave',\n        'onBeforeTaskDrag',\n        'onBeforeTaskDrop',\n        'onBeforeTaskEdit',\n        'onBeforeTaskEditShow',\n        'onBeforeTaskRemove',\n        'onCatchAll',\n        'onCellMenuItem',\n        'onCellMenuShow',\n        'onCellMenuToggleItem',\n        'onCollapse',\n        'onColumnCollapse',\n        'onColumnDrag',\n        'onColumnDragAbort',\n        'onColumnDragEnd',\n        'onColumnDragStart',\n        'onColumnDrop',\n        'onColumnExpand',\n        'onColumnFilterHide',\n        'onColumnFilterShow',\n        'onColumnFilterToggle',\n        'onColumnHeaderClick',\n        'onColumnHeaderContextMenu',\n        'onColumnHeaderDblClick',\n        'onColumnHeaderMenuBeforeShow',\n        'onColumnResize',\n        'onColumnResizeStart',\n        'onColumnTitleClick',\n        'onColumnTitleContextMenu',\n        'onColumnTitleDblClick',\n        'onColumnToggle',\n        'onDestroy',\n        'onDirtyStateChange',\n        'onElementCreated',\n        'onExpand',\n        'onFocusIn',\n        'onFocusOut',\n        'onHide',\n        'onPaint',\n        'onReadOnly',\n        'onRecompose',\n        'onRemoveTaskElement',\n        'onRenderTask',\n        'onRenderTasks',\n        'onResize',\n        'onResponsiveStateChange',\n        'onSelectionChange',\n        'onShow',\n        'onSimpleTaskEditCancel',\n        'onSimpleTaskEditComplete',\n        'onSwimlaneCollapse',\n        'onSwimlaneExpand',\n        'onSwimlaneHeaderClick',\n        'onSwimlaneHeaderContextMenu',\n        'onSwimlaneHeaderDblClick',\n        'onSwimlaneToggle',\n        'onTaskClick',\n        'onTaskDblClick',\n        'onTaskDrag',\n        'onTaskDragAbort',\n        'onTaskDragEnd',\n        'onTaskDragStart',\n        'onTaskDrop',\n        'onTaskMenuBeforeShow',\n        'onTaskMenuItem',\n        'onTaskMenuShow',\n        'onTaskMenuToggleItem',\n        'onTaskMouseEnter',\n        'onTaskMouseLeave',\n        'onToolClick'\n    ];\n\n    private static bryntumFeatureNames: string[] = [\n        'columnDragFeature',\n        'columnFilterFeature',\n        'columnHeaderMenuFeature',\n        'columnLockFeature',\n        'columnRenameFeature',\n        'columnResizeFeature',\n        'columnSortFeature',\n        'columnToolbarsFeature',\n        'filterBarFeature',\n        'simpleTaskEditFeature',\n        'swimlaneDragFeature',\n        'taskDragFeature',\n        'taskDragSelectFeature',\n        'taskEditFeature',\n        'taskMenuFeature',\n        'taskTooltipFeature'\n    ];\n\n    private static bryntumConfigs: string[] = BryntumTaskBoardComponent.bryntumFeatureNames.concat([\n        'activateTaskEvent',\n        'adopt',\n        'align',\n        'alignSelf',\n        'anchor',\n        'appendTo',\n        'ariaDescription',\n        'ariaLabel',\n        'assignments',\n        'autoGenerateColumns',\n        'autoGenerateSwimlanes',\n        'bbar',\n        'bodyCls',\n        'bodyItems',\n        'bubbleEvents',\n        'callOnFunctions',\n        'cardSizes',\n        'catchEventHandlerExceptions',\n        'centered',\n        'chainFilters',\n        'cls',\n        'collapsed',\n        'collapseTitle',\n        'collapsible',\n        'color',\n        'column',\n        'columnField',\n        'columns',\n        'columnTitleRenderer',\n        'config',\n        'constrainTo',\n        'css',\n        'cssVarPrefix',\n        'dataField',\n        'dataset',\n        'detectCSSCompatibilityIssues',\n        'disabled',\n        'dock',\n        'draggable',\n        'drawer',\n        'drawOnScroll',\n        'elementAttributes',\n        'extraData',\n        'flex',\n        'floating',\n        'footer',\n        'footerItems',\n        'getTaskHeight',\n        'header',\n        'headerItems',\n        'height',\n        'hidden',\n        'hideAnimation',\n        'htmlEncodeHeaderText',\n        'icon',\n        'id',\n        'ignoreParentReadOnly',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'isTaskSelectable',\n        'keyMap',\n        'labelPosition',\n        'listeners',\n        'loadMask',\n        'loadMaskDefaults',\n        'loadMaskError',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'margin',\n        'maskDefaults',\n        'masked',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minHeight',\n        'minWidth',\n        'newTaskDefaults',\n        'owner',\n        'plugins',\n        'positioned',\n        'processItems',\n        'project',\n        'readOnly',\n        'record',\n        'relayStoreEvents',\n        'rendition',\n        'resourceImagePath',\n        'resources',\n        'responsive',\n        'responsiveRoot',\n        'responsiveState',\n        'responsiveTarget',\n        'rootElement',\n        'rtl',\n        'scrollable',\n        'scrollAction',\n        'scrollManager',\n        'scrollOptions',\n        'selectedTasks',\n        'selectOnNavigation',\n        'showAnimation',\n        'showCollapseInHeader',\n        'showCollapseTooltip',\n        'showCountInHeader',\n        'span',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'stickyHeaders',\n        'stretchCards',\n        'strictRecordMapping',\n        'strips',\n        'swimlaneField',\n        'swimlaneRenderer',\n        'swimlanes',\n        'syncMask',\n        'tab',\n        'tabBarItems',\n        'taskRenderer',\n        'tasks',\n        'taskSorterFn',\n        'tasksPerRow',\n        'tbar',\n        'title',\n        'tools',\n        'type',\n        'ui',\n        'useDomTransition',\n        'virtualize',\n        'weight',\n        'width',\n        'x',\n        'y'\n    ]);\n\n    private static bryntumConfigsOnly: string[] = [\n        'activateTaskEvent',\n        'adopt',\n        'align',\n        'anchor',\n        'ariaDescription',\n        'ariaLabel',\n        'autoGenerateColumns',\n        'autoGenerateSwimlanes',\n        'bbar',\n        'bodyCls',\n        'bubbleEvents',\n        'cardSizes',\n        'centered',\n        'chainFilters',\n        'collapseTitle',\n        'collapsible',\n        'color',\n        'columnTitleRenderer',\n        'config',\n        'constrainTo',\n        'cssVarPrefix',\n        'dataField',\n        'detectCSSCompatibilityIssues',\n        'dock',\n        'draggable',\n        'drawer',\n        'elementAttributes',\n        'floating',\n        'footer',\n        'header',\n        'hideAnimation',\n        'htmlEncodeHeaderText',\n        'icon',\n        'ignoreParentReadOnly',\n        'listeners',\n        'loadMask',\n        'loadMaskDefaults',\n        'loadMaskError',\n        'localeClass',\n        'localizable',\n        'localizableProperties',\n        'maskDefaults',\n        'masked',\n        'newTaskDefaults',\n        'owner',\n        'plugins',\n        'positioned',\n        'processItems',\n        'record',\n        'relayStoreEvents',\n        'resourceImagePath',\n        'responsive',\n        'responsiveRoot',\n        'responsiveState',\n        'responsiveTarget',\n        'rootElement',\n        'scrollable',\n        'scrollAction',\n        'scrollManager',\n        'scrollOptions',\n        'selectOnNavigation',\n        'showAnimation',\n        'showCollapseInHeader',\n        'showCountInHeader',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'stickyHeaders',\n        'strips',\n        'swimlaneRenderer',\n        'syncMask',\n        'tab',\n        'tabBarItems',\n        'taskRenderer',\n        'taskSorterFn',\n        'tasksPerRow',\n        'tbar',\n        'type',\n        'ui',\n        'useDomTransition',\n        'weight'\n    ];\n\n    private static bryntumProps: string[] = BryntumTaskBoardComponent.bryntumFeatureNames.concat([\n        'alignSelf',\n        'anchorSize',\n        'appendTo',\n        'assignments',\n        'bodyItems',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'cls',\n        'collapsed',\n        'column',\n        'columnField',\n        'columns',\n        'css',\n        'dataset',\n        'disabled',\n        'drawOnScroll',\n        'extraData',\n        'flex',\n        'focusVisible',\n        'footerItems',\n        'getTaskHeight',\n        'hasChanges',\n        'headerItems',\n        'height',\n        'hidden',\n        'id',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'isTaskSelectable',\n        'keyMap',\n        'labelPosition',\n        'margin',\n        'maxHeight',\n        'maximizeOnMobile',\n        'maxWidth',\n        'minHeight',\n        'minWidth',\n        'parent',\n        'project',\n        'readOnly',\n        'rendition',\n        'resources',\n        'rtl',\n        'selectedTasks',\n        'showCollapseTooltip',\n        'span',\n        'state',\n        'stretchCards',\n        'strictRecordMapping',\n        'swimlaneField',\n        'swimlanes',\n        'tasks',\n        'title',\n        'tools',\n        'virtualize',\n        'width',\n        'x',\n        'y'\n    ]);\n\n    private elementRef: ElementRef;\n    public instance!: TaskBoard;\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() activateTaskEvent            ! : 'taskClick'|'taskDblClick'|null;\n    @Input() adopt                        ! : HTMLElement|string;\n    @Input() align                        ! : AlignSpec|string;\n    @Input() anchor                       ! : boolean;\n    @Input() ariaDescription              ! : string;\n    @Input() ariaLabel                    ! : string;\n    @Input() autoGenerateColumns          ! : boolean;\n    @Input() autoGenerateSwimlanes        ! : boolean;\n    @Input() bbar                         ! : (TaskBoardContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null;\n    @Input() bodyCls                      ! : string|object;\n    @Input() bubbleEvents                 ! : object;\n    @Input() cardSizes                    ! : CardSize;\n    @Input() centered                     ! : boolean;\n    @Input() chainFilters                 ! : boolean;\n    @Input() collapseTitle                ! : boolean;\n    @Input() collapsible                  ! : boolean|PanelCollapserConfig|PanelCollapserOverlayConfig;\n    @Input() color                        ! : string;\n    @Input() columnTitleRenderer          ! : (renderData: object, columnRecord: ColumnModel) => string|DomConfig;\n    @Input() config                       ! : object;\n    @Input() constrainTo                  ! : HTMLElement|Widget|Rectangle;\n    @Input() cssVarPrefix                 ! : string;\n    @Input() dataField                    ! : string;\n    @Input() detectCSSCompatibilityIssues ! : boolean;\n    @Input() dock                         ! : 'top'|'bottom'|'left'|'right'|'start'|'end'|'header'|'pre-header'|object;\n    @Input() draggable                    ! : boolean|{\n        handleSelector?: string\n    };\n    @Input() drawer                       ! : boolean|{side?: 'start'|'left'|'end'|'right'|'top'|'bottom', size?: string|number, inline?: boolean, autoClose: { mousedown?: boolean|string, focusout?: boolean|string, mouseout?: string }, autoCloseDelay?: number};\n    @Input() elementAttributes            ! : Record<string, string|null>;\n    @Input() 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() htmlEncodeHeaderText         ! : boolean;\n    @Input() icon                         ! : string|DomConfig;\n    @Input() ignoreParentReadOnly         ! : boolean;\n    @Input() listeners                    ! : TaskBoardListeners;\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() maskDefaults                 ! : MaskConfig;\n    @Input() masked                       ! : boolean|string|MaskConfig;\n    @Input() newTaskDefaults              ! : TaskModelConfig;\n    @Input() owner                        ! : Widget|any;\n    @Input() plugins                      ! : Function[];\n    @Input() positioned                   ! : boolean;\n    @Input() processItems                 ! : (context: { headerItems: Record<string, TaskItemOptions>, bodyItems: Record<string, TaskItemOptions>, footerItems: Record<string, TaskItemOptions>, taskRecord: TaskModel }) => boolean|void;\n    @Input() record                       ! : Model;\n    @Input() relayStoreEvents             ! : boolean;\n    @Input() resourceImagePath            ! : string;\n    @Input() responsive                   ! : object;\n    @Input() responsiveRoot               ! : boolean;\n    @Input() responsiveState              ! : string;\n    @Input() responsiveTarget             ! : string|Widget;\n    @Input() rootElement                  ! : ShadowRoot|HTMLElement;\n    @Input() scrollable                   ! : boolean|ScrollerConfig|Scroller;\n    @Input() scrollAction                 ! : 'hide'|'realign'|null;\n    @Input() scrollManager                ! : ScrollManagerConfig;\n    @Input() scrollOptions                ! : BryntumScrollOptions;\n    @Input() selectOnNavigation           ! : boolean|string;\n    @Input() showAnimation                ! : boolean|object;\n    @Input() showCollapseInHeader         ! : boolean;\n    @Input() showCountInHeader            ! : boolean;\n    @Input() stateful                     ! : boolean|object|string[];\n    @Input() statefulEvents               ! : object|string[];\n    @Input() stateId                      ! : string;\n    @Input() stateProvider                ! : StateProvider;\n    @Input() stickyHeaders                ! : boolean;\n    @Input() strips                       ! : Record<string, TaskBoardContainerItemConfig>;\n    @Input() swimlaneRenderer             ! : (detail: { swimlaneRecord: SwimlaneModel, swimlaneConfig: DomConfig }) => void;\n    @Input() syncMask                     ! : string|object|null;\n    @Input() tab                          ! : boolean|TabConfig;\n    @Input() tabBarItems                  ! : ToolbarItems[]|Widget[];\n    @Input() taskRenderer                 ! : (detail: { taskRecord: TaskModel, columnRecord: ColumnModel, swimlaneRecord: SwimlaneModel, cardConfig: DomConfig }) => void;\n    @Input() taskSorterFn                 ! : boolean|((first: TaskModel, second: TaskModel) => number);\n    @Input() tasksPerRow                  ! : number;\n    @Input() tbar                         ! : (TaskBoardContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null;\n    @Input() type                         ! : 'taskboard';\n    @Input() ui                           ! : 'plain'|'toolbar'|string|object;\n    @Input() useDomTransition             ! : boolean;\n    @Input() weight                       ! : number;\n\n    // Configs and properties\n    @Input() alignSelf                   ! : string;\n    @Input() appendTo                    ! : HTMLElement|string;\n    @Input() assignments                 ! : AssignmentModel[]|object[]|AssignmentModelConfig[];\n    @Input() bodyItems                   ! : Record<string, TaskItemOptions>;\n    @Input() callOnFunctions             ! : boolean;\n    @Input() catchEventHandlerExceptions ! : boolean;\n    @Input() cls                         ! : string|object;\n    @Input() collapsed                   ! : boolean;\n    @Input() column                      ! : number;\n    @Input() columnField                 ! : string;\n    @Input() columns                     ! : Store|ColumnModel[]|ColumnModelConfig[]|string[]|string|StoreConfig;\n    @Input() css                         ! : typeof Proxy|Record<string, string>;\n    @Input() dataset                     ! : object|Record<string, string>;\n    @Input() disabled                    ! : boolean|'inert';\n    @Input() drawOnScroll                ! : boolean;\n    @Input() extraData                   ! : any;\n    @Input() flex                        ! : number|string;\n    @Input() footerItems                 ! : Record<string, TaskItemOptions>;\n    @Input() getTaskHeight               ! : (taskRecord: TaskModel) => number;\n    @Input() headerItems                 ! : Record<string, TaskItemOptions>;\n    @Input() height                      ! : number|string;\n    @Input() hidden                      ! : boolean;\n    @Input() id                          ! : string;\n    @Input() inputFieldAlign             ! : 'start'|'end';\n    @Input() insertBefore                ! : HTMLElement|string;\n    @Input() insertFirst                 ! : HTMLElement|string;\n    @Input() isTaskSelectable            ! : (taskRecord: TaskModel) => boolean;\n    @Input() keyMap                      ! : Record<string, KeyMapConfig>;\n    @Input() labelPosition               ! : 'before'|'above'|'align-before'|'auto'|null;\n    @Input() margin                      ! : number|string;\n    @Input() maxHeight                   ! : string|number;\n    @Input() maximizeOnMobile            ! : number|string;\n    @Input() maxWidth                    ! : string|number;\n    @Input() minHeight                   ! : string|number;\n    @Input() minWidth                    ! : string|number;\n    @Input() project                     ! : ProjectModel|ProjectModelConfig|object;\n    @Input() readOnly                    ! : boolean;\n    @Input() rendition                   ! : string|Record<string, string>|null;\n    @Input() resources                   ! : ResourceModel[]|object[]|ResourceModelConfig[];\n    @Input() rtl                         ! : boolean;\n    @Input() selectedTasks               ! : TaskModel[];\n    @Input() showCollapseTooltip         ! : boolean;\n    @Input() span                        ! : number;\n    @Input() stretchCards                ! : boolean;\n    @Input() strictRecordMapping         ! : boolean;\n    @Input() swimlaneField               ! : string;\n    @Input() swimlanes                   ! : Store|SwimlaneModel[]|SwimlaneModelConfig[]|string|StoreConfig;\n    @Input() tasks                       ! : TaskModel[]|object[]|TaskModelConfig[];\n    @Input() title                       ! : string;\n    @Input() tools                       ! : Record<string, Tool|ToolConfig>|null|Record<string, Tool>|Record<string, ToolConfig>;\n    @Input() virtualize                  ! : boolean;\n    @Input() width                       ! : number|string;\n    @Input() x                           ! : number;\n    @Input() y                           ! : number;\n\n    // Properties only\n    @Input() anchorSize   ! : number[];\n    @Input() focusVisible ! : boolean;\n    @Input() hasChanges   ! : boolean;\n    @Input() parent       ! : Widget;\n    @Input() state        ! : any;\n\n    // Features\n    @Input() columnDragFeature        ! : object|boolean|string|ColumnDrag|ColumnDragConfig;\n    @Input() columnFilterFeature      ! : object|boolean|string|ColumnFilter|ColumnFilterConfig;\n    @Input() columnHeaderMenuFeature  ! : object|boolean|string|ColumnHeaderMenu|ColumnHeaderMenuConfig;\n    @Input() columnLockFeature        ! : object|boolean|string|ColumnLock|ColumnLockConfig;\n    @Input() columnRenameFeature      ! : object|boolean|string|ColumnRename|ColumnRenameConfig;\n    @Input() columnResizeFeature      ! : object|boolean|string|ColumnResize|ColumnResizeConfig;\n    @Input() columnSortFeature        ! : object|boolean|string|ColumnSort|ColumnSortConfig;\n    @Input() columnToolbarsFeature    ! : object|boolean|string|ColumnToolbars|ColumnToolbarsConfig;\n    @Input() filterBarFeature         ! : object|boolean|string|FilterBar|FilterBarConfig;\n    @Input() simpleTaskEditFeature    ! : object|boolean|string|SimpleTaskEdit|SimpleTaskEditConfig;\n    @Input() swimlaneDragFeature      ! : object|boolean|string|SwimlaneDrag|SwimlaneDragConfig;\n    @Input() taskDragFeature          ! : object|boolean|string|TaskDrag|TaskDragConfig;\n    @Input() taskDragSelectFeature    ! : object|boolean|string|TaskDragSelect|TaskDragSelectConfig;\n    @Input() taskEditFeature          ! : object|boolean|string|TaskEdit|TaskEditConfig;\n    @Input() taskMenuFeature          ! : object|boolean|string|TaskMenu|TaskMenuConfig;\n    @Input() taskTooltipFeature       ! : object|boolean|string|TaskTooltip|TaskTooltipConfig;\n\n    // Events emitters\n    /**\n     * Triggered when a task is \"activated\" by pressing `Enter` or double clicking it.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-activateTask)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Task record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onActivateTask: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard before column dragging starts. Return `false` to prevent the action\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column to be dragged\n     */\n    @Output() onBeforeColumnDrag: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning TaskBoard when dropping a column, before the operation completes. Handles async\n     * listeners, returning `false` from one will abort the operation\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeColumnDrop)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Dropped column\n     * @param {TaskBoard.model.ColumnModel} event.beforeColumn Dropped before this column\n     */\n    @Output() onBeforeColumnDrop: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, beforeColumn: ColumnModel }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event is fired prior to starting a column resize gesture. The resize is canceled if a listener returns\n     * `false`.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The TaskBoard instance\n     * @param {TaskBoard.model.ColumnModel} event.column The column\n     * @param {Event} event.domEvent The browser event\n     */\n    @Output() onBeforeColumnResize: any = new EventEmitter<((event: { source: TaskBoard, column: ColumnModel, domEvent: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onBeforeDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Triggered before a widget is hidden. Return `false` to prevent the action.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being hidden.\n     */\n    @Output() onBeforeHide: any = new EventEmitter<((event: { source: Widget }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Triggered before a new [responsiveState](https://bryntum.com/products/taskboard/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     * 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     * Fires on the owning TaskBoard before displaying an inline editor. Returning `false` stops the editor from\n     * being shown.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeSimpleTaskEdit)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The task board\n     * @param {TaskBoard.feature.SimpleTaskEdit} event.simpleTaskEdit The simpleTaskEdit feature\n     * @param {TaskBoard.model.TaskModel} event.taskRecord The record about to be shown in the editor\n     * @param {string} event.field Field name being edited\n     */\n    @Output() onBeforeSimpleTaskEdit: any = new EventEmitter<((event: { source: TaskBoard, simpleTaskEdit: SimpleTaskEdit, taskRecord: TaskModel, field: string }) => 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 on the owning TaskBoard before task dragging starts. Return `false` to prevent the action\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Tasks to be dragged\n     * @param {Event} event.domEvent The mouse event\n     */\n    @Output() onBeforeTaskDrag: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[], domEvent: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning TaskBoard when tasks are dropped, before the operation completes. Handles async\n     * listeners, returning `false` from one will abort the operation\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskDrop)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dropped tasks\n     * @param {TaskBoard.model.ColumnModel} event.targetColumn Dropped on this column\n     * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Dropped in this swimlane (if used)\n     * @param {Event} event.domEvent The mouse event\n     */\n    @Output() onBeforeTaskDrop: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[], targetColumn: ColumnModel, targetSwimlane: SwimlaneModel, domEvent: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning TaskBoard before a task is displayed in an editor.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskEdit)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The owning TaskBoard\n     * @param {TaskBoard.model.TaskModel} event.taskRecord The record about to be shown in the task editor\n     */\n    @Output() onBeforeTaskEdit: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning TaskBoard when the editor for a task is available, but before it is populated with data\n     * and shown. Allows manipulating fields etc.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskEditShow)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The owning TaskBoard\n     * @param {TaskBoard.model.TaskModel} event.taskRecord The record about to be shown in the task editor\n     * @param {TaskBoard.widget.TaskEditor} event.editor The editor\n     */\n    @Output() onBeforeTaskEditShow: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel, editor: TaskEditor }) => void)|string>();\n    /**\n     * Triggered when one or more tasks are to be removed by a call to `removeTask()`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-beforeTaskRemove)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Task records to be removed\n     */\n    @Output() onBeforeTaskRemove: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[] }) => 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/taskboard/docs/api/TaskBoard/view/TaskBoard#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     * This event fires on the owning TaskBoard when an item is selected in the column header menu.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord The column\n     */\n    @Output() onCellMenuItem: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, item: MenuItem, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * This event fires on the owning TaskBoard after the context menu is shown for a column header.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Record<string, MenuItemEntry>} event.items Menu item configs\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord The column\n     */\n    @Output() onCellMenuShow: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, items: Record<string, MenuItemEntry>, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * This event fires on the owning TaskBoard when a check item is toggled in the column header menu.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord The column\n     * @param {boolean} event.checked Checked or not\n     */\n    @Output() onCellMenuToggleItem: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, item: MenuItem, columnRecord: ColumnModel, checked: boolean }) => void)|string>();\n    /**\n     * Fires when a Panel is collapsed using the [collapsible](https://bryntum.com/products/taskboard/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     * Triggered when a column is collapsed.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     */\n    @Output() onColumnCollapse: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when a column is dragged, if the drag leads to a change compared to\n     * the last columnDrag event.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnDrag)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column being dragged\n     * @param {TaskBoard.model.ColumnModel} event.beforeColumn Insert before this column on drop, `null` if last\n     */\n    @Output() onColumnDrag: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, beforeColumn: ColumnModel }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when a drag operation is aborted (invalid drop or aborted using ESC)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Dragged column\n     */\n    @Output() onColumnDragAbort: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when a previously started drag operation ends, no matter the\n     * outcome of it (whether valid, invalid or aborted)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Affected column\n     */\n    @Output() onColumnDragEnd: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when column dragging starts\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column to be dragged\n     */\n    @Output() onColumnDragStart: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when a column is successfully dropped (after the drop transition\n     * has finished)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Dropped column\n     * @param {TaskBoard.model.ColumnModel} event.beforeColumn Dropped before this column (`null` if last)\n     * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Dropped in this swimlane (if used)\n     */\n    @Output() onColumnDrop: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, beforeColumn: ColumnModel, targetSwimlane: SwimlaneModel }) => void)|string>();\n    /**\n     * Triggered when a column is expanded.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     */\n    @Output() onColumnExpand: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * Triggered when the column filter is hidden.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     */\n    @Output() onColumnFilterHide: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * Triggered when the column filter is displayed.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     */\n    @Output() onColumnFilterShow: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel }) => void)|string>();\n    /**\n     * Triggered when the column filter visibility is toggled.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {boolean} event.visible True if filter popup is visible, false otherwise\n     */\n    @Output() onColumnFilterToggle: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, visible: boolean }) => void)|string>();\n    /**\n     * Triggered when a column header is clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onColumnHeaderClick: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when a column header is right-clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderContextMenu)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onColumnHeaderContextMenu: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when a column header is double-clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderDblClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onColumnHeaderDblClick: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, event: MouseEvent }) => void)|string>();\n    /**\n     * This event fires on the owning TaskBoard before the menu is shown for a column header.\n     * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/ColumnHeaderMenu#config-processItems).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnHeaderMenuBeforeShow)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Record<string, MenuItemEntry>} event.items Menu item configs\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord The column\n     */\n    @Output() onColumnHeaderMenuBeforeShow: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, items: Record<string, MenuItemEntry>, columnRecord: ColumnModel }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event is fired after a resize gesture is completed.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The TaskBoard instance\n     * @param {TaskBoard.model.ColumnModel} event.column The column\n     * @param {Event} event.domEvent The browser event\n     */\n    @Output() onColumnResize: any = new EventEmitter<((event: { source: TaskBoard, column: ColumnModel, domEvent: Event }) => void)|string>();\n    /**\n     * This event is fired when a column resize gesture starts.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The TaskBoard instance\n     * @param {TaskBoard.model.ColumnModel} event.column The column\n     * @param {Event} event.domEvent The browser event\n     */\n    @Output() onColumnResizeStart: any = new EventEmitter<((event: { source: TaskBoard, column: ColumnModel, domEvent: Event }) => void)|string>();\n    /**\n     * Triggered when a column title element is clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnTitleClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onColumnTitleClick: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when a column title element is right-clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnTitleContextMenu)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onColumnTitleContextMenu: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when a column title element is double-clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-columnTitleDblClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onColumnTitleDblClick: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when the column collapsed state is toggled.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record\n     * @param {boolean} event.collapse `true` if the column is being collapsed.\n     */\n    @Output() onColumnToggle: any = new EventEmitter<((event: { source: TaskBoard, columnRecord: ColumnModel, collapse: 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/taskboard/docs/api/Core/widget/Container#property-hasChanges) property changes\n     * @param {object} event Event object\n     * @param {Core.widget.Container} event.source The container.\n     * @param {boolean} event.dirty The dirty state of the Container - `true` if there are any fields which have been changed since initial load.\n     */\n    @Output() onDirtyStateChange: any = new EventEmitter<((event: { source: Container, dirty: boolean }) => void)|string>();\n    /**\n     * Triggered when a widget's [element](https://bryntum.com/products/taskboard/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     * Fires when a Panel is expanded using the [collapsible](https://bryntum.com/products/taskboard/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     * 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/taskboard/docs/api/TaskBoard/view/TaskBoard#event-paint)\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being painted.\n     * @param {boolean} event.firstPaint `true` if this is the first paint.\n     */\n    @Output() onPaint: any = new EventEmitter<((event: { source: Widget, firstPaint: boolean }) => void)|string>();\n    /**\n     * Fired when 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/taskboard/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     * Triggered when a tasks element is removed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-removeTaskElement)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance\n     * @param {string,number} event.taskId Id of the task (not the record itself since it might be removed)\n     * @param {HTMLElement} event.element Tasks element\n     */\n    @Output() onRemoveTaskElement: any = new EventEmitter<((event: { source: TaskBoard, taskId: string|number, element: HTMLElement }) => void)|string>();\n    /**\n     * Triggered when a task is rendered.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-renderTask)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Task being rendered\n     * @param {boolean} event.isRefresh `true` if the element was updated, `false` if it was added\n     * @param {HTMLElement} event.element Tasks element\n     */\n    @Output() onRenderTask: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel, isRefresh: boolean, element: HTMLElement }) => void)|string>();\n    /**\n     * Triggered when all tasks in the task board are rendered\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Tasks being rendered\n     */\n    @Output() onRenderTasks: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[] }) => void)|string>();\n    /**\n     * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/taskboard/docs/api/Core/widget/Widget#config-monitorResize) is `true`*.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source This Widget\n     * @param {number} event.width The new width\n     * @param {number} event.height The new height\n     * @param {number} event.oldWidth The old width\n     * @param {number} event.oldHeight The old height\n     */\n    @Output() onResize: any = new EventEmitter<((event: { source: Widget, width: number, height: number, oldWidth: number, oldHeight: number }) => void)|string>();\n    /**\n     * Triggered when a new [responsiveState](https://bryntum.com/products/taskboard/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     * Triggered when task selection changes.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source TaskBoard instance\n     * @param {'select','deselect'} event.action Either 'select' or 'deselect', depending on operation\n     * @param {TaskBoard.model.TaskModel[]} event.selection All currently selected tasks\n     * @param {TaskBoard.model.TaskModel[]} event.select Tasks selected by the operation\n     * @param {TaskBoard.model.TaskModel[]} event.deselect Tasks deselected by the operation\n     */\n    @Output() onSelectionChange: any = new EventEmitter<((event: { source: TaskBoard, action: 'select'|'deselect', selection: TaskModel[], select: TaskModel[], deselect: TaskModel[] }) => 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     * Fires on the owning TaskBoard when inline editing of a field is cancelled (by pressing ESC).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-simpleTaskEditCancel)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The task board\n     * @param {TaskBoard.feature.SimpleTaskEdit} event.simpleTaskEdit The simpleTaskEdit feature\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Record that was edited\n     * @param {string} event.field Field name being edited\n     */\n    @Output() onSimpleTaskEditCancel: any = new EventEmitter<((event: { source: TaskBoard, simpleTaskEdit: SimpleTaskEdit, taskRecord: TaskModel, field: string }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning TaskBoard when inline editing of a field has successfully finished.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-simpleTaskEditComplete)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The task board\n     * @param {TaskBoard.feature.SimpleTaskEdit} event.simpleTaskEdit The simpleTaskEdit feature\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Record that was edited\n     * @param {string} event.field Field name being edited\n     */\n    @Output() onSimpleTaskEditComplete: any = new EventEmitter<((event: { source: TaskBoard, simpleTaskEdit: SimpleTaskEdit, taskRecord: TaskModel, field: string }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Triggered when a swimlane is collapsed.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record\n     */\n    @Output() onSwimlaneCollapse: any = new EventEmitter<((event: { source: TaskBoard, swimlaneRecord: SwimlaneModel }) => void)|string>();\n    /**\n     * Triggered when a swimlane is expanded.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record\n     */\n    @Output() onSwimlaneExpand: any = new EventEmitter<((event: { source: TaskBoard, swimlaneRecord: SwimlaneModel }) => void)|string>();\n    /**\n     * Triggered when a swimlane header is clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-swimlaneHeaderClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onSwimlaneHeaderClick: any = new EventEmitter<((event: { source: TaskBoard, swimlaneRecord: SwimlaneModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when a swimlane header is right-clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-swimlaneHeaderContextMenu)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onSwimlaneHeaderContextMenu: any = new EventEmitter<((event: { source: TaskBoard, swimlaneRecord: SwimlaneModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when a swimlane header is double-clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-swimlaneHeaderDblClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onSwimlaneHeaderDblClick: any = new EventEmitter<((event: { source: TaskBoard, swimlaneRecord: SwimlaneModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when the swimlane collapsed state is toggled.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record\n     * @param {boolean} event.collapse `true` if the column is being collapsed.\n     */\n    @Output() onSwimlaneToggle: any = new EventEmitter<((event: { source: TaskBoard, swimlaneRecord: SwimlaneModel, collapse: boolean }) => void)|string>();\n    /**\n     * Triggered when a card is clicked.\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Task record\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onTaskClick: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel, columnRecord: ColumnModel, swimlaneRecord: SwimlaneModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when a card is double-clicked\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskDblClick)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Task record\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onTaskDblClick: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel, columnRecord: ColumnModel, swimlaneRecord: SwimlaneModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when tasks are dragged, if the drag leads to any changes compared to\n     * the last taskDrag event (moved to a new column or changed order within a column).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskDrag)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dragged tasks\n     * @param {TaskBoard.model.ColumnModel} event.targetColumn Currently over this column\n     * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Currently over this swimlane (if used)\n     * @param {Event} event.domEvent The mouse event\n     */\n    @Output() onTaskDrag: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[], targetColumn: ColumnModel, targetSwimlane: SwimlaneModel, domEvent: Event }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when a drag operation is aborted (invalid drop or aborted using ESC)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dragged tasks\n     */\n    @Output() onTaskDragAbort: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[] }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when a previously started drag operation ends, no matter the\n     * outcome of it (whether valid, invalid or aborted)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Affected tasks\n     * @param {Event} event.domEvent The mouse event\n     */\n    @Output() onTaskDragEnd: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[], domEvent: Event }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when task dragging starts\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Tasks to be dragged\n     * @param {Event} event.domEvent The mouse event\n     */\n    @Output() onTaskDragStart: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[], domEvent: Event }) => void)|string>();\n    /**\n     * Fires on the owning TaskBoard when tasks are successfully dropped (after the drop transition has\n     * finished)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source Owning TaskBoard\n     * @param {TaskBoard.model.TaskModel[]} event.taskRecords Dropped tasks\n     * @param {TaskBoard.model.ColumnModel} event.targetColumn Dropped on this column\n     * @param {TaskBoard.model.SwimlaneModel} event.targetSwimlane Dropped in this swimlane (if used)\n     * @param {Event} event.domEvent The mouse event\n     */\n    @Output() onTaskDrop: any = new EventEmitter<((event: { source: TaskBoard, taskRecords: TaskModel[], targetColumn: ColumnModel, targetSwimlane: SwimlaneModel, domEvent: Event }) => void)|string>();\n    /**\n     * This event fires on the owning TaskBoard before the context menu is shown for a task.\n     * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/taskboard/docs/api/TaskBoard/feature/TaskMenu#config-processItems).\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskMenuBeforeShow)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Record<string, MenuItemEntry>} event.items Menu item configs\n     * @param {TaskBoard.model.TaskModel} event.taskRecord The task\n     */\n    @Output() onTaskMenuBeforeShow: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, items: Record<string, MenuItemEntry>, taskRecord: TaskModel }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning TaskBoard when an item is selected in the task context menu.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     * @param {TaskBoard.model.TaskModel} event.taskRecord The task\n     */\n    @Output() onTaskMenuItem: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, item: MenuItem, taskRecord: TaskModel }) => void)|string>();\n    /**\n     * This event fires on the owning TaskBoard after the context menu is shown for a task.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Record<string, MenuItemEntry>} event.items Menu item configs\n     * @param {TaskBoard.model.TaskModel} event.taskRecord The task\n     */\n    @Output() onTaskMenuShow: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, items: Record<string, MenuItemEntry>, taskRecord: TaskModel }) => void)|string>();\n    /**\n     * This event fires on the owning TaskBoard when a check item is toggled in the task context menu.\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source The grid\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     * @param {TaskBoard.model.TaskModel} event.taskRecord The task\n     * @param {boolean} event.checked Checked or not\n     */\n    @Output() onTaskMenuToggleItem: any = new EventEmitter<((event: { source: TaskBoard, menu: Menu, item: MenuItem, taskRecord: TaskModel, checked: boolean }) => void)|string>();\n    /**\n     * Triggered when the mouse enters a card\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskMouseEnter)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Task record\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onTaskMouseEnter: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel, columnRecord: ColumnModel, swimlaneRecord: SwimlaneModel, event: MouseEvent }) => void)|string>();\n    /**\n     * Triggered when the mouse leaves a card\n     * ...\n     * [View online docs...](https://bryntum.com/products/taskboard/docs/api/TaskBoard/view/TaskBoard#event-taskMouseLeave)\n     * @param {object} event Event object\n     * @param {TaskBoard.view.TaskBoard} event.source This TaskBoard\n     * @param {TaskBoard.model.TaskModel} event.taskRecord Task record\n     * @param {TaskBoard.model.ColumnModel} event.columnRecord Column record for the tasks column\n     * @param {TaskBoard.model.SwimlaneModel} event.swimlaneRecord Swimlane record for the tasks swimlane (if used)\n     * @param {MouseEvent} event.event Browser event\n     */\n    @Output() onTaskMouseLeave: any = new EventEmitter<((event: { source: TaskBoard, taskRecord: TaskModel, columnRecord: ColumnModel, swimlaneRecord: SwimlaneModel, event: MouseEvent }) => void)|string>();\n    /**\n     * A header [tool](https://bryntum.com/products/taskboard/docs/api/Core/widget/Panel#config-tools) has been clicked.\n     * @param {object} event Event object\n     * @param {Core.widget.Tool} event.source This Panel.\n     * @param {Core.widget.Tool} event.tool The tool which is being clicked.\n     */\n    @Output() onToolClick: any = new EventEmitter<((event: { source: Tool, tool: Tool }) => void)|string>();\n\n    /**\n     * Create and append the underlying widget\n     */\n    ngOnInit(): void {\n        const\n            me = this,\n            {\n                elementRef,\n                bryntumConfig\n            } = me,\n            {\n                instanceClass,\n                instanceName,\n                bryntumConfigs,\n                bryntumEvents\n            } = BryntumTaskBoardComponent;\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 } = BryntumTaskBoardComponent;\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 } = BryntumTaskBoardComponent;\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"]}