@bryntum/grid-angular 7.1.1

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

@@ -0,0 +1,2103 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/**
+ * Angular wrapper for Bryntum Grid
+ */
+import { Component, EventEmitter, Output, Input } from '@angular/core';
+import WrapperHelper from './wrapper.helper';
+import { Grid, Widget } from '@bryntum/grid';
+import { StringHelper } from '@bryntum/grid';
+import * as i0 from "@angular/core";
+export class BryntumGridComponent {
+    constructor(element) {
+        this.bryntumConfig = {
+            adopt: undefined,
+            appendTo: undefined,
+            href: undefined,
+            angularComponent: this,
+            features: {},
+            listeners: {}
+        };
+        // Events emitters
+        /**
+         * Fires on the owning Grid before the cell editing is canceled, return `false` to prevent cancellation.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {Grid.util.GridLocation} event.editorContext Editing context
+         */
+        this.onBeforeCancelCellEdit = new EventEmitter();
+        /**
+         * Fires on the owning Grid before the row editing is canceled, return false to signal that the value is invalid and editing should not be finalized.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeCancelRowEdit)
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid Target grid
+         * @param {RowEditorContext} event.editorContext Editing context
+         */
+        this.onBeforeCancelRowEdit = new EventEmitter();
+        /**
+         * Fires on the owning Grid before editing starts, return `false` to prevent editing
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {CellEditorContext} event.editorContext Editing context
+         */
+        this.onBeforeCellEditStart = new EventEmitter();
+        /**
+         * Fires on the owning Grid before deleting a range of selected cell values by pressing `Backspace` or `Del`
+         * buttons while [autoEdit](https://bryntum.com/products/grid/docs/api/Grid/feature/CellEdit#config-autoEdit) is set to `true`. Return `false` to prevent editing.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {(Grid.util.GridLocation|Core.data.Model)[]} event.gridSelection An array of cell selectors or records that will have their values deleted (the records themselves will not get deleted, only visible column values).
+         */
+        this.onBeforeCellRangeDelete = new EventEmitter();
+        /**
+         * Fires for each selected record on the owning Grid before editing a range of selected cell values
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.record Current selected record from the range
+         * @param {string} event.field The field being changed
+         * @param {any} event.value The value being set
+         */
+        this.onBeforeCellRangeEdit = new EventEmitter();
+        /**
+         * This event is fired prior to starting a column drag gesture. The drag is canceled if a listener returns `false`.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance.
+         * @param {Grid.column.Column} event.column The dragged column.
+         * @param {Event} event.event The browser event.
+         */
+        this.onBeforeColumnDragStart = new EventEmitter();
+        /**
+         * This event is fired when a column is dropped, and you can return false from a listener to abort the operation.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance.
+         * @param {Grid.column.Column} event.column The dragged column.
+         * @param {Grid.column.Column} event.insertBefore The column before which the dragged column will be inserted.
+         * @param {Grid.column.Column} event.newParent The new parent column.
+         * @param {Event} event.event The browser event.
+         * @param {string} event.region The region where the column was dropped.
+         */
+        this.onBeforeColumnDropFinalize = 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 {Grid.view.Grid} event.source The grid instance
+         * @param {Grid.column.Column} event.column The column
+         * @param {Event} event.domEvent The browser event
+         */
+        this.onBeforeColumnResize = new EventEmitter();
+        /**
+         * Fires on the owning Grid before a copy action is performed, return `false` to prevent the action
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {Grid.util.GridLocation[]} event.cells The cells about to be copied or cut
+         * @param {string} event.data The string data about to be copied or cut
+         * @param {boolean} event.isCut `true` if this is a cut action
+         * @param {string} event.entityName 'cell' to distinguish this event from other beforeCopy events
+         */
+        this.onBeforeCopy = new EventEmitter();
+        /**
+         * Fires on the owning Grid before CSV export starts. Return `false` to cancel the export.
+         * @param {object} event Event object
+         * @param {ExportConfig} event.config Export config
+         * @param {Grid.column.Column[]} event.columns An array of columns to export
+         * @param {Core.data.Model[]} event.rows An array of records to export
+         * @param {string} event.lineDelimiter The CSV delimiter to separate lines
+         * @param {string} event.columnDelimiter The CSV delimiter to separate values on one line
+         */
+        this.onBeforeCSVExport = new EventEmitter();
+        /**
+         * Fires before an object is destroyed.
+         * @param {object} event Event object
+         * @param {Core.Base} event.source The Object that is being destroyed.
+         */
+        this.onBeforeDestroy = new EventEmitter();
+        /**
+         * Fires on the owning Grid before Excel export starts. Return `false` to cancel the export.
+         * @param {object} event Event object
+         * @param {ExportConfig} event.config Export config
+         * @param {XLSColumn[]} event.columns An array of columns to export
+         * @param {any[][]} event.rows An array of records to export
+         */
+        this.onBeforeExcelExport = new EventEmitter();
+        /**
+         * Fired before dragging of the FillHandle starts, return `false` to prevent the drag operation.
+         * @param {object} event Event object
+         * @param {Grid.util.GridLocation} event.cell Information about the column / record
+         * @param {MouseEvent} event.domEvent The raw DOM event
+         */
+        this.onBeforeFillHandleDragStart = new EventEmitter();
+        /**
+         * Fires on the owning Grid before the cell editing is finished, return false to signal that the value is invalid and editing should not be finalized.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid Target grid
+         * @param {CellEditorContext} event.editorContext Editing context
+         */
+        this.onBeforeFinishCellEdit = new EventEmitter();
+        /**
+         * Fires on the owning Grid before the row editing is finished, return false to signal that the value is invalid and editing should not be finalized.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeFinishRowEdit)
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid Target grid
+         * @param {RowEditorContext} event.editorContext Editing context
+         */
+        this.onBeforeFinishRowEdit = new EventEmitter();
+        /**
+         * Triggered before a widget is hidden. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being hidden.
+         */
+        this.onBeforeHide = new EventEmitter();
+        /**
+         * Fires on the owning Grid before a paste action is performed, return `false` to prevent the action
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {string} event.clipboardData The clipboardData about to be pasted
+         * @param {Grid.util.GridLocation} event.targetCell The cell from which the paste will be started
+         * @param {string} event.entityName 'cell' to distinguish this event from other beforePaste events
+         * @param {string} event.text The raw text from clipboard
+         */
+        this.onBeforePaste = new EventEmitter();
+        /**
+         * Fires on the owning Grid before export started. Return `false` to cancel the export.
+         * @param {object} event Event object
+         * @param {object} event.config Export config
+         */
+        this.onBeforePdfExport = new EventEmitter();
+        /**
+         * Fires before a row is rendered.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance.
+         * @param {Grid.row.Row} event.row The row about to be rendered.
+         * @param {Core.data.Model} event.record The record for the row.
+         * @param {number} event.recordIndex The zero-based index of the record.
+         */
+        this.onBeforeRenderRow = new EventEmitter();
+        /**
+         * Grid rows are about to be rendered
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source This grid.
+         */
+        this.onBeforeRenderRows = new EventEmitter();
+        /**
+         * This event fires before row collapse is started.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeRowCollapse)
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.record Record
+         */
+        this.onBeforeRowCollapse = new EventEmitter();
+        /**
+         * This event fires before row expand is started.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeRowExpand)
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.record Record
+         */
+        this.onBeforeRowExpand = new EventEmitter();
+        /**
+         * Fires before the selection changes. Returning `false` from a listener prevents the change
+         * @param {object} event Event object
+         * @param {string} event.action `'select'`/`'deselect'`
+         * @param {'row','cell'} event.mode `'row'`/`'cell'`
+         * @param {Grid.view.Grid} event.source
+         * @param {Core.data.Model[]} event.deselected The records to be deselected in this operation.
+         * @param {Core.data.Model[]} event.selected The records to be selected in this operation.
+         * @param {Core.data.Model[]} event.selection The records in the current selection, before applying `selected` and `deselected`
+         * @param {Grid.util.GridLocation[]} event.deselectedCells The cells to be deselected in this operation.
+         * @param {Grid.util.GridLocation[]} event.selectedCells The cells to be selected in this operation.
+         * @param {Grid.util.GridLocation[]} event.cellSelection The cells in the current selection, before applying `selectedCells` and `deselectedCells`
+         */
+        this.onBeforeSelectionChange = new EventEmitter();
+        /**
+         * Fired before this container will load record values into its child fields. This is useful if you
+         * want to modify the UI before data is loaded (e.g. set some input field to be readonly)
+         * @param {object} event Event object
+         * @param {Core.widget.Container} event.source The container
+         * @param {Core.data.Model} event.record The record
+         */
+        this.onBeforeSetRecord = new EventEmitter();
+        /**
+         * Triggered before a widget is shown. Return `false` to prevent the action.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget,any} event.source The widget being shown
+         */
+        this.onBeforeShow = new EventEmitter();
+        /**
+         * Fires on the owning Grid before editing starts, return `false` to prevent editing
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {RowEditorContext} event.editorContext Editing context
+         */
+        this.onBeforeStartRowEdit = 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 {GridStateInfo} 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 {GridStateInfo} event.state State object config
+         */
+        this.onBeforeStateSave = new EventEmitter();
+        /**
+         * Fired when a group is going to be expanded or collapsed using the UI.
+         * Returning `false` from a listener prevents the operation
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.groupRecord [DEPRECATED] Use `groupRecords` param instead
+         * @param {Core.data.Model[]} event.groupRecords The group records being toggled
+         * @param {boolean} event.collapse Collapsed (true) or expanded (false)
+         * @param {Event} event.domEvent The user interaction event (eg a `click` event) if the toggle request was instigated by user interaction.
+         */
+        this.onBeforeToggleGroup = new EventEmitter();
+        /**
+         * Fired before a parent node record toggles its collapsed state.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance.
+         * @param {Core.data.Model} event.record The record being toggled.
+         * @param {boolean} event.collapse `true` if the node is being collapsed.
+         */
+        this.onBeforeToggleNode = new EventEmitter();
+        /**
+         * Fires on the owning Grid when editing is cancelled
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {Grid.util.GridLocation} event.editorContext Editing context
+         * @param {Event} event.event Included if the cancellation was triggered by a DOM event
+         */
+        this.onCancelCellEdit = new EventEmitter();
+        /**
+         * Fires when any other event is fired from the object.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-catchAll)
+         * @param {object} event Event object
+         * @param {{[key: string]: any, type: string}} event.event The Object that contains event details
+         * @param {string} event.event.type The type of the event which is caught by the listener
+         */
+        this.onCatchAll = new EventEmitter();
+        /**
+         * Fired when user clicks in a grid cell
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid The grid instance
+         * @param {Core.data.Model} event.record The record representing the row
+         * @param {Grid.column.Column} event.column The column to which the cell belongs
+         * @param {HTMLElement} event.cellElement The cell HTML element
+         * @param {HTMLElement} event.target The target element
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onCellClick = new EventEmitter();
+        /**
+         * Fired when user activates contextmenu in a grid cell
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid The grid instance
+         * @param {Core.data.Model} event.record The record representing the row
+         * @param {Grid.column.Column} event.column The column to which the cell belongs
+         * @param {HTMLElement} event.cellElement The cell HTML element
+         * @param {HTMLElement} event.target The target element
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onCellContextMenu = new EventEmitter();
+        /**
+         * Fired when user double clicks a grid cell
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid The grid instance
+         * @param {Core.data.Model} event.record The record representing the row
+         * @param {Grid.column.Column} event.column The column to which the cell belongs
+         * @param {HTMLElement} event.cellElement The cell HTML element
+         * @param {HTMLElement} event.target The target element
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onCellDblClick = new EventEmitter();
+        /**
+         * This event fires on the owning grid before the context menu is shown for a cell.
+         * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/grid/docs/api/Grid/feature/CellMenu#config-processItems).
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-cellMenuBeforeShow)
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {Grid.column.Column} event.column Column
+         * @param {Core.data.Model} event.record Record
+         */
+        this.onCellMenuBeforeShow = new EventEmitter();
+        /**
+         * This event fires on the owning grid when an item is selected in the cell context menu.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {Grid.column.Column} event.column Column
+         * @param {Core.data.Model} event.record Record
+         */
+        this.onCellMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning grid after the context menu is shown for a cell.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {Grid.column.Column} event.column Column
+         * @param {Core.data.Model} event.record Record
+         */
+        this.onCellMenuShow = new EventEmitter();
+        /**
+         * This event fires on the owning grid when a check item is toggled in the cell context menu.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {Grid.column.Column} event.column Column
+         * @param {Core.data.Model} event.record Record
+         * @param {boolean} event.checked Checked or not
+         */
+        this.onCellMenuToggleItem = new EventEmitter();
+        /**
+         * Fired when the mouse enters a cell
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance
+         * @param {Core.data.Model} event.record The record representing the hovered cell
+         * @param {Grid.column.Column} event.column The column currently hovered
+         * @param {HTMLElement} event.cellElement The cell HTML element
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onCellMouseEnter = new EventEmitter();
+        /**
+         * Fired when the mouse leaves a cell
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance
+         * @param {Core.data.Model} event.record The record representing the cell that the mouse left
+         * @param {Grid.column.Column} event.column The column representing the cell that the mouse left
+         * @param {HTMLElement} event.cellElement The cell HTML element that the mouse left
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onCellMouseLeave = new EventEmitter();
+        /**
+         * Fired when a user moves the mouse out of a grid cell
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid The grid instance
+         * @param {Core.data.Model} event.record The record representing the row
+         * @param {Grid.column.Column} event.column The column to which the cell belongs
+         * @param {HTMLElement} event.cellElement The cell HTML element
+         * @param {HTMLElement} event.target The target element
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onCellMouseOut = new EventEmitter();
+        /**
+         * Fired when user moves the mouse over a grid cell
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid The grid instance
+         * @param {Core.data.Model} event.record The record representing the row
+         * @param {Grid.column.Column} event.column The column to which the cell belongs
+         * @param {HTMLElement} event.cellElement The cell HTML element
+         * @param {HTMLElement} event.target The target element
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onCellMouseOver = new EventEmitter();
+        /**
+         * Fires when a Panel is collapsed using the [collapsible](https://bryntum.com/products/grid/docs/api/Core/widget/Panel#config-collapsible) setting.
+         * @param {object} event Event object
+         * @param {Core.widget.Panel} event.source This Panel.
+         */
+        this.onCollapse = new EventEmitter();
+        /**
+         * Fired before a parent node record is collapsed.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance.
+         * @param {Core.data.Model} event.record The record which has been collapsed.
+         */
+        this.onCollapseNode = new EventEmitter();
+        /**
+         * This event is fired when a column is being dragged, and you can set the `valid` flag on the `context` object
+         * to indicate whether the drop position is valid or not.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance.
+         * @param {Grid.column.Column} event.column The dragged column.
+         * @param {Grid.column.Column} event.insertBefore The column before which the dragged column will be inserted (if not last).
+         * @param {Event} event.event The browser event.
+         * @param {object} event.context
+         * @param {boolean} event.context.valid Set this to `true` or `false` to indicate whether the drop position is valid.
+         */
+        this.onColumnDrag = new EventEmitter();
+        /**
+         * This event is fired when a column drag gesture has started.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance.
+         * @param {Grid.column.Column} event.column The dragged column.
+         * @param {Event} event.event The browser event.
+         */
+        this.onColumnDragStart = new EventEmitter();
+        /**
+         * This event is always fired after a column is dropped. The `valid` param is `true` if the operation was not
+         * vetoed and the column was moved in the column store.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance.
+         * @param {Grid.column.Column} event.column The dragged column.
+         * @param {Grid.column.Column} event.insertBefore The column before which the dragged column will be inserted.
+         * @param {Grid.column.Column} event.newParent The new parent column.
+         * @param {boolean} event.valid `true` if the operation was not vetoed.
+         * @param {Event} event.event The browser event.
+         * @param {string} event.region The region where the column was dropped.
+         */
+        this.onColumnDrop = new EventEmitter();
+        /**
+         * This event is fired after a resize gesture is completed.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance
+         * @param {Grid.column.Column} event.column The resized 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 {Grid.view.Grid} event.source The grid instance
+         * @param {Grid.column.Column} event.column The column
+         * @param {Event} event.domEvent The browser event
+         */
+        this.onColumnResizeStart = new EventEmitter();
+        /**
+         * This event fires on the owning widget when an item is selected in the context menu.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The owning widget
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         */
+        this.onContextMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning widget when a check item is toggled in the context menu.
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The owning widget
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {boolean} event.checked Checked or not
+         */
+        this.onContextMenuToggleItem = new EventEmitter();
+        /**
+         * Fires on the owning Grid after a copy action is performed.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {Grid.util.GridLocation[]} event.cells The cells about to be copied or cut
+         * @param {string} event.copiedDataString The concatenated data string that was copied or cut
+         * @param {boolean} event.isCut `true` if this was a cut action
+         * @param {string} event.entityName 'cell' to distinguish this event from other copy events
+         */
+        this.onCopy = new EventEmitter();
+        /**
+         * Fired when data in the store changes.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-dataChange)
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owning grid
+         * @param {Core.data.Store} event.store The originating store
+         * @param {'remove','removeAll','add','clearchanges','filter','update','dataset','replace'} event.action Name of action which triggered the change. May be one of:  * `'remove'` * `'removeAll'` * `'add'` * `'clearchanges'` * `'filter'` * `'update'` * `'dataset'` * `'replace'`
+         * @param {Core.data.Model} event.record Changed record, for actions that affects exactly one record (`'update'`)
+         * @param {Core.data.Model[]} event.records Changed records, passed for all actions except `'removeAll'`
+         * @param {object} event.changes Passed for the `'update'` action, info on which record fields changed
+         */
+        this.onDataChange = new EventEmitter();
+        /**
+         * Fires when 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/grid/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();
+        /**
+         * Fires while drag selecting. UI will update with current range, but the cells will not be selected until
+         * mouse up. This event can be listened for to perform actions while drag selecting.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source
+         * @param {GridLocationConfig[],Grid.util.GridLocation[]} event.selectedCells The cells that is currently being dragged over
+         * @param {Core.data.Model[]} event.selectedRecords The records that is currently being dragged over
+         */
+        this.onDragSelecting = new EventEmitter();
+        /**
+         * Triggered when a widget's [element](https://bryntum.com/products/grid/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/grid/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 after a parent node record is expanded.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance.
+         * @param {Core.data.Model} event.record The record which has been expanded.
+         */
+        this.onExpandNode = new EventEmitter();
+        /**
+         * Fired when a file is dropped on the widget element
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The owning Grid instance
+         * @param {DataTransferItem} event.file The dropped file descriptor
+         * @param {DragEvent} event.domEvent The native DragEvent
+         */
+        this.onFileDrop = new EventEmitter();
+        /**
+         * Fired before the FillHandle dragging is finalized and values are applied to cells, return `false` to prevent the
+         * drag operation from applying data changes.
+         * @param {object} event Event object
+         * @param {Grid.util.GridLocation} event.from The from cell
+         * @param {Grid.util.GridLocation} event.to The to cell
+         * @param {MouseEvent} event.domEvent The raw DOM event
+         */
+        this.onFillHandleBeforeDragFinalize = new EventEmitter();
+        /**
+         * Fired while dragging the FillHandle.
+         * @param {object} event Event object
+         * @param {Grid.util.GridLocation} event.from The from cell
+         * @param {Grid.util.GridLocation} event.to The to cell
+         * @param {MouseEvent} event.domEvent The raw DOM event
+         */
+        this.onFillHandleDrag = new EventEmitter();
+        /**
+         * Fired when a FillHandle drag operation is aborted.
+         */
+        this.onFillHandleDragAbort = new EventEmitter();
+        /**
+         * Fired after a FillHandle drag operation.
+         * @param {object} event Event object
+         * @param {Grid.util.GridLocation} event.from The from cell
+         * @param {Grid.util.GridLocation} event.to The to cell
+         * @param {MouseEvent} event.domEvent The raw DOM event
+         */
+        this.onFillHandleDragEnd = new EventEmitter();
+        /**
+         * Fired when dragging of the FillHandle starts.
+         * @param {object} event Event object
+         * @param {Grid.util.GridLocation} event.cell Information about the column / record
+         * @param {MouseEvent} event.domEvent The raw DOM event
+         */
+        this.onFillHandleDragStart = new EventEmitter();
+        /**
+         * Fires on the owning Grid when cell editing is finished
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid Target grid
+         * @param {CellEditorContext} event.editorContext Editing context
+         */
+        this.onFinishCellEdit = new EventEmitter();
+        /**
+         * Fires on the owning Grid before the row editing is finished, return false to signal that the value is invalid and editing should not be finalized.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-finishRowEdit)
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid Target grid
+         * @param {RowEditorContext} event.editorContext Editing context
+         */
+        this.onFinishRowEdit = 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();
+        /**
+         * Fired before dragging starts, return false to prevent the drag operation.
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.source
+         * @param {object} event.context
+         * @param {Core.data.Model[]} event.context.records The dragged row records
+         * @param {MouseEvent,TouchEvent} event.event
+         */
+        this.onGridRowBeforeDragStart = new EventEmitter();
+        /**
+         * Fired before the row drop operation is finalized. You can return false to abort the drop operation, or a
+         * Promise yielding `true` / `false` which allows for asynchronous abort (e.g. first show user a confirmation dialog).
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.source
+         * @param {object} event.context
+         * @param {boolean} event.context.valid Set this to true or false to indicate whether the drop position is valid
+         * @param {Core.data.Model} event.context.insertBefore The record to insert before (`null` if inserting at last position of a parent node)
+         * @param {Core.data.Model} event.context.parent The parent record of the current drop position (only applicable for trees)
+         * @param {Core.data.Model[]} event.context.records The dragged row records
+         * @param {RecordPositionContext[]} event.context.oldPositionContext An array of objects with information about the previous tree position. Objects contain the `record`, and its original `parentIndex` and `parentId` values
+         * @param {MouseEvent} event.event
+         */
+        this.onGridRowBeforeDropFinalize = new EventEmitter();
+        /**
+         * Fired while the row is being dragged, in the listener function you have access to `context.insertBefore` a grid /
+         * tree record, and additionally `context.parent` (a TreeNode) for trees. You can signal that the drop position is
+         * valid or invalid by setting `context.valid = false;`
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.source
+         * @param {object} event.context
+         * @param {boolean} event.context.valid Set this to true or false to indicate whether the drop position is valid.
+         * @param {Core.data.Model} event.context.insertBefore The record to insert before (`null` if inserting at last position of a parent node)
+         * @param {Core.data.Model} event.context.parent The parent record of the current drop position (only applicable for trees)
+         * @param {Core.data.Model[]} event.context.records The dragged row records
+         * @param {MouseEvent} event.event
+         */
+        this.onGridRowDrag = new EventEmitter();
+        /**
+         * Fired when a row drag operation is aborted
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.source
+         * @param {object} event.context
+         * @param {Core.data.Model[]} event.context.records The dragged row records
+         * @param {MouseEvent} event.event
+         */
+        this.onGridRowDragAbort = new EventEmitter();
+        /**
+         * Fired when dragging starts.
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.source
+         * @param {object} event.context
+         * @param {Core.data.Model[]} event.context.records The dragged row records
+         * @param {MouseEvent,TouchEvent} event.event
+         */
+        this.onGridRowDragStart = new EventEmitter();
+        /**
+         * Fired after the row drop operation has completed, regardless of validity
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.source
+         * @param {object} event.context
+         * @param {boolean} event.context.valid true or false depending on whether the drop position was valid
+         * @param {Core.data.Model} event.context.insertBefore The record to insert before (`null` if inserting at last position of a parent node)
+         * @param {Core.data.Model} event.context.parent The parent record of the current drop position (only applicable for trees)
+         * @param {Core.data.Model[]} event.context.records The dragged row records
+         * @param {RecordPositionContext[]} event.context.oldPositionContext An array of objects with information about the previous tree position. Objects contain the record, and its original `parentIndex` and `parentId` values
+         * @param {MouseEvent} event.event
+         */
+        this.onGridRowDrop = new EventEmitter();
+        /**
+         * Fired when a grid header is clicked on.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-headerClick)
+         * @param {object} event Event object
+         * @param {Event} event.domEvent The triggering DOM event.
+         * @param {Grid.column.Column} event.column The column clicked on.
+         */
+        this.onHeaderClick = new EventEmitter();
+        /**
+         * This event fires on the owning Grid before the context menu is shown for a header.
+         * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/grid/docs/api/Grid/feature/HeaderMenu#config-processItems).
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-headerMenuBeforeShow)
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {Grid.column.Column} event.column Column
+         */
+        this.onHeaderMenuBeforeShow = new EventEmitter();
+        /**
+         * This event fires on the owning Grid when an item is selected in the header context menu.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {Grid.column.Column} event.column Column
+         */
+        this.onHeaderMenuItem = new EventEmitter();
+        /**
+         * This event fires on the owning Grid after the context menu is shown for a header
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Record<string, MenuItemEntry>} event.items Menu item configs
+         * @param {Grid.column.Column} event.column Column
+         */
+        this.onHeaderMenuShow = new EventEmitter();
+        /**
+         * This event fires on the owning Grid when a check item is toggled in the header context menu.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid
+         * @param {Core.widget.Menu} event.menu The menu
+         * @param {Core.widget.MenuItem} event.item Selected menu item
+         * @param {Grid.column.Column} event.column Column
+         * @param {boolean} event.checked Checked or not
+         */
+        this.onHeaderMenuToggleItem = new EventEmitter();
+        /**
+         * Triggered after a widget was hidden
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget
+         */
+        this.onHide = new EventEmitter();
+        /**
+         * Fires when row locking is enabled.
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.clone The created clone
+         */
+        this.onLockRows = new EventEmitter();
+        /**
+         * Mouse moved out from element in grid
+         * @param {object} event Event object
+         * @param {MouseEvent} event.event The native browser event
+         */
+        this.onMouseOut = new EventEmitter();
+        /**
+         * Mouse moved in over element in grid
+         * @param {object} event Event object
+         * @param {MouseEvent} event.event The native browser event
+         */
+        this.onMouseOver = 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/grid/docs/api/Grid/view/Grid#event-paint)
+         * @param {object} event Event object
+         * @param {Core.widget.Widget} event.source The widget being painted.
+         * @param {boolean} event.firstPaint `true` if this is the first paint.
+         */
+        this.onPaint = new EventEmitter();
+        /**
+         * Fires on the owning Grid after a paste action is performed.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {string} event.clipboardData The clipboardData that was pasted
+         * @param {Core.data.Model[]} event.modifiedRecords The records which have been modified due to the paste action
+         * @param {Grid.util.GridLocation} event.targetCell The cell from which the paste will be started
+         * @param {string} event.entityName 'cell' to distinguish this event from other paste events
+         */
+        this.onPaste = new EventEmitter();
+        /**
+         * Fires on the owning Grid when export has finished
+         * @param {object} event Event object
+         * @param {Response} event.response Optional response, if received
+         * @param {Error} event.error Optional error, if exception occurred
+         */
+        this.onPdfExport = 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/grid/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.
+         */
+        this.onRecompose = new EventEmitter();
+        /**
+         * Fires after a row is rendered.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance.
+         * @param {Grid.row.Row} event.row The row that has been rendered.
+         * @param {Core.data.Model} event.record The record for the row.
+         * @param {number} event.recordIndex The zero-based index of the record.
+         */
+        this.onRenderRow = new EventEmitter();
+        /**
+         * Grid rows have been rendered
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source This grid.
+         */
+        this.onRenderRows = new EventEmitter();
+        /**
+         * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/grid/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();
+        /**
+         * Grid resize lead to a new responsive level being applied
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.grid Grid that was resized
+         * @param {string} event.level New responsive level (small, large, etc)
+         * @param {number} event.width New width in px
+         * @param {string} event.oldLevel Old responsive level
+         * @param {number} event.oldWidth Old width in px
+         */
+        this.onResponsive = new EventEmitter();
+        /**
+         * This event fires when a row has finished collapsing.
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.record Record
+         */
+        this.onRowCollapse = new EventEmitter();
+        /**
+         * This event fires when a row expand has finished expanding.
+         * ...
+         * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-rowExpand)
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.record Record
+         * @param {object} event.expandedElements An object with the Grid region name as property and the expanded body element as value
+         * @param {Core.widget.Widget} event.widget In case of expanding a Widget, this will be a reference to the instance created by the actual expansion. If there is multiple Grid regions, use the `widgets` param instead.
+         * @param {object} event.widgets In case of expanding a Widget, this will be an object with the Grid region name as property and the reference to the widget instance created by the actual expansion
+         */
+        this.onRowExpand = new EventEmitter();
+        /**
+         * Fired when the mouse enters a row
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance
+         * @param {Core.data.Model} event.record The record representing the hovered row
+         * @param {Grid.column.Column} event.column The column currently hovered
+         * @param {HTMLElement} event.cellElement The cell HTML element
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onRowMouseEnter = new EventEmitter();
+        /**
+         * Fired when the mouse leaves a row
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The grid instance
+         * @param {Core.data.Model} event.record The record representing the row that the mouse left
+         * @param {HTMLElement} event.cellElement The cell HTML element that the mouse left
+         * @param {MouseEvent} event.event The native DOM event
+         */
+        this.onRowMouseLeave = new EventEmitter();
+        /**
+         * Grid has scrolled vertically
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance.
+         * @param {number} event.scrollTop The vertical scroll position.
+         */
+        this.onScroll = new EventEmitter();
+        /**
+         * The selection has been changed.
+         * @param {object} event Event object
+         * @param {'select','deselect'} event.action `'select'`/`'deselect'`
+         * @param {'row','cell'} event.mode `'row'`/`'cell'`
+         * @param {Grid.view.Grid} event.source
+         * @param {Core.data.Model[]} event.deselected The records deselected in this operation.
+         * @param {Core.data.Model[]} event.selected The records selected in this operation.
+         * @param {Core.data.Model[]} event.selection The records in the new selection.
+         * @param {Grid.util.GridLocation[]} event.deselectedCells The cells deselected in this operation.
+         * @param {Grid.util.GridLocation[]} event.selectedCells The cells selected in this operation.
+         * @param {Grid.util.GridLocation[]} event.cellSelection The cells in the new selection.
+         */
+        this.onSelectionChange = new EventEmitter();
+        /**
+         * The selectionMode configuration has been changed.
+         * @param {object} event Event object
+         * @param {object} event.selectionMode The new [selectionMode](https://bryntum.com/products/grid/docs/api/Grid/view/mixin/GridSelection#config-selectionMode)
+         */
+        this.onSelectionModeChange = 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 when splitting the Grid.
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase[]} event.subViews The sub views created by the split
+         * @param {object} event.options The options passed to the split call
+         * @param {'horizontal','vertical','both'} event.options.direction The direction of the split
+         * @param {Grid.column.Column} event.options.atColumn The column to split at
+         * @param {Core.data.Model} event.options.atRecord The record to split at
+         */
+        this.onSplit = new EventEmitter();
+        /**
+         * Fired by the Grid when the collapse icon is clicked. Return `false` to prevent the default collapse action,
+         * if you want to implement your own behavior.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The Grid instance.
+         * @param {Grid.view.SubGrid} event.subGrid The subgrid
+         * @param {Event} event.domEvent The native DOM event
+         */
+        this.onSplitterCollapseClick = new EventEmitter();
+        /**
+         * Fired by the Grid after a sub-grid has been resized using the splitter
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The Grid instance.
+         * @param {Grid.view.SubGrid} event.subGrid The resized subgrid
+         * @param {Event} event.domEvent The native DOM event
+         */
+        this.onSplitterDragEnd = new EventEmitter();
+        /**
+         * Fired by the Grid when a sub-grid resize gesture starts
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The Grid instance.
+         * @param {Grid.view.SubGrid} event.subGrid The subgrid about to be resized
+         * @param {Event} event.domEvent The native DOM event
+         */
+        this.onSplitterDragStart = new EventEmitter();
+        /**
+         * Fired by the Grid when the expand icon is clicked. Return `false` to prevent the default expand action,
+         * if you want to implement your own behavior.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The Grid instance.
+         * @param {Grid.view.SubGrid} event.subGrid The subgrid
+         * @param {Event} event.domEvent The native DOM event
+         */
+        this.onSplitterExpandClick = new EventEmitter();
+        /**
+         * Fires on the owning Grid when editing starts
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {CellEditorContext} event.editorContext Editing context
+         */
+        this.onStartCellEdit = new EventEmitter();
+        /**
+         * Fires on the owning Grid when editing starts
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source Owner grid
+         * @param {RowEditorContext} event.editorContext Editing context
+         */
+        this.onStartRowEdit = new EventEmitter();
+        /**
+         * Fires after a sub grid is collapsed.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance
+         * @param {Grid.view.SubGrid} event.subGrid The sub grid instance
+         */
+        this.onSubGridCollapse = new EventEmitter();
+        /**
+         * Fires after a sub grid is expanded.
+         * @param {object} event Event object
+         * @param {Grid.view.Grid} event.source The firing Grid instance
+         * @param {Grid.view.SubGrid} event.subGrid The sub grid instance
+         */
+        this.onSubGridExpand = new EventEmitter();
+        /**
+         * Fired when one or more groups are expanded or collapsed
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.groupRecord [DEPRECATED] Use `groupRecords` param instead
+         * @param {Core.data.Model[]} event.groupRecords The group records being toggled
+         * @param {boolean} event.collapse Collapsed (true) or expanded (false)
+         * @param {boolean} event.allRecords True if this event is part of toggling all groups
+         */
+        this.onToggleGroup = new EventEmitter();
+        /**
+         * Fired after a parent node record toggles its collapsed state.
+         * @param {object} event Event object
+         * @param {Core.data.Model} event.record The record being toggled.
+         * @param {boolean} event.collapse `true` if the node is being collapsed.
+         */
+        this.onToggleNode = new EventEmitter();
+        /**
+         * A header [tool](https://bryntum.com/products/grid/docs/api/Core/widget/Panel#config-tools) has been clicked.
+         * @param {object} event Event object
+         * @param {Core.widget.Tool} event.source This Panel.
+         * @param {Core.widget.Tool} event.tool The tool which is being clicked.
+         */
+        this.onToolClick = new EventEmitter();
+        /**
+         * Fires when row locking is disabled.
+         * @param {object} event Event object
+         * @param {Grid.view.GridBase} event.clone The locked clone that will be destroyed
+         */
+        this.onUnlockRows = new EventEmitter();
+        /**
+         * Fires when un-splitting the Grid.
+         */
+        this.onUnsplit = new EventEmitter();
+        this.elementRef = element;
+    }
+    /**
+     * Create and append the underlying widget
+     */
+    ngOnInit() {
+        const me = this, { elementRef, bryntumConfig } = me, { instanceClass, instanceName, bryntumConfigs, bryntumEvents } = BryntumGridComponent;
+        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 } = BryntumGridComponent;
+        if (!instance) {
+            return;
+        }
+        // Iterate over all changes
+        Object.entries(changes).forEach(([prop, change]) => {
+            const newValue = change.currentValue, { instance } = this, { bryntumConfigsOnly, bryntumProps } = BryntumGridComponent;
+            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();
+        }
+    }
+}
+BryntumGridComponent.instanceClass = Grid;
+BryntumGridComponent.instanceName = 'Grid';
+BryntumGridComponent.bryntumEvents = [
+    'onBeforeCancelCellEdit',
+    'onBeforeCancelRowEdit',
+    'onBeforeCellEditStart',
+    'onBeforeCellRangeDelete',
+    'onBeforeCellRangeEdit',
+    'onBeforeColumnDragStart',
+    'onBeforeColumnDropFinalize',
+    'onBeforeColumnResize',
+    'onBeforeCopy',
+    'onBeforeCSVExport',
+    'onBeforeDestroy',
+    'onBeforeExcelExport',
+    'onBeforeFillHandleDragStart',
+    'onBeforeFinishCellEdit',
+    'onBeforeFinishRowEdit',
+    'onBeforeHide',
+    'onBeforePaste',
+    'onBeforePdfExport',
+    'onBeforeRenderRow',
+    'onBeforeRenderRows',
+    'onBeforeRowCollapse',
+    'onBeforeRowExpand',
+    'onBeforeSelectionChange',
+    'onBeforeSetRecord',
+    'onBeforeShow',
+    'onBeforeStartRowEdit',
+    'onBeforeStateApply',
+    'onBeforeStateSave',
+    'onBeforeToggleGroup',
+    'onBeforeToggleNode',
+    'onCancelCellEdit',
+    'onCatchAll',
+    'onCellClick',
+    'onCellContextMenu',
+    'onCellDblClick',
+    'onCellMenuBeforeShow',
+    'onCellMenuItem',
+    'onCellMenuShow',
+    'onCellMenuToggleItem',
+    'onCellMouseEnter',
+    'onCellMouseLeave',
+    'onCellMouseOut',
+    'onCellMouseOver',
+    'onCollapse',
+    'onCollapseNode',
+    'onColumnDrag',
+    'onColumnDragStart',
+    'onColumnDrop',
+    'onColumnResize',
+    'onColumnResizeStart',
+    'onContextMenuItem',
+    'onContextMenuToggleItem',
+    'onCopy',
+    'onDataChange',
+    'onDestroy',
+    'onDirtyStateChange',
+    'onDragSelecting',
+    'onElementCreated',
+    'onExpand',
+    'onExpandNode',
+    'onFileDrop',
+    'onFillHandleBeforeDragFinalize',
+    'onFillHandleDrag',
+    'onFillHandleDragAbort',
+    'onFillHandleDragEnd',
+    'onFillHandleDragStart',
+    'onFinishCellEdit',
+    'onFinishRowEdit',
+    'onFocusIn',
+    'onFocusOut',
+    'onGridRowBeforeDragStart',
+    'onGridRowBeforeDropFinalize',
+    'onGridRowDrag',
+    'onGridRowDragAbort',
+    'onGridRowDragStart',
+    'onGridRowDrop',
+    'onHeaderClick',
+    'onHeaderMenuBeforeShow',
+    'onHeaderMenuItem',
+    'onHeaderMenuShow',
+    'onHeaderMenuToggleItem',
+    'onHide',
+    'onLockRows',
+    'onMouseOut',
+    'onMouseOver',
+    'onPaint',
+    'onPaste',
+    'onPdfExport',
+    'onReadOnly',
+    'onRecompose',
+    'onRenderRow',
+    'onRenderRows',
+    'onResize',
+    'onResponsive',
+    'onRowCollapse',
+    'onRowExpand',
+    'onRowMouseEnter',
+    'onRowMouseLeave',
+    'onScroll',
+    'onSelectionChange',
+    'onSelectionModeChange',
+    'onShow',
+    'onSplit',
+    'onSplitterCollapseClick',
+    'onSplitterDragEnd',
+    'onSplitterDragStart',
+    'onSplitterExpandClick',
+    'onStartCellEdit',
+    'onStartRowEdit',
+    'onSubGridCollapse',
+    'onSubGridExpand',
+    'onToggleGroup',
+    'onToggleNode',
+    'onToolClick',
+    'onUnlockRows',
+    'onUnsplit'
+];
+BryntumGridComponent.bryntumFeatureNames = [
+    'aiFilterFeature',
+    'cellCopyPasteFeature',
+    'cellEditFeature',
+    'cellMenuFeature',
+    'cellTooltipFeature',
+    'chartsFeature',
+    'columnAutoWidthFeature',
+    'columnDragToolbarFeature',
+    'columnPickerFeature',
+    'columnRenameFeature',
+    'columnReorderFeature',
+    'columnResizeFeature',
+    'excelExporterFeature',
+    'fileDropFeature',
+    'fillHandleFeature',
+    'filterFeature',
+    'filterBarFeature',
+    'groupFeature',
+    'groupSummaryFeature',
+    'headerMenuFeature',
+    'lockRowsFeature',
+    'mergeCellsFeature',
+    'pdfExportFeature',
+    'pinColumnsFeature',
+    'printFeature',
+    'quickFindFeature',
+    'regionResizeFeature',
+    'rowCopyPasteFeature',
+    'rowEditFeature',
+    'rowExpanderFeature',
+    'rowReorderFeature',
+    'rowResizeFeature',
+    'searchFeature',
+    'sortFeature',
+    'splitFeature',
+    'stickyCellsFeature',
+    'stripeFeature',
+    'summaryFeature',
+    'treeFeature',
+    'treeGroupFeature'
+];
+BryntumGridComponent.bryntumConfigs = BryntumGridComponent.bryntumFeatureNames.concat([
+    'adopt',
+    'alignSelf',
+    'animateFilterRemovals',
+    'animateRemovingRows',
+    'animateTreeNodeToggle',
+    'appendTo',
+    'ariaDescription',
+    'ariaLabel',
+    'autoHeight',
+    'bbar',
+    'bodyCls',
+    'bubbleEvents',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'cellEllipsis',
+    'cls',
+    'collapsed',
+    'collapsible',
+    'color',
+    'column',
+    'columnLines',
+    'columns',
+    'config',
+    'contentElementCls',
+    'contextMenuTriggerEvent',
+    'data',
+    'dataField',
+    'dataset',
+    'defaultRegion',
+    'destroyStore',
+    'detectCSSCompatibilityIssues',
+    'disabled',
+    'disableGridColumnIdWarning',
+    'disableGridRowModelWarning',
+    'dock',
+    'drawer',
+    'elementAttributes',
+    'emptyText',
+    'enableSticky',
+    'enableTextSelection',
+    'enableUndoRedoKeys',
+    'extraData',
+    'fillLastColumn',
+    'fixedRowHeight',
+    'flex',
+    'footer',
+    'formulaProviders',
+    'fullRowRefresh',
+    'getRowHeight',
+    'header',
+    'height',
+    'hidden',
+    'hideFooters',
+    'hideHeaders',
+    'hideHorizontalScrollbar',
+    'hoverCls',
+    'icon',
+    'id',
+    'ignoreParentReadOnly',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'keyMap',
+    'labelPosition',
+    'listeners',
+    'loadMask',
+    'loadMaskDefaults',
+    'loadMaskError',
+    'localizable',
+    'longPressTime',
+    'margin',
+    'maskDefaults',
+    'masked',
+    'maxHeight',
+    'maxWidth',
+    'minHeight',
+    'minWidth',
+    'monitorResize',
+    'owner',
+    'plugins',
+    'preserveFocusOnDatasetChange',
+    'preserveScroll',
+    'preserveScrollOnDatasetChange',
+    'preventTooltipOnTouch',
+    'readOnly',
+    'relayStoreEvents',
+    'rendition',
+    'resizable',
+    'resizeToFitIncludesHeader',
+    'responsiveLevels',
+    'ripple',
+    'rootElement',
+    'rowHeight',
+    'rowLines',
+    'rtl',
+    'scrollable',
+    'scrollerClass',
+    'scrollManager',
+    'selectionMode',
+    'showDirty',
+    'span',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'stateSettings',
+    'store',
+    'strips',
+    'subGridConfigs',
+    'syncMask',
+    'tab',
+    'tabBarItems',
+    'tbar',
+    'title',
+    'tools',
+    'transition',
+    'transitionDuration',
+    'type',
+    'ui',
+    'weight',
+    'width'
+]);
+BryntumGridComponent.bryntumConfigsOnly = [
+    'adopt',
+    'animateFilterRemovals',
+    'animateRemovingRows',
+    'ariaDescription',
+    'ariaLabel',
+    'autoHeight',
+    'bbar',
+    'bodyCls',
+    'bubbleEvents',
+    'collapsible',
+    'color',
+    'config',
+    'contentElementCls',
+    'contextMenuTriggerEvent',
+    'dataField',
+    'defaultRegion',
+    'destroyStore',
+    'detectCSSCompatibilityIssues',
+    'disableGridColumnIdWarning',
+    'disableGridRowModelWarning',
+    'dock',
+    'drawer',
+    'elementAttributes',
+    'enableSticky',
+    'enableTextSelection',
+    'fillLastColumn',
+    'fixedRowHeight',
+    'footer',
+    'formulaProviders',
+    'fullRowRefresh',
+    'getRowHeight',
+    'header',
+    'hideHorizontalScrollbar',
+    'hoverCls',
+    'icon',
+    'ignoreParentReadOnly',
+    'listeners',
+    'loadMask',
+    'loadMaskDefaults',
+    'loadMaskError',
+    'localizable',
+    'maskDefaults',
+    'masked',
+    'monitorResize',
+    'owner',
+    'plugins',
+    'preserveFocusOnDatasetChange',
+    'preserveScrollOnDatasetChange',
+    'preventTooltipOnTouch',
+    'relayStoreEvents',
+    'resizable',
+    'resizeToFitIncludesHeader',
+    'responsiveLevels',
+    'ripple',
+    'rootElement',
+    'scrollerClass',
+    'scrollManager',
+    'showDirty',
+    'stateful',
+    'statefulEvents',
+    'stateId',
+    'stateProvider',
+    'strips',
+    'subGridConfigs',
+    'syncMask',
+    'tab',
+    'tabBarItems',
+    'tbar',
+    'type',
+    'ui',
+    'weight'
+];
+BryntumGridComponent.bryntumProps = BryntumGridComponent.bryntumFeatureNames.concat([
+    'alignSelf',
+    'animateTreeNodeToggle',
+    'appendTo',
+    'callOnFunctions',
+    'catchEventHandlerExceptions',
+    'cellEllipsis',
+    'cls',
+    'collapsed',
+    'column',
+    'columnLines',
+    'columns',
+    'data',
+    'dataset',
+    'disabled',
+    'emptyText',
+    'enableUndoRedoKeys',
+    'extraData',
+    'flex',
+    'focusVisible',
+    'hasChanges',
+    'height',
+    'hidden',
+    'hideFooters',
+    'hideHeaders',
+    'id',
+    'inputFieldAlign',
+    'insertBefore',
+    'insertFirst',
+    'keyMap',
+    'labelPosition',
+    'longPressTime',
+    'margin',
+    'maxHeight',
+    'maxWidth',
+    'minHeight',
+    'minWidth',
+    'originalStore',
+    'parent',
+    'preserveScroll',
+    'readOnly',
+    'rendition',
+    'rowHeight',
+    'rowLines',
+    'rtl',
+    'scrollable',
+    'selectedCell',
+    'selectedCells',
+    'selectedRecord',
+    'selectedRecords',
+    'selectedRows',
+    'selectionMode',
+    'span',
+    'state',
+    'stateSettings',
+    'store',
+    'title',
+    'tools',
+    'tooltip',
+    'transition',
+    'transitionDuration',
+    'width'
+]);
+BryntumGridComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumGridComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+BryntumGridComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.0", type: BryntumGridComponent, selector: "bryntum-grid", inputs: { adopt: "adopt", animateFilterRemovals: "animateFilterRemovals", animateRemovingRows: "animateRemovingRows", ariaDescription: "ariaDescription", ariaLabel: "ariaLabel", autoHeight: "autoHeight", bbar: "bbar", bodyCls: "bodyCls", bubbleEvents: "bubbleEvents", collapsible: "collapsible", color: "color", config: "config", contentElementCls: "contentElementCls", contextMenuTriggerEvent: "contextMenuTriggerEvent", dataField: "dataField", defaultRegion: "defaultRegion", destroyStore: "destroyStore", detectCSSCompatibilityIssues: "detectCSSCompatibilityIssues", disableGridColumnIdWarning: "disableGridColumnIdWarning", disableGridRowModelWarning: "disableGridRowModelWarning", dock: "dock", drawer: "drawer", elementAttributes: "elementAttributes", enableSticky: "enableSticky", enableTextSelection: "enableTextSelection", fillLastColumn: "fillLastColumn", fixedRowHeight: "fixedRowHeight", footer: "footer", formulaProviders: "formulaProviders", fullRowRefresh: "fullRowRefresh", getRowHeight: "getRowHeight", header: "header", hideHorizontalScrollbar: "hideHorizontalScrollbar", hoverCls: "hoverCls", icon: "icon", ignoreParentReadOnly: "ignoreParentReadOnly", listeners: "listeners", loadMask: "loadMask", loadMaskDefaults: "loadMaskDefaults", loadMaskError: "loadMaskError", localizable: "localizable", maskDefaults: "maskDefaults", masked: "masked", monitorResize: "monitorResize", owner: "owner", plugins: "plugins", preserveFocusOnDatasetChange: "preserveFocusOnDatasetChange", preserveScrollOnDatasetChange: "preserveScrollOnDatasetChange", preventTooltipOnTouch: "preventTooltipOnTouch", relayStoreEvents: "relayStoreEvents", resizable: "resizable", resizeToFitIncludesHeader: "resizeToFitIncludesHeader", responsiveLevels: "responsiveLevels", ripple: "ripple", rootElement: "rootElement", scrollerClass: "scrollerClass", scrollManager: "scrollManager", showDirty: "showDirty", stateful: "stateful", statefulEvents: "statefulEvents", stateId: "stateId", stateProvider: "stateProvider", strips: "strips", subGridConfigs: "subGridConfigs", syncMask: "syncMask", tab: "tab", tabBarItems: "tabBarItems", tbar: "tbar", type: "type", ui: "ui", weight: "weight", alignSelf: "alignSelf", animateTreeNodeToggle: "animateTreeNodeToggle", appendTo: "appendTo", callOnFunctions: "callOnFunctions", catchEventHandlerExceptions: "catchEventHandlerExceptions", cellEllipsis: "cellEllipsis", cls: "cls", collapsed: "collapsed", column: "column", columnLines: "columnLines", columns: "columns", data: "data", dataset: "dataset", disabled: "disabled", emptyText: "emptyText", enableUndoRedoKeys: "enableUndoRedoKeys", extraData: "extraData", flex: "flex", height: "height", hidden: "hidden", hideFooters: "hideFooters", hideHeaders: "hideHeaders", id: "id", inputFieldAlign: "inputFieldAlign", insertBefore: "insertBefore", insertFirst: "insertFirst", keyMap: "keyMap", labelPosition: "labelPosition", longPressTime: "longPressTime", margin: "margin", maxHeight: "maxHeight", maxWidth: "maxWidth", minHeight: "minHeight", minWidth: "minWidth", preserveScroll: "preserveScroll", readOnly: "readOnly", rendition: "rendition", rowHeight: "rowHeight", rowLines: "rowLines", rtl: "rtl", scrollable: "scrollable", selectionMode: "selectionMode", span: "span", stateSettings: "stateSettings", store: "store", title: "title", tools: "tools", transition: "transition", transitionDuration: "transitionDuration", width: "width", focusVisible: "focusVisible", hasChanges: "hasChanges", originalStore: "originalStore", parent: "parent", selectedCell: "selectedCell", selectedCells: "selectedCells", selectedRecord: "selectedRecord", selectedRecords: "selectedRecords", selectedRows: "selectedRows", state: "state", tooltip: "tooltip", aiFilterFeature: "aiFilterFeature", cellCopyPasteFeature: "cellCopyPasteFeature", cellEditFeature: "cellEditFeature", cellMenuFeature: "cellMenuFeature", cellTooltipFeature: "cellTooltipFeature", chartsFeature: "chartsFeature", columnAutoWidthFeature: "columnAutoWidthFeature", columnDragToolbarFeature: "columnDragToolbarFeature", columnPickerFeature: "columnPickerFeature", columnRenameFeature: "columnRenameFeature", columnReorderFeature: "columnReorderFeature", columnResizeFeature: "columnResizeFeature", excelExporterFeature: "excelExporterFeature", fileDropFeature: "fileDropFeature", fillHandleFeature: "fillHandleFeature", filterFeature: "filterFeature", filterBarFeature: "filterBarFeature", groupFeature: "groupFeature", groupSummaryFeature: "groupSummaryFeature", headerMenuFeature: "headerMenuFeature", lockRowsFeature: "lockRowsFeature", mergeCellsFeature: "mergeCellsFeature", pdfExportFeature: "pdfExportFeature", pinColumnsFeature: "pinColumnsFeature", printFeature: "printFeature", quickFindFeature: "quickFindFeature", regionResizeFeature: "regionResizeFeature", rowCopyPasteFeature: "rowCopyPasteFeature", rowEditFeature: "rowEditFeature", rowExpanderFeature: "rowExpanderFeature", rowReorderFeature: "rowReorderFeature", rowResizeFeature: "rowResizeFeature", searchFeature: "searchFeature", sortFeature: "sortFeature", splitFeature: "splitFeature", stickyCellsFeature: "stickyCellsFeature", stripeFeature: "stripeFeature", summaryFeature: "summaryFeature", treeFeature: "treeFeature", treeGroupFeature: "treeGroupFeature" }, outputs: { onBeforeCancelCellEdit: "onBeforeCancelCellEdit", onBeforeCancelRowEdit: "onBeforeCancelRowEdit", onBeforeCellEditStart: "onBeforeCellEditStart", onBeforeCellRangeDelete: "onBeforeCellRangeDelete", onBeforeCellRangeEdit: "onBeforeCellRangeEdit", onBeforeColumnDragStart: "onBeforeColumnDragStart", onBeforeColumnDropFinalize: "onBeforeColumnDropFinalize", onBeforeColumnResize: "onBeforeColumnResize", onBeforeCopy: "onBeforeCopy", onBeforeCSVExport: "onBeforeCSVExport", onBeforeDestroy: "onBeforeDestroy", onBeforeExcelExport: "onBeforeExcelExport", onBeforeFillHandleDragStart: "onBeforeFillHandleDragStart", onBeforeFinishCellEdit: "onBeforeFinishCellEdit", onBeforeFinishRowEdit: "onBeforeFinishRowEdit", onBeforeHide: "onBeforeHide", onBeforePaste: "onBeforePaste", onBeforePdfExport: "onBeforePdfExport", onBeforeRenderRow: "onBeforeRenderRow", onBeforeRenderRows: "onBeforeRenderRows", onBeforeRowCollapse: "onBeforeRowCollapse", onBeforeRowExpand: "onBeforeRowExpand", onBeforeSelectionChange: "onBeforeSelectionChange", onBeforeSetRecord: "onBeforeSetRecord", onBeforeShow: "onBeforeShow", onBeforeStartRowEdit: "onBeforeStartRowEdit", onBeforeStateApply: "onBeforeStateApply", onBeforeStateSave: "onBeforeStateSave", onBeforeToggleGroup: "onBeforeToggleGroup", onBeforeToggleNode: "onBeforeToggleNode", onCancelCellEdit: "onCancelCellEdit", onCatchAll: "onCatchAll", onCellClick: "onCellClick", onCellContextMenu: "onCellContextMenu", onCellDblClick: "onCellDblClick", onCellMenuBeforeShow: "onCellMenuBeforeShow", onCellMenuItem: "onCellMenuItem", onCellMenuShow: "onCellMenuShow", onCellMenuToggleItem: "onCellMenuToggleItem", onCellMouseEnter: "onCellMouseEnter", onCellMouseLeave: "onCellMouseLeave", onCellMouseOut: "onCellMouseOut", onCellMouseOver: "onCellMouseOver", onCollapse: "onCollapse", onCollapseNode: "onCollapseNode", onColumnDrag: "onColumnDrag", onColumnDragStart: "onColumnDragStart", onColumnDrop: "onColumnDrop", onColumnResize: "onColumnResize", onColumnResizeStart: "onColumnResizeStart", onContextMenuItem: "onContextMenuItem", onContextMenuToggleItem: "onContextMenuToggleItem", onCopy: "onCopy", onDataChange: "onDataChange", onDestroy: "onDestroy", onDirtyStateChange: "onDirtyStateChange", onDragSelecting: "onDragSelecting", onElementCreated: "onElementCreated", onExpand: "onExpand", onExpandNode: "onExpandNode", onFileDrop: "onFileDrop", onFillHandleBeforeDragFinalize: "onFillHandleBeforeDragFinalize", onFillHandleDrag: "onFillHandleDrag", onFillHandleDragAbort: "onFillHandleDragAbort", onFillHandleDragEnd: "onFillHandleDragEnd", onFillHandleDragStart: "onFillHandleDragStart", onFinishCellEdit: "onFinishCellEdit", onFinishRowEdit: "onFinishRowEdit", onFocusIn: "onFocusIn", onFocusOut: "onFocusOut", onGridRowBeforeDragStart: "onGridRowBeforeDragStart", onGridRowBeforeDropFinalize: "onGridRowBeforeDropFinalize", onGridRowDrag: "onGridRowDrag", onGridRowDragAbort: "onGridRowDragAbort", onGridRowDragStart: "onGridRowDragStart", onGridRowDrop: "onGridRowDrop", onHeaderClick: "onHeaderClick", onHeaderMenuBeforeShow: "onHeaderMenuBeforeShow", onHeaderMenuItem: "onHeaderMenuItem", onHeaderMenuShow: "onHeaderMenuShow", onHeaderMenuToggleItem: "onHeaderMenuToggleItem", onHide: "onHide", onLockRows: "onLockRows", onMouseOut: "onMouseOut", onMouseOver: "onMouseOver", onPaint: "onPaint", onPaste: "onPaste", onPdfExport: "onPdfExport", onReadOnly: "onReadOnly", onRecompose: "onRecompose", onRenderRow: "onRenderRow", onRenderRows: "onRenderRows", onResize: "onResize", onResponsive: "onResponsive", onRowCollapse: "onRowCollapse", onRowExpand: "onRowExpand", onRowMouseEnter: "onRowMouseEnter", onRowMouseLeave: "onRowMouseLeave", onScroll: "onScroll", onSelectionChange: "onSelectionChange", onSelectionModeChange: "onSelectionModeChange", onShow: "onShow", onSplit: "onSplit", onSplitterCollapseClick: "onSplitterCollapseClick", onSplitterDragEnd: "onSplitterDragEnd", onSplitterDragStart: "onSplitterDragStart", onSplitterExpandClick: "onSplitterExpandClick", onStartCellEdit: "onStartCellEdit", onStartRowEdit: "onStartRowEdit", onSubGridCollapse: "onSubGridCollapse", onSubGridExpand: "onSubGridExpand", onToggleGroup: "onToggleGroup", onToggleNode: "onToggleNode", onToolClick: "onToolClick", onUnlockRows: "onUnlockRows", onUnsplit: "onUnsplit" }, usesOnChanges: true, ngImport: i0, template: '', isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.0", ngImport: i0, type: BryntumGridComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bryntum-grid',
+                    template: ''
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { adopt: [{
+                type: Input
+            }], animateFilterRemovals: [{
+                type: Input
+            }], animateRemovingRows: [{
+                type: Input
+            }], ariaDescription: [{
+                type: Input
+            }], ariaLabel: [{
+                type: Input
+            }], autoHeight: [{
+                type: Input
+            }], bbar: [{
+                type: Input
+            }], bodyCls: [{
+                type: Input
+            }], bubbleEvents: [{
+                type: Input
+            }], collapsible: [{
+                type: Input
+            }], color: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], contentElementCls: [{
+                type: Input
+            }], contextMenuTriggerEvent: [{
+                type: Input
+            }], dataField: [{
+                type: Input
+            }], defaultRegion: [{
+                type: Input
+            }], destroyStore: [{
+                type: Input
+            }], detectCSSCompatibilityIssues: [{
+                type: Input
+            }], disableGridColumnIdWarning: [{
+                type: Input
+            }], disableGridRowModelWarning: [{
+                type: Input
+            }], dock: [{
+                type: Input
+            }], drawer: [{
+                type: Input
+            }], elementAttributes: [{
+                type: Input
+            }], enableSticky: [{
+                type: Input
+            }], enableTextSelection: [{
+                type: Input
+            }], fillLastColumn: [{
+                type: Input
+            }], fixedRowHeight: [{
+                type: Input
+            }], footer: [{
+                type: Input
+            }], formulaProviders: [{
+                type: Input
+            }], fullRowRefresh: [{
+                type: Input
+            }], getRowHeight: [{
+                type: Input
+            }], header: [{
+                type: Input
+            }], hideHorizontalScrollbar: [{
+                type: Input
+            }], hoverCls: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], ignoreParentReadOnly: [{
+                type: Input
+            }], listeners: [{
+                type: Input
+            }], loadMask: [{
+                type: Input
+            }], loadMaskDefaults: [{
+                type: Input
+            }], loadMaskError: [{
+                type: Input
+            }], localizable: [{
+                type: Input
+            }], maskDefaults: [{
+                type: Input
+            }], masked: [{
+                type: Input
+            }], monitorResize: [{
+                type: Input
+            }], owner: [{
+                type: Input
+            }], plugins: [{
+                type: Input
+            }], preserveFocusOnDatasetChange: [{
+                type: Input
+            }], preserveScrollOnDatasetChange: [{
+                type: Input
+            }], preventTooltipOnTouch: [{
+                type: Input
+            }], relayStoreEvents: [{
+                type: Input
+            }], resizable: [{
+                type: Input
+            }], resizeToFitIncludesHeader: [{
+                type: Input
+            }], responsiveLevels: [{
+                type: Input
+            }], ripple: [{
+                type: Input
+            }], rootElement: [{
+                type: Input
+            }], scrollerClass: [{
+                type: Input
+            }], scrollManager: [{
+                type: Input
+            }], showDirty: [{
+                type: Input
+            }], stateful: [{
+                type: Input
+            }], statefulEvents: [{
+                type: Input
+            }], stateId: [{
+                type: Input
+            }], stateProvider: [{
+                type: Input
+            }], strips: [{
+                type: Input
+            }], subGridConfigs: [{
+                type: Input
+            }], syncMask: [{
+                type: Input
+            }], tab: [{
+                type: Input
+            }], tabBarItems: [{
+                type: Input
+            }], tbar: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], ui: [{
+                type: Input
+            }], weight: [{
+                type: Input
+            }], alignSelf: [{
+                type: Input
+            }], animateTreeNodeToggle: [{
+                type: Input
+            }], appendTo: [{
+                type: Input
+            }], callOnFunctions: [{
+                type: Input
+            }], catchEventHandlerExceptions: [{
+                type: Input
+            }], cellEllipsis: [{
+                type: Input
+            }], cls: [{
+                type: Input
+            }], collapsed: [{
+                type: Input
+            }], column: [{
+                type: Input
+            }], columnLines: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], dataset: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], emptyText: [{
+                type: Input
+            }], enableUndoRedoKeys: [{
+                type: Input
+            }], extraData: [{
+                type: Input
+            }], flex: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], hidden: [{
+                type: Input
+            }], hideFooters: [{
+                type: Input
+            }], hideHeaders: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], inputFieldAlign: [{
+                type: Input
+            }], insertBefore: [{
+                type: Input
+            }], insertFirst: [{
+                type: Input
+            }], keyMap: [{
+                type: Input
+            }], labelPosition: [{
+                type: Input
+            }], longPressTime: [{
+                type: Input
+            }], margin: [{
+                type: Input
+            }], maxHeight: [{
+                type: Input
+            }], maxWidth: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], preserveScroll: [{
+                type: Input
+            }], readOnly: [{
+                type: Input
+            }], rendition: [{
+                type: Input
+            }], rowHeight: [{
+                type: Input
+            }], rowLines: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], scrollable: [{
+                type: Input
+            }], selectionMode: [{
+                type: Input
+            }], span: [{
+                type: Input
+            }], stateSettings: [{
+                type: Input
+            }], store: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], tools: [{
+                type: Input
+            }], transition: [{
+                type: Input
+            }], transitionDuration: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], focusVisible: [{
+                type: Input
+            }], hasChanges: [{
+                type: Input
+            }], originalStore: [{
+                type: Input
+            }], parent: [{
+                type: Input
+            }], selectedCell: [{
+                type: Input
+            }], selectedCells: [{
+                type: Input
+            }], selectedRecord: [{
+                type: Input
+            }], selectedRecords: [{
+                type: Input
+            }], selectedRows: [{
+                type: Input
+            }], state: [{
+                type: Input
+            }], tooltip: [{
+                type: Input
+            }], aiFilterFeature: [{
+                type: Input
+            }], cellCopyPasteFeature: [{
+                type: Input
+            }], cellEditFeature: [{
+                type: Input
+            }], cellMenuFeature: [{
+                type: Input
+            }], cellTooltipFeature: [{
+                type: Input
+            }], chartsFeature: [{
+                type: Input
+            }], columnAutoWidthFeature: [{
+                type: Input
+            }], columnDragToolbarFeature: [{
+                type: Input
+            }], columnPickerFeature: [{
+                type: Input
+            }], columnRenameFeature: [{
+                type: Input
+            }], columnReorderFeature: [{
+                type: Input
+            }], columnResizeFeature: [{
+                type: Input
+            }], excelExporterFeature: [{
+                type: Input
+            }], fileDropFeature: [{
+                type: Input
+            }], fillHandleFeature: [{
+                type: Input
+            }], filterFeature: [{
+                type: Input
+            }], filterBarFeature: [{
+                type: Input
+            }], groupFeature: [{
+                type: Input
+            }], groupSummaryFeature: [{
+                type: Input
+            }], headerMenuFeature: [{
+                type: Input
+            }], lockRowsFeature: [{
+                type: Input
+            }], mergeCellsFeature: [{
+                type: Input
+            }], pdfExportFeature: [{
+                type: Input
+            }], pinColumnsFeature: [{
+                type: Input
+            }], printFeature: [{
+                type: Input
+            }], quickFindFeature: [{
+                type: Input
+            }], regionResizeFeature: [{
+                type: Input
+            }], rowCopyPasteFeature: [{
+                type: Input
+            }], rowEditFeature: [{
+                type: Input
+            }], rowExpanderFeature: [{
+                type: Input
+            }], rowReorderFeature: [{
+                type: Input
+            }], rowResizeFeature: [{
+                type: Input
+            }], searchFeature: [{
+                type: Input
+            }], sortFeature: [{
+                type: Input
+            }], splitFeature: [{
+                type: Input
+            }], stickyCellsFeature: [{
+                type: Input
+            }], stripeFeature: [{
+                type: Input
+            }], summaryFeature: [{
+                type: Input
+            }], treeFeature: [{
+                type: Input
+            }], treeGroupFeature: [{
+                type: Input
+            }], onBeforeCancelCellEdit: [{
+                type: Output
+            }], onBeforeCancelRowEdit: [{
+                type: Output
+            }], onBeforeCellEditStart: [{
+                type: Output
+            }], onBeforeCellRangeDelete: [{
+                type: Output
+            }], onBeforeCellRangeEdit: [{
+                type: Output
+            }], onBeforeColumnDragStart: [{
+                type: Output
+            }], onBeforeColumnDropFinalize: [{
+                type: Output
+            }], onBeforeColumnResize: [{
+                type: Output
+            }], onBeforeCopy: [{
+                type: Output
+            }], onBeforeCSVExport: [{
+                type: Output
+            }], onBeforeDestroy: [{
+                type: Output
+            }], onBeforeExcelExport: [{
+                type: Output
+            }], onBeforeFillHandleDragStart: [{
+                type: Output
+            }], onBeforeFinishCellEdit: [{
+                type: Output
+            }], onBeforeFinishRowEdit: [{
+                type: Output
+            }], onBeforeHide: [{
+                type: Output
+            }], onBeforePaste: [{
+                type: Output
+            }], onBeforePdfExport: [{
+                type: Output
+            }], onBeforeRenderRow: [{
+                type: Output
+            }], onBeforeRenderRows: [{
+                type: Output
+            }], onBeforeRowCollapse: [{
+                type: Output
+            }], onBeforeRowExpand: [{
+                type: Output
+            }], onBeforeSelectionChange: [{
+                type: Output
+            }], onBeforeSetRecord: [{
+                type: Output
+            }], onBeforeShow: [{
+                type: Output
+            }], onBeforeStartRowEdit: [{
+                type: Output
+            }], onBeforeStateApply: [{
+                type: Output
+            }], onBeforeStateSave: [{
+                type: Output
+            }], onBeforeToggleGroup: [{
+                type: Output
+            }], onBeforeToggleNode: [{
+                type: Output
+            }], onCancelCellEdit: [{
+                type: Output
+            }], onCatchAll: [{
+                type: Output
+            }], onCellClick: [{
+                type: Output
+            }], onCellContextMenu: [{
+                type: Output
+            }], onCellDblClick: [{
+                type: Output
+            }], onCellMenuBeforeShow: [{
+                type: Output
+            }], onCellMenuItem: [{
+                type: Output
+            }], onCellMenuShow: [{
+                type: Output
+            }], onCellMenuToggleItem: [{
+                type: Output
+            }], onCellMouseEnter: [{
+                type: Output
+            }], onCellMouseLeave: [{
+                type: Output
+            }], onCellMouseOut: [{
+                type: Output
+            }], onCellMouseOver: [{
+                type: Output
+            }], onCollapse: [{
+                type: Output
+            }], onCollapseNode: [{
+                type: Output
+            }], onColumnDrag: [{
+                type: Output
+            }], onColumnDragStart: [{
+                type: Output
+            }], onColumnDrop: [{
+                type: Output
+            }], onColumnResize: [{
+                type: Output
+            }], onColumnResizeStart: [{
+                type: Output
+            }], onContextMenuItem: [{
+                type: Output
+            }], onContextMenuToggleItem: [{
+                type: Output
+            }], onCopy: [{
+                type: Output
+            }], onDataChange: [{
+                type: Output
+            }], onDestroy: [{
+                type: Output
+            }], onDirtyStateChange: [{
+                type: Output
+            }], onDragSelecting: [{
+                type: Output
+            }], onElementCreated: [{
+                type: Output
+            }], onExpand: [{
+                type: Output
+            }], onExpandNode: [{
+                type: Output
+            }], onFileDrop: [{
+                type: Output
+            }], onFillHandleBeforeDragFinalize: [{
+                type: Output
+            }], onFillHandleDrag: [{
+                type: Output
+            }], onFillHandleDragAbort: [{
+                type: Output
+            }], onFillHandleDragEnd: [{
+                type: Output
+            }], onFillHandleDragStart: [{
+                type: Output
+            }], onFinishCellEdit: [{
+                type: Output
+            }], onFinishRowEdit: [{
+                type: Output
+            }], onFocusIn: [{
+                type: Output
+            }], onFocusOut: [{
+                type: Output
+            }], onGridRowBeforeDragStart: [{
+                type: Output
+            }], onGridRowBeforeDropFinalize: [{
+                type: Output
+            }], onGridRowDrag: [{
+                type: Output
+            }], onGridRowDragAbort: [{
+                type: Output
+            }], onGridRowDragStart: [{
+                type: Output
+            }], onGridRowDrop: [{
+                type: Output
+            }], onHeaderClick: [{
+                type: Output
+            }], onHeaderMenuBeforeShow: [{
+                type: Output
+            }], onHeaderMenuItem: [{
+                type: Output
+            }], onHeaderMenuShow: [{
+                type: Output
+            }], onHeaderMenuToggleItem: [{
+                type: Output
+            }], onHide: [{
+                type: Output
+            }], onLockRows: [{
+                type: Output
+            }], onMouseOut: [{
+                type: Output
+            }], onMouseOver: [{
+                type: Output
+            }], onPaint: [{
+                type: Output
+            }], onPaste: [{
+                type: Output
+            }], onPdfExport: [{
+                type: Output
+            }], onReadOnly: [{
+                type: Output
+            }], onRecompose: [{
+                type: Output
+            }], onRenderRow: [{
+                type: Output
+            }], onRenderRows: [{
+                type: Output
+            }], onResize: [{
+                type: Output
+            }], onResponsive: [{
+                type: Output
+            }], onRowCollapse: [{
+                type: Output
+            }], onRowExpand: [{
+                type: Output
+            }], onRowMouseEnter: [{
+                type: Output
+            }], onRowMouseLeave: [{
+                type: Output
+            }], onScroll: [{
+                type: Output
+            }], onSelectionChange: [{
+                type: Output
+            }], onSelectionModeChange: [{
+                type: Output
+            }], onShow: [{
+                type: Output
+            }], onSplit: [{
+                type: Output
+            }], onSplitterCollapseClick: [{
+                type: Output
+            }], onSplitterDragEnd: [{
+                type: Output
+            }], onSplitterDragStart: [{
+                type: Output
+            }], onSplitterExpandClick: [{
+                type: Output
+            }], onStartCellEdit: [{
+                type: Output
+            }], onStartRowEdit: [{
+                type: Output
+            }], onSubGridCollapse: [{
+                type: Output
+            }], onSubGridExpand: [{
+                type: Output
+            }], onToggleGroup: [{
+                type: Output
+            }], onToggleNode: [{
+                type: Output
+            }], onToolClick: [{
+                type: Output
+            }], onUnlockRows: [{
+                type: Output
+            }], onUnsplit: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bryntum-grid.component.js","sourceRoot":"","sources":["../../../component/src/lib/bryntum-grid.component.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/no-unused-vars */\n/**\n * Angular wrapper for Bryntum Grid\n */\n\nimport { Component, ElementRef, EventEmitter, Output, Input, SimpleChange, SimpleChanges, OnDestroy, OnInit } from '@angular/core';\n\nimport WrapperHelper from './wrapper.helper';\n\nimport { AIFilter, AIFilterConfig, AjaxStore, AjaxStoreConfig, Base, CellCopyPaste, CellCopyPasteConfig, CellEdit, CellEditConfig, CellEditorContext, CellMenu, CellMenuConfig, CellTooltip, CellTooltipConfig, Charts, ChartsConfig, Column, ColumnAutoWidth, ColumnAutoWidthConfig, ColumnDragToolbar, ColumnDragToolbarConfig, ColumnPicker, ColumnPickerConfig, ColumnRename, ColumnRenameConfig, ColumnReorder, ColumnReorderConfig, ColumnResize, ColumnResizeConfig, ColumnStore, ColumnStoreConfig, Container, ContainerItemConfig, DomConfig, EmptyTextDomConfig, ExcelExporter, ExcelExporterConfig, ExportConfig, FileDrop, FileDropConfig, FillHandle, FillHandleConfig, Filter, FilterBar, FilterBarConfig, FilterConfig, FormulaProviderConfig, Grid, GridBase, GridColumnConfig, GridListeners, GridLocation, GridLocationConfig, GridSelectionMode, GridStateInfo, Group, GroupConfig, GroupSummary, GroupSummaryConfig, HeaderMenu, HeaderMenuConfig, KeyMapConfig, LockRows, LockRowsConfig, Mask, MaskConfig, Menu, MenuItem, MenuItemEntry, MergeCells, MergeCellsConfig, Model, ModelConfig, PagingToolbarConfig, Panel, PanelCollapserConfig, PanelCollapserOverlayConfig, PanelHeader, PdfExport, PdfExportConfig, PinColumns, PinColumnsConfig, PreserveScrollOptions, Print, PrintConfig, QuickFind, QuickFindConfig, RecordPositionContext, RegionResize, RegionResizeConfig, ResponsiveLevelConfig, Row, RowCopyPaste, RowCopyPasteConfig, RowEdit, RowEditConfig, RowEditorContext, RowExpander, RowExpanderConfig, RowReorder, RowReorderConfig, RowResize, RowResizeConfig, ScrollManager, ScrollManagerConfig, Scroller, ScrollerConfig, Search, SearchConfig, Sort, SortConfig, Split, SplitConfig, StateProvider, StickyCells, StickyCellsConfig, Store, StoreConfig, Stripe, StripeConfig, SubGrid, SubGridConfig, Summary, SummaryConfig, TabConfig, Tool, ToolConfig, ToolbarConfig, ToolbarItems, TooltipConfig, Tree, TreeConfig, TreeGroup, TreeGroupConfig, Widget, XLSColumn } from '@bryntum/grid';\n\nimport { StringHelper } from '@bryntum/grid';\n\nexport type BryntumGridProps = {\n    // Configs\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/grid/docs/api/Grid/view/Grid#config-adopt)\n     */\n    adopt ? : HTMLElement|string\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/grid/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     * Set to `true` to animate row removals caused by filtering.\n     * @deprecated 7.0.0 Deprecated `animateFilterRemovals`. Use `transition.filterRemoval` instead\n     */\n    animateFilterRemovals ? : boolean\n    /**\n     * Controls if removing and inserting rows should be animated. Set to `false` to prevent those animations,\n     * removing the related delays.\n     * @deprecated 7.0.0 Deprecated `animateRemovingRows`. Use `transition.removeRecord` instead\n     */\n    animateRemovingRows ? : boolean\n    /**\n     * When the [Tree](https://bryntum.com/products/grid/docs/api/Grid/feature/Tree) feature is in use and the Store is a tree store, this\n     * config may be set to `true` to visually animate branch node expand and collapse operations.\n     * *This is not supported in Scheduler and Gantt*\n     * @deprecated 7.0.0 Deprecated `animateTreeNodeToggle`. Use `transition.toggleTreeNode` instead\n     */\n    animateTreeNodeToggle ? : 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/grid/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/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Grid/view/Grid#config-ariaLabel)\n     */\n    ariaLabel ? : string\n    /**\n     * Automatically set grids height to fit all rows (no scrolling in the grid). In general you should avoid\n     * using `autoHeight: true`, since it will bypass Grids virtual rendering and render all rows at once, which\n     * in a larger grid is really bad for performance.\n     */\n    autoHeight ? : boolean\n    /**\n     * A Config object representing the configuration of a [Toolbar](https://bryntum.com/products/grid/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/grid/docs/api/Core/widget/Panel#config-strips).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-bbar)\n     */\n    bbar ? : (ContainerItemConfig|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/grid/docs/api/Grid/view/Grid#config-bodyCls)\n     */\n    bodyCls ? : string|object\n    /**\n     * An object where property names with a truthy value indicate which events should bubble up the ownership\n     * hierarchy when triggered.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Grid/view/Grid#config-callOnFunctions)\n     */\n    callOnFunctions ? : boolean\n    /**\n     * By default, if an event handler throws an exception, the error propagates up the stack and the\n     * application state is undefined. Code which follows the event handler will *not* be executed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-catchEventHandlerExceptions)\n     */\n    catchEventHandlerExceptions ? : boolean\n    /**\n     * Set to `false` to crop text in grid cells without ellipsis (...). When enabled, cells containing pure\n     * use `display : block`, instead of `display : flex` to allow ellipsis to work.\n     * <strong>NOTE</strong> Only supported in browsers that support `:has()` CSS selector\n     */\n    cellEllipsis ? : 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/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Core/widget/Panel#config-collapsible).\n     */\n    collapsed ? : boolean\n    /**\n     * This config enables collapsibility for the panel. See [collapsed](https://bryntum.com/products/grid/docs/api/Core/widget/Panel#config-collapsed).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Grid/view/Grid#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     * Set to `false` to not show column lines. End result might be overruled by/differ between themes.\n     */\n    columnLines ? : boolean\n    /**\n     * Accepts column definitions for the grid during initialization. They will be used to create\n     * [Column](https://bryntum.com/products/grid/docs/api/Grid/column/Column) instances that are added to a [ColumnStore](#Grid/data/ColumnStore).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-columns)\n     */\n    columns ? : ColumnStore|GridColumnConfig[]|ColumnStoreConfig\n    config ? : object\n    /**\n     * Custom CSS classes to add to the [contentElement](https://bryntum.com/products/grid/docs/api/Core/widget/Widget#property-contentElement).\n     * May be specified as a space separated string, or as an object in which property names\n     * with truthy values are used as the class names:\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-contentElementCls)\n     */\n    contentElementCls ? : string|object\n    /**\n     * Event which is used to show context menus.\n     * Available options are: 'contextmenu', 'click', 'dblclick'.\n     */\n    contextMenuTriggerEvent ? : 'contextmenu'|'click'|'dblclick'\n    /**\n     * Convenient shortcut to set data in grids store both during initialization and at runtime. Can also be\n     * used to retrieve data at runtime, although we do recommend interacting with Grids store instead using\n     * the [store](https://bryntum.com/products/grid/docs/api/Grid/view/GridBase#property-store) property.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-data)\n     */\n    data ? : object[]|Model[]|ModelConfig[]\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     * Region to which columns are added when they have none specified\n     */\n    defaultRegion ? : string\n    /**\n     * Set to `true` to destroy the store when the grid is destroyed.\n     */\n    destroyStore ? : boolean\n    /**\n     * Check for CSS compatibility issues when upgrading to v7. Performs the following checks:\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-detectCSSCompatibilityIssues)\n     */\n    detectCSSCompatibilityIssues ? : boolean\n    /**\n     * Disable or enable the widget. It is similar to [readOnly](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#config-disabled)\n     */\n    disabled ? : boolean|'inert'\n    /**\n     * Set to `true` to not get a warning when calling [getState](https://bryntum.com/products/grid/docs/api/Grid/view/GridBase#function-getState) when there is a column\n     * configured without an `id`. But the recommended action is to always configure columns with an `id` when\n     * using states.\n     */\n    disableGridColumnIdWarning ? : boolean\n    /**\n     * Set to `true` to not get a warning when using another base class than GridRowModel for your grid data. If\n     * you do, and would like to use the full feature set of the grid then include the fields from GridRowModel\n     * in your model definition.\n     */\n    disableGridRowModelWarning ? : boolean\n    /**\n     * Controls the placement of this widget when it is added to a [panel's ](https://bryntum.com/products/grid/docs/api/Core/widget/Panel)\n     * [strips collection](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#config-dock)\n     */\n    dock ? : 'top'|'bottom'|'left'|'right'|'start'|'end'|'header'|'pre-header'|object\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/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Core/widget/Panel#config-appendTo) config to place the drawer inside a host widget, this may be set to `true` to make the drawer inline within that host. Note that, if using this, the layout of the host element must have `flex-direction` set appropriately.\n     * @param {boolean,object} autoClose Specifies what user actions should automatically close the drawer. Defaults to closing when the user clicks outside of the drawer or when focus moves outside of the drawer.\n     * @param {boolean,string} autoClose.mousedown If the user clicks outside of the drawer, the drawer will automatically be hidden. If the value is a string, it is used as a CSS selector to filter clicks which should close the drawer.\n     * @param {boolean,string} autoClose.focusout If focus moves outside of the drawer, the drawer will automatically be hidden.\n     * @param {string} autoClose.mouseout Hides the drawer when the mouse leaves the drawer after the `autoCloseDelay` period.\n     * @param {number} autoCloseDelay When using `mouseout`, this is the delay in milliseconds\n     */\n    drawer ? : boolean|{side?: 'start'|'left'|'end'|'right'|'top'|'bottom', size?: string|number, inline?: boolean, autoClose: { mousedown?: boolean|string, focusout?: boolean|string, mouseout?: string }, autoCloseDelay?: number}\n    /**\n     * An object specifying attributes to assign to the root element of this widget.\n     * Set `null` value to attribute to remove it.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-elementAttributes)\n     */\n    elementAttributes ? : Record<string, string|null>\n    /**\n     * Text or HTML, or a [EmptyTextDomConfig](https://bryntum.com/products/grid/docs/api/Grid/view/GridBase#typedef-EmptyTextDomConfig) block to display when there is no data to display in the grid.\n     * When using multiple Grid regions, provide the `region` property to decide where the text is shown.\n     * By default, it is shown in the first region.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-emptyText)\n     */\n    emptyText ? : string|EmptyTextDomConfig\n    /**\n     * Configure this as `true` to allow elements within cells to be styled as `position: sticky`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-enableSticky)\n     */\n    enableSticky ? : boolean\n    /**\n     * Set to `true` to allow text selection in the grid cells. Note, this cannot be used simultaneously with the\n     * `RowReorder` feature.\n     */\n    enableTextSelection ? : boolean\n    /**\n     * Set to `true` to listen for CTRL-Z (CMD-Z on Mac OS) keyboard event and trigger undo (redo when SHIFT is\n     * pressed). Only applicable when using a [StateTrackingManager](https://bryntum.com/products/grid/docs/api/Core/data/stm/StateTrackingManager).\n     */\n    enableUndoRedoKeys ? : boolean\n    extraData ? : any\n    /**\n     * Set to `true` to stretch the last column in a grid with all fixed width columns\n     * to fill extra available space if the grid's width is wider than the sum of all\n     * configured column widths.\n     */\n    fillLastColumn ? : boolean\n    /**\n     * Use fixed row height. Setting this to `true` will configure the underlying RowManager to use fixed row\n     * height, which sacrifices the ability to use rows with variable height to gain a fraction better\n     * performance.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-fixedRowHeight)\n     */\n    fixedRowHeight ? : boolean\n    /**\n     * When this widget is a child of a [Container](https://bryntum.com/products/grid/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     * 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/grid/docs/api/Core/widget/Panel#config-strips).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-footer)\n     */\n    footer ? : {\n        dock?: 'top'|'right'|'bottom'|'left'|'start'|'end'\n        html?: string\n        cls?: string\n    }|string\n    /**\n     * An object which names formula prefixes which will be applied to all columns configured with\n     * `formula : true`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-formulaProviders)\n     */\n    formulaProviders ? : Record<string, FormulaProviderConfig>\n    /**\n     * Refresh entire row when a record changes (`true`) or, if possible, only the cells affected (`false`).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-fullRowRefresh)\n     */\n    fullRowRefresh ? : boolean\n    /**\n     * A function called for each row to determine its height. It is passed a [record](https://bryntum.com/products/grid/docs/api/Core/data/Model) and\n     * expected to return the desired height of that records row. If the function returns a falsy value, Grids\n     * configured [rowHeight](https://bryntum.com/products/grid/docs/api/Grid/view/GridBase#config-rowHeight) is used.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-getRowHeight)\n     * @param {Core.data.Model} getRowHeight.record Record to determine row height for\n     * @returns {number} Desired row height\n     */\n    getRowHeight ? : (getRowHeight: { record: Model }) => number\n    /**\n     * A config [object](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#config-header)\n     */\n    header ? : string|boolean|PanelHeader\n    /**\n     * Widget's height, used to set element `style.height`. Either specify a valid height string or a number,\n     * which will get 'px' appended. We recommend using CSS as the primary way to control height, but in some\n     * cases this config is convenient.\n     */\n    height ? : string|number\n    /**\n     * Configure with true to make widget initially hidden.\n     */\n    hidden ? : boolean\n    /**\n     * Set to `true` to hide the footer elements\n     */\n    hideFooters ? : boolean\n    /**\n     * Set to `true` to hide the column header elements\n     */\n    hideHeaders ? : boolean\n    /**\n     * Set to `true` to hide the Grid's horizontal scrollbar(s)\n     */\n    hideHorizontalScrollbar ? : boolean\n    /**\n     * A CSS class to add to hovered row elements\n     */\n    hoverCls ? : string\n    /**\n     * An icon to show before the [title](https://bryntum.com/products/grid/docs/api/Core/widget/Panel#config-title). Either pass a CSS class as a string, or pass a\n     * [DomConfig](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Grid/view/Grid#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/grid/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/grid/docs/api/Core/widget/Widget#config-appendTo) config is ignored.\n     */\n    insertFirst ? : HTMLElement|string\n    /**\n     * See [Keyboard shortcuts](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Grid/view/Grid#config-listeners)\n     */\n    listeners ? : GridListeners\n    /**\n     * A [Mask](https://bryntum.com/products/grid/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/grid/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/grid/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/grid/docs/api/Grid/view/Grid#config-loadMaskDefaults)\n     */\n    loadMaskDefaults ? : MaskConfig\n    /**\n     * A [Mask](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#config-loadMaskError)\n     */\n    loadMaskError ? : MaskConfig|Mask|boolean\n    /**\n     * Set to `false` to disable localization of this object.\n     */\n    localizable ? : boolean\n    /**\n     * Time in ms until a longpress is triggered\n     */\n    longPressTime ? : number\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     * Grids change the `maskDefaults` to cover only their `body` element.\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/grid/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/grid/docs/api/Core/widget/Widget#config-height), *reading* the value will return the numeric value in pixels.\n     */\n    maxHeight ? : string|number\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/grid/docs/api/Core/widget/Widget#config-width), *reading* the value will return the numeric value in pixels.\n     */\n    maxWidth ? : string|number\n    /**\n     * Grid's `min-height`. Defaults to `10em` to be sure that the Grid always has a height wherever it is\n     * inserted.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-minHeight)\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/grid/docs/api/Core/widget/Widget#config-width), *reading* the value will return the numeric value in pixels.\n     */\n    minWidth ? : string|number\n    /**\n     * Grid monitors window resize by default.\n     */\n    monitorResize ? : boolean\n    /**\n     * The owning Widget of this Widget. If this Widget is directly contained (that is, it is one of the\n     * [items](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#config-owner)\n     */\n    owner ? : Widget|any\n    /**\n     * Specify plugins (an array of classes) in config\n     */\n    plugins ? : Function[]\n    /**\n     * True to preserve focused cell after loading new data\n     */\n    preserveFocusOnDatasetChange ? : boolean\n    /**\n     * Preserve the grid's vertical scroll position when changesets are applied, as in the case of remote\n     * changes, or when stores are configured with [syncDataOnLoad](https://bryntum.com/products/grid/docs/api/Core/data/Store#config-syncDataOnLoad).\n     */\n    preserveScroll ? : PreserveScrollOptions|boolean\n    /**\n     * Specify `true` to preserve vertical scroll position after store actions that trigger a `refresh` event,\n     * such as loading new data and filtering.\n     */\n    preserveScrollOnDatasetChange ? : boolean\n    /**\n     * Prevent tooltip from being displayed on touch devices. Useful for example for buttons that display a\n     * menu on click etc, since the tooltip would be displayed at the same time.\n     */\n    preventTooltipOnTouch ? : boolean\n    /**\n     * Set to `true` to make the grid read-only, by disabling any UIs for modifying data.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-readOnly)\n     */\n    readOnly ? : boolean\n    relayStoreEvents ? : boolean\n    /**\n     * Either a default `rendition` to apply to all child widgets, or a map of renditions keyed by child widget\n     * `type`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-rendition)\n     */\n    rendition ? : string|Record<string, string>|null\n    /**\n     * Configure this property to allow the widget/component to be resized. Pressing <kbd>Shift</kbd> while resizing will\n     * constrain the aspect ratio.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-resizable)\n     */\n    resizable ? : boolean|{\n        minWidth?: number\n        maxWidth?: number\n        minHeight?: number\n        maxHeight?: number\n        handles?: object\n    }\n    /**\n     * Set to `false` to only measure cell contents when double-clicking the edge between column headers.\n     */\n    resizeToFitIncludesHeader ? : boolean\n    /**\n     * \"Break points\" for which responsive config to use for columns and css.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-responsiveLevels)\n     */\n    responsiveLevels ? : Record<string, number|string|ResponsiveLevelConfig>\n    /**\n     * Configure as `true` to have the component display a translucent ripple when its\n     * [focusElement](https://bryntum.com/products/grid/docs/api/Core/widget/Widget#property-focusElement), or [element](#Core/widget/Widget#property-element) is tapped <em>if the\n     * current theme supports ripples</em>. Out of the box, only the Material theme supports ripples.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-ripple)\n     */\n    ripple ? : boolean|{\n        delegate?: string\n        color?: string\n        radius?: number\n        clip?: string\n    }\n    /**\n     * If you are rendering this widget to a shadow root inside a web component, set this config to the shadowRoot. If not inside a web component, set it to `document.body`\n     */\n    rootElement ? : ShadowRoot|HTMLElement\n    /**\n     * Row height in pixels. This allows the default height for rows to be controlled. Note that it may be\n     * overriden by specifying a [rowHeight](https://bryntum.com/products/grid/docs/api/Grid/data/GridRowModel#field-rowHeight) on a per record basis, or from\n     * a column [renderer](https://bryntum.com/products/grid/docs/api/Grid/column/Column#config-renderer).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-rowHeight)\n     */\n    rowHeight ? : number\n    /**\n     * Set to `false` to not show row lines. End result might be overruled by/differ between themes.\n     */\n    rowLines ? : boolean\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/grid/docs/api/Grid/view/Grid#config-rtl)\n     */\n    rtl ? : boolean\n    /**\n     * Configures whether the grid is scrollable in the `Y` axis. This is used to configure a [Scroller](https://bryntum.com/products/grid/docs/api/Core/helper/util/Scroller).\n     * See the [scrollerClass](https://bryntum.com/products/grid/docs/api/Grid/view/GridBase#config-scrollerClass) config option.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-scrollable)\n     */\n    scrollable ? : boolean|ScrollerConfig|Scroller\n    /**\n     * The class to instantiate to use as the [scrollable](https://bryntum.com/products/grid/docs/api/Grid/view/GridBase#config-scrollable). Defaults to [Scroller](#Core/helper/util/Scroller).\n     */\n    scrollerClass ? : typeof Scroller\n    /**\n     * Configuration values for the [ScrollManager](https://bryntum.com/products/grid/docs/api/Core/util/ScrollManager) class on initialization. Returns the\n     * [ScrollManager](https://bryntum.com/products/grid/docs/api/Core/util/ScrollManager) at runtime.\n     */\n    scrollManager ? : ScrollManagerConfig|ScrollManager\n    /**\n     * Selection configuration settings, change these properties to control how selection works and what can be\n     * selected.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-selectionMode)\n     */\n    selectionMode ? : GridSelectionMode\n    /**\n     * Configure as `true` to have the grid show a red \"changed\" tag in cells whose\n     * field value has changed and not yet been committed.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-showDirty)\n     */\n    showDirty ? : boolean|{\n        duringEdit?: boolean\n        newRecord?: boolean\n    }\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/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Core/mixin/State#function-saveState).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Core/mixin/State#config-stateProvider). If this config is\n     * not assigned, and [stateful](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#config-stateId)\n     */\n    stateId ? : string\n    /**\n     * The `StateProvider` to use to save and restore this object's [state](https://bryntum.com/products/grid/docs/api/Core/mixin/State#property-state). By default, `state`\n     * will be saved using the [default state provider](https://bryntum.com/products/grid/docs/api/Core/state/StateProvider#property-instance-static).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-stateProvider)\n     */\n    stateProvider ? : StateProvider\n    /**\n     * The properties of this settings object controls how grid is restored from state data.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-stateSettings)\n     */\n    stateSettings ? : {\n        restoreUnconfiguredColumns?: boolean\n    }\n    /**\n     * Store that holds records to display in the grid, or a store config object. If the configuration contains\n     * a `readUrl`, an `AjaxStore` will be created.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-store)\n     */\n    store ? : Store|StoreConfig|AjaxStore|AjaxStoreConfig\n    /**\n     * An object containing widgets keyed by name. By default (when no `type` is given), strips are\n     * [toolbars](https://bryntum.com/products/grid/docs/api/Core/widget/Toolbar). If you want to pass an array, you can use\n     * the toolbar's [items](https://bryntum.com/products/grid/docs/api/Core/widget/Container#config-items).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-strips)\n     */\n    strips ? : Record<string, ContainerItemConfig>\n    /**\n     * An object containing sub grid configuration objects keyed by a `region` property.\n     * By default, grid has a 'locked' region (if configured with locked columns) and a 'normal' region.\n     * The 'normal' region defaults to use `flex: 1`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-subGridConfigs)\n     */\n    subGridConfigs ? : Record<string, SubGridConfig>\n    /**\n     * A [Mask](https://bryntum.com/products/grid/docs/api/Core/widget/Mask) config object, or a message to be shown when Crud Manager\n     * is persisting changes on the server. Set to `null` to disable default sync mask.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-syncMask)\n     */\n    syncMask ? : string|MaskConfig|null\n    /**\n     * A configuration for the [tab](https://bryntum.com/products/grid/docs/api/Core/widget/Tab) created for this widget when it is placed in a\n     * [TabPanel](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#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/grid/docs/api/Core/widget/TabBar) when this container is the active tab.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-tabBarItems)\n     */\n    tabBarItems ? : ToolbarItems[]|Widget[]\n    /**\n     * A Config object representing the configuration of a [Toolbar](https://bryntum.com/products/grid/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/grid/docs/api/Grid/view/Grid#config-tbar)\n     */\n    tbar ? : (ContainerItemConfig|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/grid/docs/api/Grid/view/Grid#config-title)\n     */\n    title ? : string\n    /**\n     * The [tools](https://bryntum.com/products/grid/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/grid/docs/api/Core/widget/mixin/Toolable#property-tools)` property.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#config-tools)\n     */\n    tools ? : Record<string, ToolConfig>|null\n    /**\n     * Configure UI transitions for various actions in the grid.\n     */\n    transition ? : {\n        insertRecord?: boolean\n        removeRecord?: boolean\n        toggleColumn?: boolean\n        expandCollapseColumn?: boolean\n        toggleRegion?: boolean\n        toggleTreeNode?: boolean\n        toggleGroup?: boolean\n        filterRemoval?: boolean\n    }\n    /**\n     * Animation transition duration in milliseconds.\n     */\n    transitionDuration ? : number\n    type ? : 'grid'\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/grid/docs/api/Grid/view/Grid#config-ui)\n     */\n    ui ? : 'plain'|'toolbar'|string|object\n    /**\n     * A widgets weight determines its position among siblings when added to a [Container](https://bryntum.com/products/grid/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    // Features\n    /**\n     * AI-powered filter feature for Grid. Allows users to type natural language queries to filter grid data.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/ai/AIFilter)\n     */\n    aiFilterFeature ? : object|boolean|string|AIFilter|AIFilterConfig\n    /**\n     * Allows using `[Ctrl/CMD + C]`, `[Ctrl/CMD + X]` and `[Ctrl/CMD + V]` to cut, copy and paste cell or cell ranges. Also\n     * makes cut, copy and paste actions available via the cell context menu.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/CellCopyPaste)\n     */\n    cellCopyPasteFeature ? : object|boolean|string|CellCopyPaste|CellCopyPasteConfig\n    /**\n     * Adding this feature to the grid and other Bryntum products which are based on the Grid (i.e. Scheduler, SchedulerPro, and Gantt)\n     * enables cell editing. Any subclass of [Field](https://bryntum.com/products/grid/docs/api/Core/widget/Field) can be used\n     * as editor for the [Column](https://bryntum.com/products/grid/docs/api/Grid/column/Column). The most popular are:\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/CellEdit)\n     */\n    cellEditFeature ? : object|boolean|string|CellEdit|CellEditConfig\n    /**\n     * Right click to display context menu for cells. To invoke the cell menu in a keyboard-accessible manner, use the\n     * `SPACE` key when the cell is focused.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/CellMenu)\n     */\n    cellMenuFeature ? : object|boolean|string|CellMenu|CellMenuConfig\n    /**\n     * Displays a tooltip when hovering cells.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/CellTooltip)\n     */\n    cellTooltipFeature ? : object|boolean|string|CellTooltip|CellTooltipConfig\n    /**\n     * Adds interactive charting to a Grid. [Charts](https://bryntum.com/products/grid/docs/api/Chart/widget/Chart) can be created from a selection of Grid data\n     * and updated in realtime as data changes. Supports many common chart types with extensive styling and customization\n     * options.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Charts)\n     */\n    chartsFeature ? : object|boolean|string|Charts|ChartsConfig\n    /**\n     * Enables the [autoWidth](https://bryntum.com/products/grid/docs/api/Grid/column/Column#config-autoWidth) config for a grid's columns.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/ColumnAutoWidth)\n     */\n    columnAutoWidthFeature ? : object|boolean|string|ColumnAutoWidth|ColumnAutoWidthConfig\n    /**\n     * Displays a toolbar while dragging column headers. Drop on a button in the toolbar to activate a certain function,\n     * for example to group by that column. This feature simplifies certain operations on touch devices.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/ColumnDragToolbar)\n     */\n    columnDragToolbarFeature ? : object|boolean|string|ColumnDragToolbar|ColumnDragToolbarConfig\n    /**\n     * Displays a column picker (to show/hide columns) in the header context menu. Columns can be displayed in sub menus\n     * by region or tag. Grouped headers are displayed as menu hierarchies.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/ColumnPicker)\n     */\n    columnPickerFeature ? : object|boolean|string|ColumnPicker|ColumnPickerConfig\n    /**\n     * Allows user to rename columns by either right-clicking column header or using keyboard shortcuts when column header\n     * is focused.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/ColumnRename)\n     */\n    columnRenameFeature ? : object|boolean|string|ColumnRename|ColumnRenameConfig\n    /**\n     * Allows user to reorder columns by dragging headers. To get notified about column reorder listen to `change` event\n     * on [columns](https://bryntum.com/products/grid/docs/api/Grid/data/ColumnStore) store.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/ColumnReorder)\n     */\n    columnReorderFeature ? : object|boolean|string|ColumnReorder|ColumnReorderConfig\n    /**\n     * Enables user to resize columns by dragging a handle on the right hand side of the header. To get notified about column\n     * resize listen to `change` event on [columns](https://bryntum.com/products/grid/docs/api/Grid/data/ColumnStore) store.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/ColumnResize)\n     */\n    columnResizeFeature ? : object|boolean|string|ColumnResize|ColumnResizeConfig\n    /**\n     * A feature that allows exporting Grid data to Excel or CSV without involving the server. It uses\n     * [TableExporter](https://bryntum.com/products/grid/docs/api/Grid/util/TableExporter) class as data provider, 3rd party provider to generate XLS files, and\n     * [Microsoft XML specification](https://msdn.microsoft.com/en-us/library/office/documentformat.openxml.spreadsheet.aspx).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/experimental/ExcelExporter)\n     */\n    excelExporterFeature ? : object|boolean|string|ExcelExporter|ExcelExporterConfig\n    /**\n     * An experimental feature that lets users drop files on a Widget. The widget fires an event when a file is dropped onto it.\n     * In the event, you get access to the raw files as strings, that were parsed by calling `readAsBinaryString`.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/experimental/FileDrop)\n     */\n    fileDropFeature ? : object|boolean|string|FileDrop|FileDropConfig\n    /**\n     * This feature adds a fill handle to a Grid range selection, which when dragged, fills the cells being dragged over\n     * with values based on the values in the original selected range. This is similar to functionality normally seen in\n     * various spreadsheet applications.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/FillHandle)\n     */\n    fillHandleFeature ? : object|boolean|string|FillHandle|FillHandleConfig\n    /**\n     * Feature that allows filtering of the grid by settings filters on columns. The actual filtering is done by the store.\n     * For info on programmatically handling filters, see [StoreFilter](https://bryntum.com/products/grid/docs/api/Core/data/mixin/StoreFilter).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Filter)\n     */\n    filterFeature ? : object|boolean|string|Filter|FilterConfig\n    /**\n     * Feature that allows filtering of the grid by entering filters on column headers.\n     * The actual filtering is done by the store.\n     * For info on programmatically handling filters, see [StoreFilter](https://bryntum.com/products/grid/docs/api/Core/data/mixin/StoreFilter).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/FilterBar)\n     */\n    filterBarFeature ? : object|boolean|string|FilterBar|FilterBarConfig\n    /**\n     * Enables rendering and handling of row groups. The actual grouping is done in the store, but triggered by\n     * <kbd>shift</kbd> + clicking headers, or by using the context menu, or by using two finger tap (one on header,\n     * one anywhere on grid). Use <kbd>shift</kbd> + <kbd>alt</kbd> + click, or the context menu, to remove a column\n     * grouper.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Group)\n     */\n    groupFeature ? : object|boolean|string|Group|GroupConfig\n    /**\n     * Displays a summary row as a group footer in a grouped grid. Uses the same configuration options on columns as\n     * [Summary](https://bryntum.com/products/grid/docs/api/Grid/feature/Summary).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/GroupSummary)\n     */\n    groupSummaryFeature ? : object|boolean|string|GroupSummary|GroupSummaryConfig\n    /**\n     * Right click column header or focus it and press SPACE key to show the context menu for headers.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/HeaderMenu)\n     */\n    headerMenuFeature ? : object|boolean|string|HeaderMenu|HeaderMenuConfig\n    /**\n     * This feature allows records which satisfy a certain condition to be locked at the top of the grid.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/LockRows)\n     */\n    lockRowsFeature ? : object|boolean|string|LockRows|LockRowsConfig\n    /**\n     * This feature merges cells that have the same value in sorted (or [optionally](https://bryntum.com/products/grid/docs/api/Grid/feature/MergeCells#config-sortedOnly) any) columns\n     * configured to [mergeCells](https://bryntum.com/products/grid/docs/api/Grid/column/Column#config-mergeCells).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/MergeCells)\n     */\n    mergeCellsFeature ? : object|boolean|string|MergeCells|MergeCellsConfig\n    /**\n     * Generates PDF/PNG files from the Grid component.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/export/PdfExport)\n     */\n    pdfExportFeature ? : object|boolean|string|PdfExport|PdfExportConfig\n    /**\n     * Allows pinning columns to the start or end region of the grid without any additional subGrid configurations.\n     * When pinning to a region that does not yet exist, the feature creates the required subGrid on the fly.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/PinColumns)\n     */\n    pinColumnsFeature ? : object|boolean|string|PinColumns|PinColumnsConfig\n    /**\n     * Allows printing Grid contents using browser print dialog.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/export/Print)\n     */\n    printFeature ? : object|boolean|string|Print|PrintConfig\n    /**\n     * Feature that allows the user to search in a column by focusing a cell and typing. Navigate between hits using the\n     * keyboard, [f3] or [ctrl]/[cmd] + [g] moves to next, also pressing [shift] moves to previous.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/QuickFind)\n     */\n    quickFindFeature ? : object|boolean|string|QuickFind|QuickFindConfig\n    /**\n     * Makes the splitter between grid [sections](https://bryntum.com/products/grid/docs/api/Grid/view/SubGrid) draggable, to let users resize, and\n     * collapse/expand the sections.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/RegionResize)\n     */\n    regionResizeFeature ? : object|boolean|string|RegionResize|RegionResizeConfig\n    /**\n     * Allow using [Ctrl/CMD + C/X] and [Ctrl/CMD + V] to copy/cut-and-paste rows. Also makes cut, copy and paste actions\n     * available via the cell context menu.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/RowCopyPaste)\n     */\n    rowCopyPasteFeature ? : object|boolean|string|RowCopyPaste|RowCopyPasteConfig\n    /**\n     * This feature allows editing of entire rows in a grid in a docked panel which by default slides out from the right.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/RowEdit)\n     */\n    rowEditFeature ? : object|boolean|string|RowEdit|RowEditConfig\n    /**\n     * Enables expanding of Grid rows by either row click or double click, or by adding a separate Grid column which renders\n     * a button that expands or collapses the row.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/RowExpander)\n     */\n    rowExpanderFeature ? : object|boolean|string|RowExpander|RowExpanderConfig\n    /**\n     * Allows user to reorder rows by dragging them. To get notified about row reorder listen to `change` event\n     * on the grid [store](https://bryntum.com/products/grid/docs/api/Core/data/Store).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/RowReorder)\n     */\n    rowReorderFeature ? : object|boolean|string|RowReorder|RowReorderConfig\n    /**\n     * Enables user to change row height by dragging the bottom row border. After a resize operation, the [rowHeight](https://bryntum.com/products/grid/docs/api/Grid/data/GridRowModel#field-rowHeight)\n     * field of the record is updated (when [applyToAllRows](https://bryntum.com/products/grid/docs/api/Grid/feature/RowResize#config-applyToAllRows) is `false`).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/RowResize)\n     */\n    rowResizeFeature ? : object|boolean|string|RowResize|RowResizeConfig\n    /**\n     * <div class=\"external-example vertical\" data-file=\"Grid/feature/Search.js\"></div>\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Search)\n     */\n    searchFeature ? : object|boolean|string|Search|SearchConfig\n    /**\n     * Allows sorting of grid by clicking (or tapping) headers, also displays which columns grid is sorted by (numbered if\n     * using multisort). Use modifier keys for multisorting: [Ctrl/CMD + click] to add sorter, [Ctrl/CMD + Alt + click] to remove sorter.\n     * The actual sorting is done by the store, see [Store.sort()](https://bryntum.com/products/grid/docs/api/Core/data/mixin/StoreSort#function-sort).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Sort)\n     */\n    sortFeature ? : object|boolean|string|Sort|SortConfig\n    /**\n     * This feature allows splitting the Grid into multiple views, either by using the cell context menu, or\n     * programmatically by calling [split()](https://bryntum.com/products/grid/docs/api/Grid/feature/Split#function-split).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Split)\n     */\n    splitFeature ? : object|boolean|string|Split|SplitConfig\n    /**\n     * A feature which pins configurable content from a grid row to the top of the grid\n     * while the row scrolls off the top but is still visible.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/StickyCells)\n     */\n    stickyCellsFeature ? : object|boolean|string|StickyCells|StickyCellsConfig\n    /**\n     * Stripes rows by adding alternating CSS classes to all row elements (`b-even` and `b-odd`).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Stripe)\n     */\n    stripeFeature ? : object|boolean|string|Stripe|StripeConfig\n    /**\n     * Displays a summary row in the grid footer.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Summary)\n     */\n    summaryFeature ? : object|boolean|string|Summary|SummaryConfig\n    /**\n     * Feature that makes the grid work more like a tree. Included by default in [TreeGrid](https://bryntum.com/products/grid/docs/api/Grid/view/TreeGrid). Requires\n     * exactly one [TreeColumn](https://bryntum.com/products/grid/docs/api/Grid/column/TreeColumn) among grids columns. That column will have its renderer replaced with a\n     * tree renderer that adds padding and icon to give the appearance of a tree. The original renderer is preserved and\n     * also called.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/Tree)\n     */\n    treeFeature ? : object|boolean|string|Tree|TreeConfig\n    /**\n     * A feature that allows transforming a flat dataset (or the leaves of a hierarchical) into a tree by specifying a\n     * record field per parent level. Parents are generated based on each leaf's value for those fields.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/feature/TreeGroup)\n     */\n    treeGroupFeature ? : object|boolean|string|TreeGroup|TreeGroupConfig\n\n}\n\n@Component({\n    selector : 'bryntum-grid',\n    template : ''\n})\nexport class BryntumGridComponent implements OnInit, OnDestroy {\n\n    public static instanceClass = Grid;\n\n    public static instanceName = 'Grid';\n\n    private static bryntumEvents: string[] = [\n        'onBeforeCancelCellEdit',\n        'onBeforeCancelRowEdit',\n        'onBeforeCellEditStart',\n        'onBeforeCellRangeDelete',\n        'onBeforeCellRangeEdit',\n        'onBeforeColumnDragStart',\n        'onBeforeColumnDropFinalize',\n        'onBeforeColumnResize',\n        'onBeforeCopy',\n        'onBeforeCSVExport',\n        'onBeforeDestroy',\n        'onBeforeExcelExport',\n        'onBeforeFillHandleDragStart',\n        'onBeforeFinishCellEdit',\n        'onBeforeFinishRowEdit',\n        'onBeforeHide',\n        'onBeforePaste',\n        'onBeforePdfExport',\n        'onBeforeRenderRow',\n        'onBeforeRenderRows',\n        'onBeforeRowCollapse',\n        'onBeforeRowExpand',\n        'onBeforeSelectionChange',\n        'onBeforeSetRecord',\n        'onBeforeShow',\n        'onBeforeStartRowEdit',\n        'onBeforeStateApply',\n        'onBeforeStateSave',\n        'onBeforeToggleGroup',\n        'onBeforeToggleNode',\n        'onCancelCellEdit',\n        'onCatchAll',\n        'onCellClick',\n        'onCellContextMenu',\n        'onCellDblClick',\n        'onCellMenuBeforeShow',\n        'onCellMenuItem',\n        'onCellMenuShow',\n        'onCellMenuToggleItem',\n        'onCellMouseEnter',\n        'onCellMouseLeave',\n        'onCellMouseOut',\n        'onCellMouseOver',\n        'onCollapse',\n        'onCollapseNode',\n        'onColumnDrag',\n        'onColumnDragStart',\n        'onColumnDrop',\n        'onColumnResize',\n        'onColumnResizeStart',\n        'onContextMenuItem',\n        'onContextMenuToggleItem',\n        'onCopy',\n        'onDataChange',\n        'onDestroy',\n        'onDirtyStateChange',\n        'onDragSelecting',\n        'onElementCreated',\n        'onExpand',\n        'onExpandNode',\n        'onFileDrop',\n        'onFillHandleBeforeDragFinalize',\n        'onFillHandleDrag',\n        'onFillHandleDragAbort',\n        'onFillHandleDragEnd',\n        'onFillHandleDragStart',\n        'onFinishCellEdit',\n        'onFinishRowEdit',\n        'onFocusIn',\n        'onFocusOut',\n        'onGridRowBeforeDragStart',\n        'onGridRowBeforeDropFinalize',\n        'onGridRowDrag',\n        'onGridRowDragAbort',\n        'onGridRowDragStart',\n        'onGridRowDrop',\n        'onHeaderClick',\n        'onHeaderMenuBeforeShow',\n        'onHeaderMenuItem',\n        'onHeaderMenuShow',\n        'onHeaderMenuToggleItem',\n        'onHide',\n        'onLockRows',\n        'onMouseOut',\n        'onMouseOver',\n        'onPaint',\n        'onPaste',\n        'onPdfExport',\n        'onReadOnly',\n        'onRecompose',\n        'onRenderRow',\n        'onRenderRows',\n        'onResize',\n        'onResponsive',\n        'onRowCollapse',\n        'onRowExpand',\n        'onRowMouseEnter',\n        'onRowMouseLeave',\n        'onScroll',\n        'onSelectionChange',\n        'onSelectionModeChange',\n        'onShow',\n        'onSplit',\n        'onSplitterCollapseClick',\n        'onSplitterDragEnd',\n        'onSplitterDragStart',\n        'onSplitterExpandClick',\n        'onStartCellEdit',\n        'onStartRowEdit',\n        'onSubGridCollapse',\n        'onSubGridExpand',\n        'onToggleGroup',\n        'onToggleNode',\n        'onToolClick',\n        'onUnlockRows',\n        'onUnsplit'\n    ];\n\n    private static bryntumFeatureNames: string[] = [\n        'aiFilterFeature',\n        'cellCopyPasteFeature',\n        'cellEditFeature',\n        'cellMenuFeature',\n        'cellTooltipFeature',\n        'chartsFeature',\n        'columnAutoWidthFeature',\n        'columnDragToolbarFeature',\n        'columnPickerFeature',\n        'columnRenameFeature',\n        'columnReorderFeature',\n        'columnResizeFeature',\n        'excelExporterFeature',\n        'fileDropFeature',\n        'fillHandleFeature',\n        'filterFeature',\n        'filterBarFeature',\n        'groupFeature',\n        'groupSummaryFeature',\n        'headerMenuFeature',\n        'lockRowsFeature',\n        'mergeCellsFeature',\n        'pdfExportFeature',\n        'pinColumnsFeature',\n        'printFeature',\n        'quickFindFeature',\n        'regionResizeFeature',\n        'rowCopyPasteFeature',\n        'rowEditFeature',\n        'rowExpanderFeature',\n        'rowReorderFeature',\n        'rowResizeFeature',\n        'searchFeature',\n        'sortFeature',\n        'splitFeature',\n        'stickyCellsFeature',\n        'stripeFeature',\n        'summaryFeature',\n        'treeFeature',\n        'treeGroupFeature'\n    ];\n\n    private static bryntumConfigs: string[] = BryntumGridComponent.bryntumFeatureNames.concat([\n        'adopt',\n        'alignSelf',\n        'animateFilterRemovals',\n        'animateRemovingRows',\n        'animateTreeNodeToggle',\n        'appendTo',\n        'ariaDescription',\n        'ariaLabel',\n        'autoHeight',\n        'bbar',\n        'bodyCls',\n        'bubbleEvents',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'cellEllipsis',\n        'cls',\n        'collapsed',\n        'collapsible',\n        'color',\n        'column',\n        'columnLines',\n        'columns',\n        'config',\n        'contentElementCls',\n        'contextMenuTriggerEvent',\n        'data',\n        'dataField',\n        'dataset',\n        'defaultRegion',\n        'destroyStore',\n        'detectCSSCompatibilityIssues',\n        'disabled',\n        'disableGridColumnIdWarning',\n        'disableGridRowModelWarning',\n        'dock',\n        'drawer',\n        'elementAttributes',\n        'emptyText',\n        'enableSticky',\n        'enableTextSelection',\n        'enableUndoRedoKeys',\n        'extraData',\n        'fillLastColumn',\n        'fixedRowHeight',\n        'flex',\n        'footer',\n        'formulaProviders',\n        'fullRowRefresh',\n        'getRowHeight',\n        'header',\n        'height',\n        'hidden',\n        'hideFooters',\n        'hideHeaders',\n        'hideHorizontalScrollbar',\n        'hoverCls',\n        'icon',\n        'id',\n        'ignoreParentReadOnly',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'keyMap',\n        'labelPosition',\n        'listeners',\n        'loadMask',\n        'loadMaskDefaults',\n        'loadMaskError',\n        'localizable',\n        'longPressTime',\n        'margin',\n        'maskDefaults',\n        'masked',\n        'maxHeight',\n        'maxWidth',\n        'minHeight',\n        'minWidth',\n        'monitorResize',\n        'owner',\n        'plugins',\n        'preserveFocusOnDatasetChange',\n        'preserveScroll',\n        'preserveScrollOnDatasetChange',\n        'preventTooltipOnTouch',\n        'readOnly',\n        'relayStoreEvents',\n        'rendition',\n        'resizable',\n        'resizeToFitIncludesHeader',\n        'responsiveLevels',\n        'ripple',\n        'rootElement',\n        'rowHeight',\n        'rowLines',\n        'rtl',\n        'scrollable',\n        'scrollerClass',\n        'scrollManager',\n        'selectionMode',\n        'showDirty',\n        'span',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'stateSettings',\n        'store',\n        'strips',\n        'subGridConfigs',\n        'syncMask',\n        'tab',\n        'tabBarItems',\n        'tbar',\n        'title',\n        'tools',\n        'transition',\n        'transitionDuration',\n        'type',\n        'ui',\n        'weight',\n        'width'\n    ]);\n\n    private static bryntumConfigsOnly: string[] = [\n        'adopt',\n        'animateFilterRemovals',\n        'animateRemovingRows',\n        'ariaDescription',\n        'ariaLabel',\n        'autoHeight',\n        'bbar',\n        'bodyCls',\n        'bubbleEvents',\n        'collapsible',\n        'color',\n        'config',\n        'contentElementCls',\n        'contextMenuTriggerEvent',\n        'dataField',\n        'defaultRegion',\n        'destroyStore',\n        'detectCSSCompatibilityIssues',\n        'disableGridColumnIdWarning',\n        'disableGridRowModelWarning',\n        'dock',\n        'drawer',\n        'elementAttributes',\n        'enableSticky',\n        'enableTextSelection',\n        'fillLastColumn',\n        'fixedRowHeight',\n        'footer',\n        'formulaProviders',\n        'fullRowRefresh',\n        'getRowHeight',\n        'header',\n        'hideHorizontalScrollbar',\n        'hoverCls',\n        'icon',\n        'ignoreParentReadOnly',\n        'listeners',\n        'loadMask',\n        'loadMaskDefaults',\n        'loadMaskError',\n        'localizable',\n        'maskDefaults',\n        'masked',\n        'monitorResize',\n        'owner',\n        'plugins',\n        'preserveFocusOnDatasetChange',\n        'preserveScrollOnDatasetChange',\n        'preventTooltipOnTouch',\n        'relayStoreEvents',\n        'resizable',\n        'resizeToFitIncludesHeader',\n        'responsiveLevels',\n        'ripple',\n        'rootElement',\n        'scrollerClass',\n        'scrollManager',\n        'showDirty',\n        'stateful',\n        'statefulEvents',\n        'stateId',\n        'stateProvider',\n        'strips',\n        'subGridConfigs',\n        'syncMask',\n        'tab',\n        'tabBarItems',\n        'tbar',\n        'type',\n        'ui',\n        'weight'\n    ];\n\n    private static bryntumProps: string[] = BryntumGridComponent.bryntumFeatureNames.concat([\n        'alignSelf',\n        'animateTreeNodeToggle',\n        'appendTo',\n        'callOnFunctions',\n        'catchEventHandlerExceptions',\n        'cellEllipsis',\n        'cls',\n        'collapsed',\n        'column',\n        'columnLines',\n        'columns',\n        'data',\n        'dataset',\n        'disabled',\n        'emptyText',\n        'enableUndoRedoKeys',\n        'extraData',\n        'flex',\n        'focusVisible',\n        'hasChanges',\n        'height',\n        'hidden',\n        'hideFooters',\n        'hideHeaders',\n        'id',\n        'inputFieldAlign',\n        'insertBefore',\n        'insertFirst',\n        'keyMap',\n        'labelPosition',\n        'longPressTime',\n        'margin',\n        'maxHeight',\n        'maxWidth',\n        'minHeight',\n        'minWidth',\n        'originalStore',\n        'parent',\n        'preserveScroll',\n        'readOnly',\n        'rendition',\n        'rowHeight',\n        'rowLines',\n        'rtl',\n        'scrollable',\n        'selectedCell',\n        'selectedCells',\n        'selectedRecord',\n        'selectedRecords',\n        'selectedRows',\n        'selectionMode',\n        'span',\n        'state',\n        'stateSettings',\n        'store',\n        'title',\n        'tools',\n        'tooltip',\n        'transition',\n        'transitionDuration',\n        'width'\n    ]);\n\n    private elementRef: ElementRef;\n    public instance!: Grid;\n\n    private bryntumConfig = {\n        adopt            : undefined,\n        appendTo         : undefined,\n        href             : undefined,\n        angularComponent : this,\n        features         : {},\n        listeners        : {}\n    };\n\n    constructor(element: ElementRef) {\n        this.elementRef = element;\n    }\n\n    // Configs only\n    @Input() adopt                         ! : HTMLElement|string;\n    @Input() animateFilterRemovals         ! : boolean;\n    @Input() animateRemovingRows           ! : boolean;\n    @Input() ariaDescription               ! : string;\n    @Input() ariaLabel                     ! : string;\n    @Input() autoHeight                    ! : boolean;\n    @Input() bbar                          ! : (ContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null;\n    @Input() bodyCls                       ! : string|object;\n    @Input() bubbleEvents                  ! : object;\n    @Input() collapsible                   ! : boolean|PanelCollapserConfig|PanelCollapserOverlayConfig;\n    @Input() color                         ! : string;\n    @Input() config                        ! : object;\n    @Input() contentElementCls             ! : string|object;\n    @Input() contextMenuTriggerEvent       ! : 'contextmenu'|'click'|'dblclick';\n    @Input() dataField                     ! : string;\n    @Input() defaultRegion                 ! : string;\n    @Input() destroyStore                  ! : boolean;\n    @Input() detectCSSCompatibilityIssues  ! : boolean;\n    @Input() disableGridColumnIdWarning    ! : boolean;\n    @Input() disableGridRowModelWarning    ! : boolean;\n    @Input() dock                          ! : 'top'|'bottom'|'left'|'right'|'start'|'end'|'header'|'pre-header'|object;\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() enableSticky                  ! : boolean;\n    @Input() enableTextSelection           ! : boolean;\n    @Input() fillLastColumn                ! : boolean;\n    @Input() fixedRowHeight                ! : boolean;\n    @Input() footer                        ! : {\n        dock?: 'top'|'right'|'bottom'|'left'|'start'|'end'\n        html?: string\n        cls?: string\n    }|string;\n    @Input() formulaProviders              ! : Record<string, FormulaProviderConfig>;\n    @Input() fullRowRefresh                ! : boolean;\n    @Input() getRowHeight                  ! : (getRowHeight: { record: Model }) => number;\n    @Input() header                        ! : string|boolean|PanelHeader;\n    @Input() hideHorizontalScrollbar       ! : boolean;\n    @Input() hoverCls                      ! : string;\n    @Input() icon                          ! : string|DomConfig;\n    @Input() ignoreParentReadOnly          ! : boolean;\n    @Input() listeners                     ! : GridListeners;\n    @Input() loadMask                      ! : string|MaskConfig|null;\n    @Input() loadMaskDefaults              ! : MaskConfig;\n    @Input() loadMaskError                 ! : MaskConfig|Mask|boolean;\n    @Input() localizable                   ! : boolean;\n    @Input() maskDefaults                  ! : MaskConfig;\n    @Input() masked                        ! : boolean|string|MaskConfig;\n    @Input() monitorResize                 ! : boolean;\n    @Input() owner                         ! : Widget|any;\n    @Input() plugins                       ! : Function[];\n    @Input() preserveFocusOnDatasetChange  ! : boolean;\n    @Input() preserveScrollOnDatasetChange ! : boolean;\n    @Input() preventTooltipOnTouch         ! : boolean;\n    @Input() relayStoreEvents              ! : boolean;\n    @Input() resizable                     ! : boolean|{\n        minWidth?: number\n        maxWidth?: number\n        minHeight?: number\n        maxHeight?: number\n        handles?: object\n    };\n    @Input() resizeToFitIncludesHeader     ! : boolean;\n    @Input() responsiveLevels              ! : Record<string, number|string|ResponsiveLevelConfig>;\n    @Input() ripple                        ! : boolean|{\n        delegate?: string\n        color?: string\n        radius?: number\n        clip?: string\n    };\n    @Input() rootElement                   ! : ShadowRoot|HTMLElement;\n    @Input() scrollerClass                 ! : typeof Scroller;\n    @Input() scrollManager                 ! : ScrollManagerConfig|ScrollManager;\n    @Input() showDirty                     ! : boolean|{\n        duringEdit?: boolean\n        newRecord?: boolean\n    };\n    @Input() stateful                      ! : boolean|object|string[];\n    @Input() statefulEvents                ! : object|string[];\n    @Input() stateId                       ! : string;\n    @Input() stateProvider                 ! : StateProvider;\n    @Input() strips                        ! : Record<string, ContainerItemConfig>;\n    @Input() subGridConfigs                ! : Record<string, SubGridConfig>;\n    @Input() syncMask                      ! : string|MaskConfig|null;\n    @Input() tab                           ! : boolean|TabConfig;\n    @Input() tabBarItems                   ! : ToolbarItems[]|Widget[];\n    @Input() tbar                          ! : (ContainerItemConfig|string)[]|ToolbarConfig|PagingToolbarConfig|null;\n    @Input() type                          ! : 'grid';\n    @Input() ui                            ! : 'plain'|'toolbar'|string|object;\n    @Input() weight                        ! : number;\n\n    // Configs and properties\n    @Input() alignSelf                   ! : string;\n    @Input() animateTreeNodeToggle       ! : boolean;\n    @Input() appendTo                    ! : HTMLElement|string;\n    @Input() callOnFunctions             ! : boolean;\n    @Input() catchEventHandlerExceptions ! : boolean;\n    @Input() cellEllipsis                ! : boolean;\n    @Input() cls                         ! : string|object;\n    @Input() collapsed                   ! : boolean;\n    @Input() column                      ! : number;\n    @Input() columnLines                 ! : boolean;\n    @Input() columns                     ! : ColumnStore|GridColumnConfig[]|ColumnStoreConfig;\n    @Input() data                        ! : object[]|Model[]|ModelConfig[];\n    @Input() dataset                     ! : object|Record<string, string>;\n    @Input() disabled                    ! : boolean|'inert';\n    @Input() emptyText                   ! : string|EmptyTextDomConfig;\n    @Input() enableUndoRedoKeys          ! : boolean;\n    @Input() extraData                   ! : any;\n    @Input() flex                        ! : number|string;\n    @Input() height                      ! : number|string;\n    @Input() hidden                      ! : boolean;\n    @Input() hideFooters                 ! : boolean;\n    @Input() hideHeaders                 ! : boolean;\n    @Input() id                          ! : string;\n    @Input() inputFieldAlign             ! : 'start'|'end';\n    @Input() insertBefore                ! : HTMLElement|string;\n    @Input() insertFirst                 ! : HTMLElement|string;\n    @Input() keyMap                      ! : Record<string, KeyMapConfig>;\n    @Input() labelPosition               ! : 'before'|'above'|'align-before'|'auto'|null;\n    @Input() longPressTime               ! : number;\n    @Input() margin                      ! : number|string;\n    @Input() maxHeight                   ! : string|number;\n    @Input() maxWidth                    ! : string|number;\n    @Input() minHeight                   ! : string|number;\n    @Input() minWidth                    ! : string|number;\n    @Input() preserveScroll              ! : PreserveScrollOptions|boolean;\n    @Input() readOnly                    ! : boolean;\n    @Input() rendition                   ! : string|Record<string, string>|null;\n    @Input() rowHeight                   ! : number;\n    @Input() rowLines                    ! : boolean;\n    @Input() rtl                         ! : boolean;\n    @Input() scrollable                  ! : Scroller|boolean|ScrollerConfig;\n    @Input() selectionMode               ! : GridSelectionMode;\n    @Input() span                        ! : number;\n    @Input() stateSettings               ! : {\n        restoreUnconfiguredColumns?: boolean\n    };\n    @Input() store                       ! : Store|StoreConfig|AjaxStore|AjaxStoreConfig;\n    @Input() title                       ! : string;\n    @Input() tools                       ! : Record<string, Tool|ToolConfig>|null|Record<string, Tool>|Record<string, ToolConfig>;\n    @Input() transition                  ! : {\n        insertRecord?: boolean\n        removeRecord?: boolean\n        toggleColumn?: boolean\n        expandCollapseColumn?: boolean\n        toggleRegion?: boolean\n        toggleTreeNode?: boolean\n        toggleGroup?: boolean\n        filterRemoval?: boolean\n    };\n    @Input() transitionDuration          ! : number;\n    @Input() width                       ! : number|string;\n\n    // Properties only\n    @Input() focusVisible    ! : boolean;\n    @Input() hasChanges      ! : boolean;\n    @Input() originalStore   ! : Store;\n    @Input() parent          ! : Widget;\n    @Input() selectedCell    ! : GridLocation|GridLocationConfig;\n    @Input() selectedCells   ! : GridLocation[]|GridLocationConfig[];\n    @Input() selectedRecord  ! : Model;\n    @Input() selectedRecords ! : Model[]|number[];\n    @Input() selectedRows    ! : Model[]|number[];\n    @Input() state           ! : GridStateInfo;\n    @Input() tooltip         ! : string|TooltipConfig;\n\n    // Features\n    @Input() aiFilterFeature           ! : object|boolean|string|AIFilter|AIFilterConfig;\n    @Input() cellCopyPasteFeature      ! : object|boolean|string|CellCopyPaste|CellCopyPasteConfig;\n    @Input() cellEditFeature           ! : object|boolean|string|CellEdit|CellEditConfig;\n    @Input() cellMenuFeature           ! : object|boolean|string|CellMenu|CellMenuConfig;\n    @Input() cellTooltipFeature        ! : object|boolean|string|CellTooltip|CellTooltipConfig;\n    @Input() chartsFeature             ! : object|boolean|string|Charts|ChartsConfig;\n    @Input() columnAutoWidthFeature    ! : object|boolean|string|ColumnAutoWidth|ColumnAutoWidthConfig;\n    @Input() columnDragToolbarFeature  ! : object|boolean|string|ColumnDragToolbar|ColumnDragToolbarConfig;\n    @Input() columnPickerFeature       ! : object|boolean|string|ColumnPicker|ColumnPickerConfig;\n    @Input() columnRenameFeature       ! : object|boolean|string|ColumnRename|ColumnRenameConfig;\n    @Input() columnReorderFeature      ! : object|boolean|string|ColumnReorder|ColumnReorderConfig;\n    @Input() columnResizeFeature       ! : object|boolean|string|ColumnResize|ColumnResizeConfig;\n    @Input() excelExporterFeature      ! : object|boolean|string|ExcelExporter|ExcelExporterConfig;\n    @Input() fileDropFeature           ! : object|boolean|string|FileDrop|FileDropConfig;\n    @Input() fillHandleFeature         ! : object|boolean|string|FillHandle|FillHandleConfig;\n    @Input() filterFeature             ! : object|boolean|string|Filter|FilterConfig;\n    @Input() filterBarFeature          ! : object|boolean|string|FilterBar|FilterBarConfig;\n    @Input() groupFeature              ! : object|boolean|string|Group|GroupConfig;\n    @Input() groupSummaryFeature       ! : object|boolean|string|GroupSummary|GroupSummaryConfig;\n    @Input() headerMenuFeature         ! : object|boolean|string|HeaderMenu|HeaderMenuConfig;\n    @Input() lockRowsFeature           ! : object|boolean|string|LockRows|LockRowsConfig;\n    @Input() mergeCellsFeature         ! : object|boolean|string|MergeCells|MergeCellsConfig;\n    @Input() pdfExportFeature          ! : object|boolean|string|PdfExport|PdfExportConfig;\n    @Input() pinColumnsFeature         ! : object|boolean|string|PinColumns|PinColumnsConfig;\n    @Input() printFeature              ! : object|boolean|string|Print|PrintConfig;\n    @Input() quickFindFeature          ! : object|boolean|string|QuickFind|QuickFindConfig;\n    @Input() regionResizeFeature       ! : object|boolean|string|RegionResize|RegionResizeConfig;\n    @Input() rowCopyPasteFeature       ! : object|boolean|string|RowCopyPaste|RowCopyPasteConfig;\n    @Input() rowEditFeature            ! : object|boolean|string|RowEdit|RowEditConfig;\n    @Input() rowExpanderFeature        ! : object|boolean|string|RowExpander|RowExpanderConfig;\n    @Input() rowReorderFeature         ! : object|boolean|string|RowReorder|RowReorderConfig;\n    @Input() rowResizeFeature          ! : object|boolean|string|RowResize|RowResizeConfig;\n    @Input() searchFeature             ! : object|boolean|string|Search|SearchConfig;\n    @Input() sortFeature               ! : object|boolean|string|Sort|SortConfig;\n    @Input() splitFeature              ! : object|boolean|string|Split|SplitConfig;\n    @Input() stickyCellsFeature        ! : object|boolean|string|StickyCells|StickyCellsConfig;\n    @Input() stripeFeature             ! : object|boolean|string|Stripe|StripeConfig;\n    @Input() summaryFeature            ! : object|boolean|string|Summary|SummaryConfig;\n    @Input() treeFeature               ! : object|boolean|string|Tree|TreeConfig;\n    @Input() treeGroupFeature          ! : object|boolean|string|TreeGroup|TreeGroupConfig;\n\n    // Events emitters\n    /**\n     * Fires on the owning Grid before the cell editing is canceled, return `false` to prevent cancellation.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {Grid.util.GridLocation} event.editorContext Editing context\n     */\n    @Output() onBeforeCancelCellEdit: any = new EventEmitter<((event: { source: Grid, editorContext: GridLocation }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before the row editing is canceled, return false to signal that the value is invalid and editing should not be finalized.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeCancelRowEdit)\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid Target grid\n     * @param {RowEditorContext} event.editorContext Editing context\n     */\n    @Output() onBeforeCancelRowEdit: any = new EventEmitter<((event: { grid: Grid, editorContext: RowEditorContext }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before editing starts, return `false` to prevent editing\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {CellEditorContext} event.editorContext Editing context\n     */\n    @Output() onBeforeCellEditStart: any = new EventEmitter<((event: { source: Grid, editorContext: CellEditorContext }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before deleting a range of selected cell values by pressing `Backspace` or `Del`\n     * buttons while [autoEdit](https://bryntum.com/products/grid/docs/api/Grid/feature/CellEdit#config-autoEdit) is set to `true`. Return `false` to prevent editing.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {(Grid.util.GridLocation|Core.data.Model)[]} event.gridSelection An array of cell selectors or records that will have their values deleted (the records themselves will not get deleted, only visible column values).\n     */\n    @Output() onBeforeCellRangeDelete: any = new EventEmitter<((event: { source: Grid, gridSelection: (GridLocation|Model)[] }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires for each selected record on the owning Grid before editing a range of selected cell values\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.record Current selected record from the range\n     * @param {string} event.field The field being changed\n     * @param {any} event.value The value being set\n     */\n    @Output() onBeforeCellRangeEdit: any = new EventEmitter<((event: { record: Model, field: string, value: any }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event is fired prior to starting a column drag gesture. The drag is canceled if a listener returns `false`.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance.\n     * @param {Grid.column.Column} event.column The dragged column.\n     * @param {Event} event.event The browser event.\n     */\n    @Output() onBeforeColumnDragStart: any = new EventEmitter<((event: { source: Grid, column: Column, event: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event is fired when a column is dropped, and you can return false from a listener to abort the operation.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance.\n     * @param {Grid.column.Column} event.column The dragged column.\n     * @param {Grid.column.Column} event.insertBefore The column before which the dragged column will be inserted.\n     * @param {Grid.column.Column} event.newParent The new parent column.\n     * @param {Event} event.event The browser event.\n     * @param {string} event.region The region where the column was dropped.\n     */\n    @Output() onBeforeColumnDropFinalize: any = new EventEmitter<((event: { source: Grid, column: Column, insertBefore: Column, newParent: Column, event: Event, region: string }) => 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 {Grid.view.Grid} event.source The grid instance\n     * @param {Grid.column.Column} event.column The column\n     * @param {Event} event.domEvent The browser event\n     */\n    @Output() onBeforeColumnResize: any = new EventEmitter<((event: { source: Grid, column: Column, domEvent: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before a copy action is performed, return `false` to prevent the action\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {Grid.util.GridLocation[]} event.cells The cells about to be copied or cut\n     * @param {string} event.data The string data about to be copied or cut\n     * @param {boolean} event.isCut `true` if this is a cut action\n     * @param {string} event.entityName 'cell' to distinguish this event from other beforeCopy events\n     */\n    @Output() onBeforeCopy: any = new EventEmitter<((event: { source: Grid, cells: GridLocation[], data: string, isCut: boolean, entityName: string }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before CSV export starts. Return `false` to cancel the export.\n     * @param {object} event Event object\n     * @param {ExportConfig} event.config Export config\n     * @param {Grid.column.Column[]} event.columns An array of columns to export\n     * @param {Core.data.Model[]} event.rows An array of records to export\n     * @param {string} event.lineDelimiter The CSV delimiter to separate lines\n     * @param {string} event.columnDelimiter The CSV delimiter to separate values on one line\n     */\n    @Output() onBeforeCSVExport: any = new EventEmitter<((event: { config: ExportConfig, columns: Column[], rows: Model[], lineDelimiter: string, columnDelimiter: string }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before an object is destroyed.\n     * @param {object} event Event object\n     * @param {Core.Base} event.source The Object that is being destroyed.\n     */\n    @Output() onBeforeDestroy: any = new EventEmitter<((event: { source: Base }) => void)|string>();\n    /**\n     * Fires on the owning Grid before Excel export starts. Return `false` to cancel the export.\n     * @param {object} event Event object\n     * @param {ExportConfig} event.config Export config\n     * @param {XLSColumn[]} event.columns An array of columns to export\n     * @param {any[][]} event.rows An array of records to export\n     */\n    @Output() onBeforeExcelExport: any = new EventEmitter<((event: { config: ExportConfig, columns: XLSColumn[], rows: any[] }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired before dragging of the FillHandle starts, return `false` to prevent the drag operation.\n     * @param {object} event Event object\n     * @param {Grid.util.GridLocation} event.cell Information about the column / record\n     * @param {MouseEvent} event.domEvent The raw DOM event\n     */\n    @Output() onBeforeFillHandleDragStart: any = new EventEmitter<((event: { cell: GridLocation, domEvent: MouseEvent }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before the cell editing is finished, return false to signal that the value is invalid and editing should not be finalized.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid Target grid\n     * @param {CellEditorContext} event.editorContext Editing context\n     */\n    @Output() onBeforeFinishCellEdit: any = new EventEmitter<((event: { grid: Grid, editorContext: CellEditorContext }) => void)|string>();\n    /**\n     * Fires on the owning Grid before the row editing is finished, return false to signal that the value is invalid and editing should not be finalized.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeFinishRowEdit)\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid Target grid\n     * @param {RowEditorContext} event.editorContext Editing context\n     */\n    @Output() onBeforeFinishRowEdit: any = new EventEmitter<((event: { grid: Grid, editorContext: RowEditorContext }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Triggered before a widget is hidden. Return `false` to prevent the action.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being hidden.\n     */\n    @Output() onBeforeHide: any = new EventEmitter<((event: { source: Widget }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before a paste action is performed, return `false` to prevent the action\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {string} event.clipboardData The clipboardData about to be pasted\n     * @param {Grid.util.GridLocation} event.targetCell The cell from which the paste will be started\n     * @param {string} event.entityName 'cell' to distinguish this event from other beforePaste events\n     * @param {string} event.text The raw text from clipboard\n     */\n    @Output() onBeforePaste: any = new EventEmitter<((event: { source: Grid, clipboardData: string, targetCell: GridLocation, entityName: string, text: string }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before export started. Return `false` to cancel the export.\n     * @param {object} event Event object\n     * @param {object} event.config Export config\n     */\n    @Output() onBeforePdfExport: any = new EventEmitter<((event: { config: object }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before a row is rendered.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance.\n     * @param {Grid.row.Row} event.row The row about to be rendered.\n     * @param {Core.data.Model} event.record The record for the row.\n     * @param {number} event.recordIndex The zero-based index of the record.\n     */\n    @Output() onBeforeRenderRow: any = new EventEmitter<((event: { source: Grid, row: Row, record: Model, recordIndex: number }) => void)|string>();\n    /**\n     * Grid rows are about to be rendered\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source This grid.\n     */\n    @Output() onBeforeRenderRows: any = new EventEmitter<((event: { source: Grid }) => void)|string>();\n    /**\n     * This event fires before row collapse is started.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeRowCollapse)\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.record Record\n     */\n    @Output() onBeforeRowCollapse: any = new EventEmitter<((event: { record: Model }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires before row expand is started.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-beforeRowExpand)\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.record Record\n     */\n    @Output() onBeforeRowExpand: any = new EventEmitter<((event: { record: Model }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires before the selection changes. Returning `false` from a listener prevents the change\n     * @param {object} event Event object\n     * @param {string} event.action `'select'`/`'deselect'`\n     * @param {'row','cell'} event.mode `'row'`/`'cell'`\n     * @param {Grid.view.Grid} event.source\n     * @param {Core.data.Model[]} event.deselected The records to be deselected in this operation.\n     * @param {Core.data.Model[]} event.selected The records to be selected in this operation.\n     * @param {Core.data.Model[]} event.selection The records in the current selection, before applying `selected` and `deselected`\n     * @param {Grid.util.GridLocation[]} event.deselectedCells The cells to be deselected in this operation.\n     * @param {Grid.util.GridLocation[]} event.selectedCells The cells to be selected in this operation.\n     * @param {Grid.util.GridLocation[]} event.cellSelection The cells in the current selection, before applying `selectedCells` and `deselectedCells`\n     */\n    @Output() onBeforeSelectionChange: any = new EventEmitter<((event: { action: string, mode: 'row'|'cell', source: Grid, deselected: Model[], selected: Model[], selection: Model[], deselectedCells: GridLocation[], selectedCells: GridLocation[], cellSelection: GridLocation[] }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired before this container will load record values into its child fields. This is useful if you\n     * want to modify the UI before data is loaded (e.g. set some input field to be readonly)\n     * @param {object} event Event object\n     * @param {Core.widget.Container} event.source The container\n     * @param {Core.data.Model} event.record The record\n     */\n    @Output() onBeforeSetRecord: any = new EventEmitter<((event: { source: Container, record: Model }) => void)|string>();\n    /**\n     * Triggered before a widget is shown. Return `false` to prevent the action.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget,any} event.source The widget being shown\n     */\n    @Output() onBeforeShow: any = new EventEmitter<((event: { source: Widget|any }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid before editing starts, return `false` to prevent editing\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {RowEditorContext} event.editorContext Editing context\n     */\n    @Output() onBeforeStartRowEdit: any = new EventEmitter<((event: { source: Grid, editorContext: RowEditorContext }) => 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 {GridStateInfo} event.state State object config\n     */\n    @Output() onBeforeStateApply: any = new EventEmitter<((event: { state: GridStateInfo }) => 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 {GridStateInfo} event.state State object config\n     */\n    @Output() onBeforeStateSave: any = new EventEmitter<((event: { state: GridStateInfo }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired when a group is going to be expanded or collapsed using the UI.\n     * Returning `false` from a listener prevents the operation\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.groupRecord [DEPRECATED] Use `groupRecords` param instead\n     * @param {Core.data.Model[]} event.groupRecords The group records being toggled\n     * @param {boolean} event.collapse Collapsed (true) or expanded (false)\n     * @param {Event} event.domEvent The user interaction event (eg a `click` event) if the toggle request was instigated by user interaction.\n     */\n    @Output() onBeforeToggleGroup: any = new EventEmitter<((event: { groupRecord: Model, groupRecords: Model[], collapse: boolean, domEvent: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired before a parent node record toggles its collapsed state.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance.\n     * @param {Core.data.Model} event.record The record being toggled.\n     * @param {boolean} event.collapse `true` if the node is being collapsed.\n     */\n    @Output() onBeforeToggleNode: any = new EventEmitter<((event: { source: Grid, record: Model, collapse: boolean }) => void)|string>();\n    /**\n     * Fires on the owning Grid when editing is cancelled\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {Grid.util.GridLocation} event.editorContext Editing context\n     * @param {Event} event.event Included if the cancellation was triggered by a DOM event\n     */\n    @Output() onCancelCellEdit: any = new EventEmitter<((event: { source: Grid, editorContext: GridLocation, event: Event }) => void)|string>();\n    /**\n     * Fires when any other event is fired from the object.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-catchAll)\n     * @param {object} event Event object\n     * @param {{[key: string]: any, type: string}} event.event The Object that contains event details\n     * @param {string} event.event.type The type of the event which is caught by the listener\n     */\n    @Output() onCatchAll: any = new EventEmitter<((event: {[key: string]: any, type: string}) => void)|string>();\n    /**\n     * Fired when user clicks in a grid cell\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid The grid instance\n     * @param {Core.data.Model} event.record The record representing the row\n     * @param {Grid.column.Column} event.column The column to which the cell belongs\n     * @param {HTMLElement} event.cellElement The cell HTML element\n     * @param {HTMLElement} event.target The target element\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onCellClick: any = new EventEmitter<((event: { grid: Grid, record: Model, column: Column, cellElement: HTMLElement, target: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when user activates contextmenu in a grid cell\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid The grid instance\n     * @param {Core.data.Model} event.record The record representing the row\n     * @param {Grid.column.Column} event.column The column to which the cell belongs\n     * @param {HTMLElement} event.cellElement The cell HTML element\n     * @param {HTMLElement} event.target The target element\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onCellContextMenu: any = new EventEmitter<((event: { grid: Grid, record: Model, column: Column, cellElement: HTMLElement, target: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when user double clicks a grid cell\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid The grid instance\n     * @param {Core.data.Model} event.record The record representing the row\n     * @param {Grid.column.Column} event.column The column to which the cell belongs\n     * @param {HTMLElement} event.cellElement The cell HTML element\n     * @param {HTMLElement} event.target The target element\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onCellDblClick: any = new EventEmitter<((event: { grid: Grid, record: Model, column: Column, cellElement: HTMLElement, target: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * This event fires on the owning grid before the context menu is shown for a cell.\n     * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/grid/docs/api/Grid/feature/CellMenu#config-processItems).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-cellMenuBeforeShow)\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     * @param {Core.data.Model} event.record Record\n     */\n    @Output() onCellMenuBeforeShow: any = new EventEmitter<((event: { source: Grid, menu: Menu, items: Record<string, MenuItemEntry>, column: Column, record: Model }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning grid when an item is selected in the cell context menu.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     * @param {Core.data.Model} event.record Record\n     */\n    @Output() onCellMenuItem: any = new EventEmitter<((event: { source: Grid, menu: Menu, item: MenuItem, column: Column, record: Model }) => void)|string>();\n    /**\n     * This event fires on the owning grid after the context menu is shown for a cell.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     * @param {Core.data.Model} event.record Record\n     */\n    @Output() onCellMenuShow: any = new EventEmitter<((event: { source: Grid, menu: Menu, items: Record<string, MenuItemEntry>, column: Column, record: Model }) => void)|string>();\n    /**\n     * This event fires on the owning grid when a check item is toggled in the cell context menu.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     * @param {Core.data.Model} event.record Record\n     * @param {boolean} event.checked Checked or not\n     */\n    @Output() onCellMenuToggleItem: any = new EventEmitter<((event: { source: Grid, menu: Menu, item: MenuItem, column: Column, record: Model, checked: boolean }) => void)|string>();\n    /**\n     * Fired when the mouse enters a cell\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance\n     * @param {Core.data.Model} event.record The record representing the hovered cell\n     * @param {Grid.column.Column} event.column The column currently hovered\n     * @param {HTMLElement} event.cellElement The cell HTML element\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onCellMouseEnter: any = new EventEmitter<((event: { source: Grid, record: Model, column: Column, cellElement: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when the mouse leaves a cell\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance\n     * @param {Core.data.Model} event.record The record representing the cell that the mouse left\n     * @param {Grid.column.Column} event.column The column representing the cell that the mouse left\n     * @param {HTMLElement} event.cellElement The cell HTML element that the mouse left\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onCellMouseLeave: any = new EventEmitter<((event: { source: Grid, record: Model, column: Column, cellElement: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when a user moves the mouse out of a grid cell\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid The grid instance\n     * @param {Core.data.Model} event.record The record representing the row\n     * @param {Grid.column.Column} event.column The column to which the cell belongs\n     * @param {HTMLElement} event.cellElement The cell HTML element\n     * @param {HTMLElement} event.target The target element\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onCellMouseOut: any = new EventEmitter<((event: { grid: Grid, record: Model, column: Column, cellElement: HTMLElement, target: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when user moves the mouse over a grid cell\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid The grid instance\n     * @param {Core.data.Model} event.record The record representing the row\n     * @param {Grid.column.Column} event.column The column to which the cell belongs\n     * @param {HTMLElement} event.cellElement The cell HTML element\n     * @param {HTMLElement} event.target The target element\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onCellMouseOver: any = new EventEmitter<((event: { grid: Grid, record: Model, column: Column, cellElement: HTMLElement, target: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Fires when a Panel is collapsed using the [collapsible](https://bryntum.com/products/grid/docs/api/Core/widget/Panel#config-collapsible) setting.\n     * @param {object} event Event object\n     * @param {Core.widget.Panel} event.source This Panel.\n     */\n    @Output() onCollapse: any = new EventEmitter<((event: { source: Panel }) => void)|string>();\n    /**\n     * Fired before a parent node record is collapsed.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance.\n     * @param {Core.data.Model} event.record The record which has been collapsed.\n     */\n    @Output() onCollapseNode: any = new EventEmitter<((event: { source: Grid, record: Model }) => void)|string>();\n    /**\n     * This event is fired when a column is being dragged, and you can set the `valid` flag on the `context` object\n     * to indicate whether the drop position is valid or not.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance.\n     * @param {Grid.column.Column} event.column The dragged column.\n     * @param {Grid.column.Column} event.insertBefore The column before which the dragged column will be inserted (if not last).\n     * @param {Event} event.event The browser event.\n     * @param {object} event.context\n     * @param {boolean} event.context.valid Set this to `true` or `false` to indicate whether the drop position is valid.\n     */\n    @Output() onColumnDrag: any = new EventEmitter<((event: { source: Grid, column: Column, insertBefore: Column, event: Event, context: { valid: boolean } }) => void)|string>();\n    /**\n     * This event is fired when a column drag gesture has started.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance.\n     * @param {Grid.column.Column} event.column The dragged column.\n     * @param {Event} event.event The browser event.\n     */\n    @Output() onColumnDragStart: any = new EventEmitter<((event: { source: Grid, column: Column, event: Event }) => void)|string>();\n    /**\n     * This event is always fired after a column is dropped. The `valid` param is `true` if the operation was not\n     * vetoed and the column was moved in the column store.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance.\n     * @param {Grid.column.Column} event.column The dragged column.\n     * @param {Grid.column.Column} event.insertBefore The column before which the dragged column will be inserted.\n     * @param {Grid.column.Column} event.newParent The new parent column.\n     * @param {boolean} event.valid `true` if the operation was not vetoed.\n     * @param {Event} event.event The browser event.\n     * @param {string} event.region The region where the column was dropped.\n     */\n    @Output() onColumnDrop: any = new EventEmitter<((event: { source: Grid, column: Column, insertBefore: Column, newParent: Column, valid: boolean, event: Event, region: string }) => 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 {Grid.view.Grid} event.source The grid instance\n     * @param {Grid.column.Column} event.column The resized column\n     * @param {Event} event.domEvent The browser event\n     */\n    @Output() onColumnResize: any = new EventEmitter<((event: { source: Grid, column: Column, domEvent: Event }) => void)|string>();\n    /**\n     * This event is fired when a column resize gesture starts.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance\n     * @param {Grid.column.Column} event.column The column\n     * @param {Event} event.domEvent The browser event\n     */\n    @Output() onColumnResizeStart: any = new EventEmitter<((event: { source: Grid, column: Column, domEvent: Event }) => void)|string>();\n    /**\n     * This event fires on the owning widget when an item is selected in the context menu.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The owning widget\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     */\n    @Output() onContextMenuItem: any = new EventEmitter<((event: { source: Widget, menu: Menu, item: MenuItem }) => void)|string>();\n    /**\n     * This event fires on the owning widget when a check item is toggled in the context menu.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The owning widget\n     * @param {Core.widget.Menu} event.menu The menu\n     * @param {Core.widget.MenuItem} event.item Selected menu item\n     * @param {boolean} event.checked Checked or not\n     */\n    @Output() onContextMenuToggleItem: any = new EventEmitter<((event: { source: Widget, menu: Menu, item: MenuItem, checked: boolean }) => void)|string>();\n    /**\n     * Fires on the owning Grid after a copy action is performed.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {Grid.util.GridLocation[]} event.cells The cells about to be copied or cut\n     * @param {string} event.copiedDataString The concatenated data string that was copied or cut\n     * @param {boolean} event.isCut `true` if this was a cut action\n     * @param {string} event.entityName 'cell' to distinguish this event from other copy events\n     */\n    @Output() onCopy: any = new EventEmitter<((event: { source: Grid, cells: GridLocation[], copiedDataString: string, isCut: boolean, entityName: string }) => void)|string>();\n    /**\n     * Fired when data in the store changes.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-dataChange)\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owning grid\n     * @param {Core.data.Store} event.store The originating store\n     * @param {'remove','removeAll','add','clearchanges','filter','update','dataset','replace'} event.action Name of action which triggered the change. May be one of:  * `'remove'` * `'removeAll'` * `'add'` * `'clearchanges'` * `'filter'` * `'update'` * `'dataset'` * `'replace'`\n     * @param {Core.data.Model} event.record Changed record, for actions that affects exactly one record (`'update'`)\n     * @param {Core.data.Model[]} event.records Changed records, passed for all actions except `'removeAll'`\n     * @param {object} event.changes Passed for the `'update'` action, info on which record fields changed\n     */\n    @Output() onDataChange: any = new EventEmitter<((event: { source: Grid, store: Store, action: 'remove'|'removeAll'|'add'|'clearchanges'|'filter'|'update'|'dataset'|'replace', record: Model, records: Model[], changes: object }) => 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/grid/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     * Fires while drag selecting. UI will update with current range, but the cells will not be selected until\n     * mouse up. This event can be listened for to perform actions while drag selecting.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source\n     * @param {GridLocationConfig[],Grid.util.GridLocation[]} event.selectedCells The cells that is currently being dragged over\n     * @param {Core.data.Model[]} event.selectedRecords The records that is currently being dragged over\n     */\n    @Output() onDragSelecting: any = new EventEmitter<((event: { source: Grid, selectedCells: GridLocationConfig[]|GridLocation[], selectedRecords: Model[] }) => void)|string>();\n    /**\n     * Triggered when a widget's [element](https://bryntum.com/products/grid/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/grid/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 after a parent node record is expanded.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance.\n     * @param {Core.data.Model} event.record The record which has been expanded.\n     */\n    @Output() onExpandNode: any = new EventEmitter<((event: { source: Grid, record: Model }) => void)|string>();\n    /**\n     * Fired when a file is dropped on the widget element\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The owning Grid instance\n     * @param {DataTransferItem} event.file The dropped file descriptor\n     * @param {DragEvent} event.domEvent The native DragEvent\n     */\n    @Output() onFileDrop: any = new EventEmitter<((event: { source: Grid, file: DataTransferItem, domEvent: DragEvent }) => void)|string>();\n    /**\n     * Fired before the FillHandle dragging is finalized and values are applied to cells, return `false` to prevent the\n     * drag operation from applying data changes.\n     * @param {object} event Event object\n     * @param {Grid.util.GridLocation} event.from The from cell\n     * @param {Grid.util.GridLocation} event.to The to cell\n     * @param {MouseEvent} event.domEvent The raw DOM event\n     */\n    @Output() onFillHandleBeforeDragFinalize: any = new EventEmitter<((event: { from: GridLocation, to: GridLocation, domEvent: MouseEvent }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired while dragging the FillHandle.\n     * @param {object} event Event object\n     * @param {Grid.util.GridLocation} event.from The from cell\n     * @param {Grid.util.GridLocation} event.to The to cell\n     * @param {MouseEvent} event.domEvent The raw DOM event\n     */\n    @Output() onFillHandleDrag: any = new EventEmitter<((event: { from: GridLocation, to: GridLocation, domEvent: MouseEvent }) => void)|string>();\n    /**\n     * Fired when a FillHandle drag operation is aborted.\n     */\n    @Output() onFillHandleDragAbort: any = new EventEmitter<(() => void)|string>();\n    /**\n     * Fired after a FillHandle drag operation.\n     * @param {object} event Event object\n     * @param {Grid.util.GridLocation} event.from The from cell\n     * @param {Grid.util.GridLocation} event.to The to cell\n     * @param {MouseEvent} event.domEvent The raw DOM event\n     */\n    @Output() onFillHandleDragEnd: any = new EventEmitter<((event: { from: GridLocation, to: GridLocation, domEvent: MouseEvent }) => void)|string>();\n    /**\n     * Fired when dragging of the FillHandle starts.\n     * @param {object} event Event object\n     * @param {Grid.util.GridLocation} event.cell Information about the column / record\n     * @param {MouseEvent} event.domEvent The raw DOM event\n     */\n    @Output() onFillHandleDragStart: any = new EventEmitter<((event: { cell: GridLocation, domEvent: MouseEvent }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid when cell editing is finished\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid Target grid\n     * @param {CellEditorContext} event.editorContext Editing context\n     */\n    @Output() onFinishCellEdit: any = new EventEmitter<((event: { grid: Grid, editorContext: CellEditorContext }) => void)|string>();\n    /**\n     * Fires on the owning Grid before the row editing is finished, return false to signal that the value is invalid and editing should not be finalized.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-finishRowEdit)\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid Target grid\n     * @param {RowEditorContext} event.editorContext Editing context\n     */\n    @Output() onFinishRowEdit: any = new EventEmitter<((event: { grid: Grid, editorContext: RowEditorContext }) => Promise<boolean>|boolean|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     * Fired before dragging starts, return false to prevent the drag operation.\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.source\n     * @param {object} event.context\n     * @param {Core.data.Model[]} event.context.records The dragged row records\n     * @param {MouseEvent,TouchEvent} event.event\n     */\n    @Output() onGridRowBeforeDragStart: any = new EventEmitter<((event: { source: GridBase, context: { records: Model[] }, event: MouseEvent|TouchEvent }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired before the row drop operation is finalized. You can return false to abort the drop operation, or a\n     * Promise yielding `true` / `false` which allows for asynchronous abort (e.g. first show user a confirmation dialog).\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.source\n     * @param {object} event.context\n     * @param {boolean} event.context.valid Set this to true or false to indicate whether the drop position is valid\n     * @param {Core.data.Model} event.context.insertBefore The record to insert before (`null` if inserting at last position of a parent node)\n     * @param {Core.data.Model} event.context.parent The parent record of the current drop position (only applicable for trees)\n     * @param {Core.data.Model[]} event.context.records The dragged row records\n     * @param {RecordPositionContext[]} event.context.oldPositionContext An array of objects with information about the previous tree position. Objects contain the `record`, and its original `parentIndex` and `parentId` values\n     * @param {MouseEvent} event.event\n     */\n    @Output() onGridRowBeforeDropFinalize: any = new EventEmitter<((event: { source: GridBase, context: { valid: boolean, insertBefore: Model, parent: Model, records: Model[], oldPositionContext: RecordPositionContext[] }, event: MouseEvent }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired while the row is being dragged, in the listener function you have access to `context.insertBefore` a grid /\n     * tree record, and additionally `context.parent` (a TreeNode) for trees. You can signal that the drop position is\n     * valid or invalid by setting `context.valid = false;`\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.source\n     * @param {object} event.context\n     * @param {boolean} event.context.valid Set this to true or false to indicate whether the drop position is valid.\n     * @param {Core.data.Model} event.context.insertBefore The record to insert before (`null` if inserting at last position of a parent node)\n     * @param {Core.data.Model} event.context.parent The parent record of the current drop position (only applicable for trees)\n     * @param {Core.data.Model[]} event.context.records The dragged row records\n     * @param {MouseEvent} event.event\n     */\n    @Output() onGridRowDrag: any = new EventEmitter<((event: { source: GridBase, context: { valid: boolean, insertBefore: Model, parent: Model, records: Model[] }, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when a row drag operation is aborted\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.source\n     * @param {object} event.context\n     * @param {Core.data.Model[]} event.context.records The dragged row records\n     * @param {MouseEvent} event.event\n     */\n    @Output() onGridRowDragAbort: any = new EventEmitter<((event: { source: GridBase, context: { records: Model[] }, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when dragging starts.\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.source\n     * @param {object} event.context\n     * @param {Core.data.Model[]} event.context.records The dragged row records\n     * @param {MouseEvent,TouchEvent} event.event\n     */\n    @Output() onGridRowDragStart: any = new EventEmitter<((event: { source: GridBase, context: { records: Model[] }, event: MouseEvent|TouchEvent }) => void)|string>();\n    /**\n     * Fired after the row drop operation has completed, regardless of validity\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.source\n     * @param {object} event.context\n     * @param {boolean} event.context.valid true or false depending on whether the drop position was valid\n     * @param {Core.data.Model} event.context.insertBefore The record to insert before (`null` if inserting at last position of a parent node)\n     * @param {Core.data.Model} event.context.parent The parent record of the current drop position (only applicable for trees)\n     * @param {Core.data.Model[]} event.context.records The dragged row records\n     * @param {RecordPositionContext[]} event.context.oldPositionContext An array of objects with information about the previous tree position. Objects contain the record, and its original `parentIndex` and `parentId` values\n     * @param {MouseEvent} event.event\n     */\n    @Output() onGridRowDrop: any = new EventEmitter<((event: { source: GridBase, context: { valid: boolean, insertBefore: Model, parent: Model, records: Model[], oldPositionContext: RecordPositionContext[] }, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when a grid header is clicked on.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-headerClick)\n     * @param {object} event Event object\n     * @param {Event} event.domEvent The triggering DOM event.\n     * @param {Grid.column.Column} event.column The column clicked on.\n     */\n    @Output() onHeaderClick: any = new EventEmitter<((event: { domEvent: Event, column: Column }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Grid before the context menu is shown for a header.\n     * Allows manipulation of the items to show in the same way as in the [processItems](https://bryntum.com/products/grid/docs/api/Grid/feature/HeaderMenu#config-processItems).\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-headerMenuBeforeShow)\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     */\n    @Output() onHeaderMenuBeforeShow: any = new EventEmitter<((event: { source: Grid, menu: Menu, items: Record<string, MenuItemEntry>, column: Column }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * This event fires on the owning Grid when an item is selected in the header context menu.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     */\n    @Output() onHeaderMenuItem: any = new EventEmitter<((event: { source: Grid, menu: Menu, item: MenuItem, column: Column }) => void)|string>();\n    /**\n     * This event fires on the owning Grid after the context menu is shown for a header\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     */\n    @Output() onHeaderMenuShow: any = new EventEmitter<((event: { source: Grid, menu: Menu, items: Record<string, MenuItemEntry>, column: Column }) => void)|string>();\n    /**\n     * This event fires on the owning Grid when a check item is toggled in the header context menu.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} 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 {Grid.column.Column} event.column Column\n     * @param {boolean} event.checked Checked or not\n     */\n    @Output() onHeaderMenuToggleItem: any = new EventEmitter<((event: { source: Grid, menu: Menu, item: MenuItem, column: Column, checked: boolean }) => void)|string>();\n    /**\n     * Triggered after a widget was hidden\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget\n     */\n    @Output() onHide: any = new EventEmitter<((event: { source: Widget }) => void)|string>();\n    /**\n     * Fires when row locking is enabled.\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.clone The created clone\n     */\n    @Output() onLockRows: any = new EventEmitter<((event: { clone: GridBase }) => void)|string>();\n    /**\n     * Mouse moved out from element in grid\n     * @param {object} event Event object\n     * @param {MouseEvent} event.event The native browser event\n     */\n    @Output() onMouseOut: any = new EventEmitter<((event: { event: MouseEvent }) => void)|string>();\n    /**\n     * Mouse moved in over element in grid\n     * @param {object} event Event object\n     * @param {MouseEvent} event.event The native browser event\n     */\n    @Output() onMouseOver: any = new EventEmitter<((event: { event: MouseEvent }) => 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/grid/docs/api/Grid/view/Grid#event-paint)\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget being painted.\n     * @param {boolean} event.firstPaint `true` if this is the first paint.\n     */\n    @Output() onPaint: any = new EventEmitter<((event: { source: Widget, firstPaint: boolean }) => void)|string>();\n    /**\n     * Fires on the owning Grid after a paste action is performed.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {string} event.clipboardData The clipboardData that was pasted\n     * @param {Core.data.Model[]} event.modifiedRecords The records which have been modified due to the paste action\n     * @param {Grid.util.GridLocation} event.targetCell The cell from which the paste will be started\n     * @param {string} event.entityName 'cell' to distinguish this event from other paste events\n     */\n    @Output() onPaste: any = new EventEmitter<((event: { source: Grid, clipboardData: string, modifiedRecords: Model[], targetCell: GridLocation, entityName: string }) => void)|string>();\n    /**\n     * Fires on the owning Grid when export has finished\n     * @param {object} event Event object\n     * @param {Response} event.response Optional response, if received\n     * @param {Error} event.error Optional error, if exception occurred\n     */\n    @Output() onPdfExport: any = new EventEmitter<((event: { response?: any, error?: Error }) => 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/grid/docs/api/Core/widget/Widget#function-recompose), if this results in some change to the widget's rendered DOM elements.\n     */\n    @Output() onRecompose: any = new EventEmitter<(() => void)|string>();\n    /**\n     * Fires after a row is rendered.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance.\n     * @param {Grid.row.Row} event.row The row that has been rendered.\n     * @param {Core.data.Model} event.record The record for the row.\n     * @param {number} event.recordIndex The zero-based index of the record.\n     */\n    @Output() onRenderRow: any = new EventEmitter<((event: { source: Grid, row: Row, record: Model, recordIndex: number }) => void)|string>();\n    /**\n     * Grid rows have been rendered\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source This grid.\n     */\n    @Output() onRenderRows: any = new EventEmitter<((event: { source: Grid }) => void)|string>();\n    /**\n     * Fired when the encapsulating element of a Widget resizes *only when [monitorResize](https://bryntum.com/products/grid/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     * Grid resize lead to a new responsive level being applied\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.grid Grid that was resized\n     * @param {string} event.level New responsive level (small, large, etc)\n     * @param {number} event.width New width in px\n     * @param {string} event.oldLevel Old responsive level\n     * @param {number} event.oldWidth Old width in px\n     */\n    @Output() onResponsive: any = new EventEmitter<((event: { grid: Grid, level: string, width: number, oldLevel: string, oldWidth: number }) => void)|string>();\n    /**\n     * This event fires when a row has finished collapsing.\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.record Record\n     */\n    @Output() onRowCollapse: any = new EventEmitter<((event: { record: Model }) => void)|string>();\n    /**\n     * This event fires when a row expand has finished expanding.\n     * ...\n     * [View online docs...](https://bryntum.com/products/grid/docs/api/Grid/view/Grid#event-rowExpand)\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.record Record\n     * @param {object} event.expandedElements An object with the Grid region name as property and the expanded body element as value\n     * @param {Core.widget.Widget} event.widget In case of expanding a Widget, this will be a reference to the instance created by the actual expansion. If there is multiple Grid regions, use the `widgets` param instead.\n     * @param {object} event.widgets In case of expanding a Widget, this will be an object with the Grid region name as property and the reference to the widget instance created by the actual expansion\n     */\n    @Output() onRowExpand: any = new EventEmitter<((event: { record: Model, expandedElements: object, widget: Widget, widgets: object }) => void)|string>();\n    /**\n     * Fired when the mouse enters a row\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance\n     * @param {Core.data.Model} event.record The record representing the hovered row\n     * @param {Grid.column.Column} event.column The column currently hovered\n     * @param {HTMLElement} event.cellElement The cell HTML element\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onRowMouseEnter: any = new EventEmitter<((event: { source: Grid, record: Model, column: Column, cellElement: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Fired when the mouse leaves a row\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The grid instance\n     * @param {Core.data.Model} event.record The record representing the row that the mouse left\n     * @param {HTMLElement} event.cellElement The cell HTML element that the mouse left\n     * @param {MouseEvent} event.event The native DOM event\n     */\n    @Output() onRowMouseLeave: any = new EventEmitter<((event: { source: Grid, record: Model, cellElement: HTMLElement, event: MouseEvent }) => void)|string>();\n    /**\n     * Grid has scrolled vertically\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance.\n     * @param {number} event.scrollTop The vertical scroll position.\n     */\n    @Output() onScroll: any = new EventEmitter<((event: { source: Grid, scrollTop: number }) => void)|string>();\n    /**\n     * The selection has been changed.\n     * @param {object} event Event object\n     * @param {'select','deselect'} event.action `'select'`/`'deselect'`\n     * @param {'row','cell'} event.mode `'row'`/`'cell'`\n     * @param {Grid.view.Grid} event.source\n     * @param {Core.data.Model[]} event.deselected The records deselected in this operation.\n     * @param {Core.data.Model[]} event.selected The records selected in this operation.\n     * @param {Core.data.Model[]} event.selection The records in the new selection.\n     * @param {Grid.util.GridLocation[]} event.deselectedCells The cells deselected in this operation.\n     * @param {Grid.util.GridLocation[]} event.selectedCells The cells selected in this operation.\n     * @param {Grid.util.GridLocation[]} event.cellSelection The cells in the new selection.\n     */\n    @Output() onSelectionChange: any = new EventEmitter<((event: { action: 'select'|'deselect', mode: 'row'|'cell', source: Grid, deselected: Model[], selected: Model[], selection: Model[], deselectedCells: GridLocation[], selectedCells: GridLocation[], cellSelection: GridLocation[] }) => void)|string>();\n    /**\n     * The selectionMode configuration has been changed.\n     * @param {object} event Event object\n     * @param {object} event.selectionMode The new [selectionMode](https://bryntum.com/products/grid/docs/api/Grid/view/mixin/GridSelection#config-selectionMode)\n     */\n    @Output() onSelectionModeChange: any = new EventEmitter<((event: { selectionMode: object }) => void)|string>();\n    /**\n     * Triggered after a widget is shown.\n     * @param {object} event Event object\n     * @param {Core.widget.Widget} event.source The widget\n     */\n    @Output() onShow: any = new EventEmitter<((event: { source: Widget }) => void)|string>();\n    /**\n     * Fires when splitting the Grid.\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase[]} event.subViews The sub views created by the split\n     * @param {object} event.options The options passed to the split call\n     * @param {'horizontal','vertical','both'} event.options.direction The direction of the split\n     * @param {Grid.column.Column} event.options.atColumn The column to split at\n     * @param {Core.data.Model} event.options.atRecord The record to split at\n     */\n    @Output() onSplit: any = new EventEmitter<((event: { subViews: GridBase[], options: { direction: 'horizontal'|'vertical'|'both', atColumn: Column, atRecord: Model } }) => void)|string>();\n    /**\n     * Fired by the Grid when the collapse icon is clicked. Return `false` to prevent the default collapse action,\n     * if you want to implement your own behavior.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The Grid instance.\n     * @param {Grid.view.SubGrid} event.subGrid The subgrid\n     * @param {Event} event.domEvent The native DOM event\n     */\n    @Output() onSplitterCollapseClick: any = new EventEmitter<((event: { source: Grid, subGrid: SubGrid, domEvent: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fired by the Grid after a sub-grid has been resized using the splitter\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The Grid instance.\n     * @param {Grid.view.SubGrid} event.subGrid The resized subgrid\n     * @param {Event} event.domEvent The native DOM event\n     */\n    @Output() onSplitterDragEnd: any = new EventEmitter<((event: { source: Grid, subGrid: SubGrid, domEvent: Event }) => void)|string>();\n    /**\n     * Fired by the Grid when a sub-grid resize gesture starts\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The Grid instance.\n     * @param {Grid.view.SubGrid} event.subGrid The subgrid about to be resized\n     * @param {Event} event.domEvent The native DOM event\n     */\n    @Output() onSplitterDragStart: any = new EventEmitter<((event: { source: Grid, subGrid: SubGrid, domEvent: Event }) => void)|string>();\n    /**\n     * Fired by the Grid when the expand icon is clicked. Return `false` to prevent the default expand action,\n     * if you want to implement your own behavior.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The Grid instance.\n     * @param {Grid.view.SubGrid} event.subGrid The subgrid\n     * @param {Event} event.domEvent The native DOM event\n     */\n    @Output() onSplitterExpandClick: any = new EventEmitter<((event: { source: Grid, subGrid: SubGrid, domEvent: Event }) => Promise<boolean>|boolean|void)|string>();\n    /**\n     * Fires on the owning Grid when editing starts\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {CellEditorContext} event.editorContext Editing context\n     */\n    @Output() onStartCellEdit: any = new EventEmitter<((event: { source: Grid, editorContext: CellEditorContext }) => void)|string>();\n    /**\n     * Fires on the owning Grid when editing starts\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source Owner grid\n     * @param {RowEditorContext} event.editorContext Editing context\n     */\n    @Output() onStartRowEdit: any = new EventEmitter<((event: { source: Grid, editorContext: RowEditorContext }) => void)|string>();\n    /**\n     * Fires after a sub grid is collapsed.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance\n     * @param {Grid.view.SubGrid} event.subGrid The sub grid instance\n     */\n    @Output() onSubGridCollapse: any = new EventEmitter<((event: { source: Grid, subGrid: SubGrid }) => void)|string>();\n    /**\n     * Fires after a sub grid is expanded.\n     * @param {object} event Event object\n     * @param {Grid.view.Grid} event.source The firing Grid instance\n     * @param {Grid.view.SubGrid} event.subGrid The sub grid instance\n     */\n    @Output() onSubGridExpand: any = new EventEmitter<((event: { source: Grid, subGrid: SubGrid }) => void)|string>();\n    /**\n     * Fired when one or more groups are expanded or collapsed\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.groupRecord [DEPRECATED] Use `groupRecords` param instead\n     * @param {Core.data.Model[]} event.groupRecords The group records being toggled\n     * @param {boolean} event.collapse Collapsed (true) or expanded (false)\n     * @param {boolean} event.allRecords True if this event is part of toggling all groups\n     */\n    @Output() onToggleGroup: any = new EventEmitter<((event: { groupRecord: Model, groupRecords: Model[], collapse: boolean, allRecords?: boolean }) => void)|string>();\n    /**\n     * Fired after a parent node record toggles its collapsed state.\n     * @param {object} event Event object\n     * @param {Core.data.Model} event.record The record being toggled.\n     * @param {boolean} event.collapse `true` if the node is being collapsed.\n     */\n    @Output() onToggleNode: any = new EventEmitter<((event: { record: Model, collapse: boolean }) => void)|string>();\n    /**\n     * A header [tool](https://bryntum.com/products/grid/docs/api/Core/widget/Panel#config-tools) has been clicked.\n     * @param {object} event Event object\n     * @param {Core.widget.Tool} event.source This Panel.\n     * @param {Core.widget.Tool} event.tool The tool which is being clicked.\n     */\n    @Output() onToolClick: any = new EventEmitter<((event: { source: Tool, tool: Tool }) => void)|string>();\n    /**\n     * Fires when row locking is disabled.\n     * @param {object} event Event object\n     * @param {Grid.view.GridBase} event.clone The locked clone that will be destroyed\n     */\n    @Output() onUnlockRows: any = new EventEmitter<((event: { clone: GridBase }) => void)|string>();\n    /**\n     * Fires when un-splitting the Grid.\n     */\n    @Output() onUnsplit: any = new EventEmitter<(() => 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            } = BryntumGridComponent;\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 } = BryntumGridComponent;\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 } = BryntumGridComponent;\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"]}