@motifx-community/ui 0.0.0-stage → 0.1.0-beta.0

package/dist/components/datagrid/DataGrid.d.ts

@@ -0,0 +1,1194 @@
+import { type Bind, type Event as MotifEvent, type IBaseProp } from '@motifx/core';
+import { data } from '@motifx-community/data';
+import { Control } from '../../core/control';
+import type { ColumnFeatures } from './column-features';
+import type { ColumnOptionName } from './column-option-name';
+import type { GridCellClickEventArgs } from './grid-cell-click-event-args';
+import type { GridColumn } from './grid-column';
+import type { GridCellPreparedEventArgs } from './grid-cell-prepared-event-args';
+import type { GridContentReadyEventArgs } from './grid-content-ready-event-args';
+import type { GridContextMenuPreparingEventArgs } from './grid-context-menu-preparing-event-args';
+import type { GridCopyingEventArgs } from './grid-copying-event-args';
+import type { GridDataErrorEventArgs } from './grid-data-error-event-args';
+import type { GridEditCanceledEventArgs } from './grid-edit-canceled-event-args';
+import type { GridEditCancelingEventArgs } from './grid-edit-canceling-event-args';
+import type { GridEditingCell } from './grid-editing-cell';
+import type { GridEditingStartEventArgs } from './grid-editing-start-event-args';
+import type { GridExportedEventArgs } from './grid-exported-event-args';
+import type { GridExportingEventArgs } from './grid-exporting-event-args';
+import type { GridFilterChangedEventArgs } from './grid-filter-changed-event-args';
+import type { GridFilterChangingEventArgs } from './grid-filter-changing-event-args';
+import type { GridFocusedCellChangedEventArgs } from './grid-focused-cell-changed-event-args';
+import type { GridFocusedCellChangingEventArgs } from './grid-focused-cell-changing-event-args';
+import type { GridFocusedRowChangedEventArgs } from './grid-focused-row-changed-event-args';
+import type { GridFocusedRowChangingEventArgs } from './grid-focused-row-changing-event-args';
+import type { GridInitNewRowEventArgs } from './grid-init-new-row-event-args';
+import type { GridKeyHandlingEventArgs } from './grid-key-handling-event-args';
+import type { GridLayoutChangingEventArgs } from './grid-layout-changing-event-args';
+import type { GridOptionChangedEventArgs } from './grid-option-changed-event-args';
+import type { GridMoreRowsLoadedEventArgs } from './grid-more-rows-loaded-event-args';
+import type { GridMoreRowsLoadingEventArgs } from './grid-more-rows-loading-event-args';
+import type { GridPageChangedEventArgs } from './grid-page-changed-event-args';
+import type { GridPageChangingEventArgs } from './grid-page-changing-event-args';
+import type { GridPageSizeChangedEventArgs } from './grid-page-size-changed-event-args';
+import type { GridPageSizeChangingEventArgs } from './grid-page-size-changing-event-args';
+import type { GridPastingEventArgs } from './grid-pasting-event-args';
+import type { GridRowClickEventArgs } from './grid-row-click-event-args';
+import type { GridRowInsertedEventArgs } from './grid-row-inserted-event-args';
+import type { GridRowInsertingEventArgs } from './grid-row-inserting-event-args';
+import type { GridRowPreparedEventArgs } from './grid-row-prepared-event-args';
+import type { GridRowRemovedEventArgs } from './grid-row-removed-event-args';
+import type { GridRowRemovingEventArgs } from './grid-row-removing-event-args';
+import type { GridRowUpdatedEventArgs } from './grid-row-updated-event-args';
+import type { GridRowUpdatingEventArgs } from './grid-row-updating-event-args';
+import type { GridSavedEventArgs } from './grid-saved-event-args';
+import type { GridSavingEventArgs } from './grid-saving-event-args';
+import type { GridSearchTextChangingEventArgs } from './grid-search-text-changing-event-args';
+import type { GridSelectionChangingEventArgs } from './grid-selection-changing-event-args';
+import type { GridSortChangedEventArgs } from './grid-sort-changed-event-args';
+import type { GridSortChangingEventArgs } from './grid-sort-changing-event-args';
+import type { GridSummary } from './grid-summary';
+import type { GridSummaryChangedEventArgs } from './grid-summary-changed-event-args';
+import type { GridStateValue } from './grid-state-value';
+import type { GridToolbarPreparingEventArgs } from './grid-toolbar-preparing-event-args';
+import type { GridVisibleRow } from './grid-visible-row';
+import type { DataGridProps } from './data-grid-props';
+import type { GridActionRanEventArgs } from './grid-action-ran-event-args';
+import type { GridActionRunningEventArgs } from './grid-action-running-event-args';
+import type { GridBarAction } from './grid-bar-action';
+import type { GridBuiltInActions } from './grid-built-in-actions';
+import type { GridChanges } from './grid-changes';
+import type { GridEditForm } from './grid-edit-form';
+import type { GridEditPopup } from './grid-edit-popup';
+import type { GridMasterDetail } from './grid-master-detail';
+import type { GridAdaptiveDetail } from './grid-adaptive-detail';
+import type { GridAdaptiveDetailRowPreparingEventArgs } from './grid-adaptive-detail-row-preparing-event-args';
+import type { GridAdaptiveRowExpandedEventArgs } from './grid-adaptive-row-expanded-event-args';
+import type { GridAdaptiveRowExpandingEventArgs } from './grid-adaptive-row-expanding-event-args';
+import type { GridColumnItem } from './grid-column-item';
+import type { GridEditorPreparedEventArgs } from './grid-editor-prepared-event-args';
+import type { GridEditorPreparingEventArgs } from './grid-editor-preparing-event-args';
+import type { GridRowValidatingEventArgs } from './grid-row-validating-event-args';
+import type { GridExportOptions } from './grid-export-options';
+import type { GridExportSettings } from './grid-export-settings';
+import type { GridSheet } from './grid-sheet';
+import type { GridSheetOptions } from './grid-sheet-options';
+import type { GridFilters } from './grid-filters';
+import type { GridGroupDroppingEventArgs } from './grid-group-dropping-event-args';
+import type { GridGroupingChangedEventArgs } from './grid-grouping-changed-event-args';
+import type { GridGroupingChangingEventArgs } from './grid-grouping-changing-event-args';
+import type { GridLayout } from './grid-layout';
+import type { GridRowExpandedEventArgs } from './grid-row-expanded-event-args';
+import type { GridRowExpandingEventArgs } from './grid-row-expanding-event-args';
+import type { GridSearchTextChangedEventArgs } from './grid-search-text-changed-event-args';
+import type { GridSelection } from './grid-selection';
+import type { GridSelectionChangedEventArgs } from './grid-selection-changed-event-args';
+import type { GridSettings } from './grid-settings';
+import type { GridToolbar as GridToolbarOptions } from './grid-toolbar';
+import type { GridRowDragging } from './grid-row-dragging';
+import type { GridCellPoint } from './grid-cell-point';
+import type { GridCellRange } from './grid-cell-range';
+import type { GridCellSelectionChangedEventArgs } from './grid-cell-selection-changed-event-args';
+import type { GridCellSelectionChangingEventArgs } from './grid-cell-selection-changing-event-args';
+import type { GridCellSummary } from './grid-cell-summary';
+import type { GridCellValue } from './grid-cell-value';
+import type { FilterBuilder } from '../filterbuilder/FilterBuilder';
+import type { GridFilterBuilderClosedEventArgs } from './grid-filter-builder-closed-event-args';
+import type { GridFilterBuilderClosingEventArgs } from './grid-filter-builder-closing-event-args';
+import type { GridFilterBuilderOpenedEventArgs } from './grid-filter-builder-opened-event-args';
+import type { GridFilterBuilderOpeningEventArgs } from './grid-filter-builder-opening-event-args';
+import type { GridFilterBuilderOptions } from './grid-filter-builder-options';
+import type { GridFilterBuilderPopup } from './grid-filter-builder-popup';
+/**
+ * A data grid: rows in memory or from the data layer (any adapter), shown as one virtual list or in
+ * pages. Columns can be sorted, resized, moved, hidden and pinned; cells are edited in place with the
+ * kit's editors, rows are added (Tab on the last cell of a new row opens the next one) and deleted,
+ * and changes are saved through a `ChangeTracker` row by row (waiting or in the background) or all
+ * together. Rows carry their own action buttons (those that do not fit go into a "more" menu), can be
+ * selected one, several or all (also over data never loaded), and are filtered from a filter row, from
+ * value lists in the headers and from a search box that looks in every column at once (the text found
+ * is marked). Rows can be grouped, with summaries in the group rows and footers, and totals in a
+ * row under the rows. A toolbar above the rows holds the grid's own commands and the app's. The grid is a
+ * single tab stop navigated with the arrow keys. Every feature can be turned off, for the whole grid
+ * (`settings`) or per column, also while it is shown.
+ *
+ * @example
+ * <DataGrid rows={() => this.orders} rowKey="id" columns={columns} settings={{ editable: true }} />
+ *
+ * const grid = new DataGrid<Order>({ dataSource: orders, columns, saveMode: 'background', settings: { editable: true, addRows: true } });
+ * this.panel.controls.add(grid);
+ * grid.addRow();
+ */
+export declare class DataGrid<T = any> extends Control<HTMLDivElement, DataGridProps<T>> {
+    private readonly model;
+    private readonly header;
+    /** The rows of band headers above the header. */
+    private readonly bands;
+    private readonly filterRow;
+    private readonly body;
+    /** Rows dragged to another place, or to another grid (`rowDragging`), and moved with the keys. */
+    private readonly rowDrag;
+    /** Rows and cell ranges selected by dragging over them. */
+    private readonly dragSelect;
+    /** The active cell when the last press in the rows came, before it moved there: a Shift+click range starts from it. */
+    private pressFrom;
+    /** A row drag selection: the selection before it (Escape puts it back), and whether its rows are selected or taken out. */
+    private rowDragBefore;
+    private rowDragOn;
+    /** The selected cells' summary, and what it was worked out for. */
+    private cellSummaryCache;
+    private readonly totalRow;
+    private readonly pager;
+    private readonly menu;
+    private readonly headerFilter;
+    private readonly moreMenu;
+    private readonly conditionMenu;
+    private readonly widths;
+    private readonly builtIns;
+    private readonly toolbarSwitches;
+    private readonly topBar;
+    private readonly groupPanel;
+    private readonly styles;
+    private readonly tip;
+    private readonly clipboard;
+    private readonly exporter;
+    /** Exports running, stopped when the grid goes away. */
+    private readonly exports;
+    private readonly exportSwitches;
+    /** The panel over the rows while an export with `loadPanel` runs, or an action works on several rows. */
+    /** Stops following the options given as functions (see `followGiven`). */
+    private stopGiven;
+    /** The panel of a long export or action: plain, drawn again (`drawShell`) where it changes. */
+    private readonly exportPanel;
+    private stopPanelExport;
+    private readonly runner;
+    /** The actions of the target rows in the bottom bar, on a kit toolbar of their own. */
+    private readonly bottomBar;
+    private readonly bottomActions;
+    /** "Export selected rows" was chosen for a format the app writes: its next `exportSheet()` takes the selection. */
+    private selectedNext;
+    private readonly gridId;
+    private viewportEl;
+    private headEl;
+    private footEl;
+    private probeEl;
+    private measureEl;
+    /** Which button of the active actions cell has focus. */
+    private actionIndex;
+    private tabbable;
+    private editor;
+    /** The row and field the open editor belongs to. */
+    private editTarget;
+    /** Id of the active row (follows a new row when rows above it come or go). */
+    private activeRowId;
+    /** A row the user left with messages (focus went elsewhere); adding a row goes back to it first. */
+    private pendingInvalid;
+    /** Stops following a `searchText` function. */
+    private stopSearchBinding;
+    /** A key `onKeyHandling` cancelled: the grid leaves it alone. */
+    private skippedKey;
+    /** The row being edited in the edit form (`editMode` `'form'`, `'popup'`), and the window it is in. */
+    private formEdit;
+    private readonly formSwitches;
+    private readonly popupSwitches;
+    /** The filter panel under the rows, the filter builder's window and its options. */
+    private readonly filterPanel;
+    private readonly builderWindow;
+    private readonly builderOptions;
+    private readonly builderPopupSwitches;
+    /** Bumped when texts of lookup keys arrive: the panel's text reads them. */
+    private readonly lookupTexts;
+    /** Stops following a `filterValue` or a `filterEnabled` function. */
+    private stopFilterValueBinding;
+    private stopFilterEnabledBinding;
+    /** The ready `remove` was confirmed for the rows it runs on: `deleteRow` does not ask again. */
+    private deleteConfirmed;
+    /** What follows the functions of a column (`groupIndex`, `filterValues`, `filterType`), by field. */
+    private readonly columnWatches;
+    /** `beginUpdate()` calls not ended yet, and whether the body waits to be laid out. */
+    private updates;
+    private relayoutWaiting;
+    /** While columns are virtual: how long drawing the columns that came into view took last (ms), and the wait for the sideways scrolling to stop. */
+    private columnsTook;
+    private columnsTimer;
+    constructor(props: IBaseProp<DataGridProps<T>>);
+    /** The toolbar and the bottom bar as the grid is now. */
+    private drawBars;
+    get label(): string;
+    set label(value: Bind<string>);
+    /** The feature switches, live: `grid.settings.resizable = false`; a function is followed. */
+    get settings(): GridSettings;
+    /**
+     * The bar above the rows, live: `grid.toolbar.items = ['searchPanel', { text: 'Refresh', click }]`;
+     * a function is followed. `visible` left out shows the bar while it has an item.
+     */
+    get toolbar(): GridToolbarOptions;
+    /**
+     * What the toolbar's export button offers, live: `grid.export.formats = ['xlsx', 'csv']`; a
+     * function is followed.
+     */
+    get export(): GridExportSettings;
+    /** The edit form of `editMode` `'form'` and `'popup'`, live: `grid.form.colCount = 3`; a function is followed. */
+    get form(): GridEditForm;
+    /** The window of `editMode: 'popup'`, live: `grid.popup.width = '40rem'`; a function is followed. */
+    get popup(): GridEditPopup;
+    /**
+     * One column's own feature switches, live. A value set here wins over `settings`; `undefined`
+     * follows `settings` again.
+     * @example grid.columnSettings('amount').movable = false;
+     */
+    columnSettings(field: string): Partial<ColumnFeatures>;
+    /** The source the rows come from: the one given, or the one the grid made for `rows`. */
+    get dataSource(): data.DataSource<T, unknown>;
+    /** The unsaved changes of the rows; listen to it, or read it, as any `ChangeTracker`. */
+    get changeTracker(): data.ChangeTracker<T, unknown>;
+    /** Data rows (0 while the first answer is loading), saved new rows included. Reactive. */
+    get total(): number;
+    /** True until the first rows arrive, and again after the sort changes, until they are there. Reactive. */
+    get loading(): boolean;
+    /** The sort order. Assigning replaces it and goes back to the first row. */
+    get sort(): data.SortItem[];
+    set sort(sort: data.SortItem[]);
+    /** The page shown (paged mode), 0-based. Infinite mode: the last part shown; assigning loads the parts up to that one and scrolls to its first row. */
+    get page(): number;
+    set page(page: number);
+    /** Pages in paged mode (at least 1); in infinite mode the parts of every row once their count is known, else the parts shown. Reactive. */
+    get pageCount(): number;
+    /**
+     * Infinite mode: shows the next part of the rows (`pageSize` more), after `onMoreRowsLoading`;
+     * `false` while the rows load, a part is loading or failed (`retry()`), or every row shows.
+     */
+    loadMore(): boolean;
+    /** Infinite mode: a part of the rows is loading. Reactive. */
+    get loadingMore(): boolean;
+    /** Every row shows: always outside infinite mode, there once the last part came. Reactive. */
+    get endReached(): boolean;
+    /** The page shown, 0-based; with a number, goes there (as `page` does). */
+    pageIndex(): number;
+    pageIndex(page: number): void;
+    /**
+     * Rows per page in paged mode, 0 for every row on one page; with a number, shows that many, as the
+     * pager's page sizes do (`onPageSizeChanging` may keep the old size): back to the first page, and
+     * the size is kept with the layout (`layoutKey`).
+     */
+    pageSize(): number;
+    pageSize(size: number): void;
+    /** Data rows of every page, saved new rows included: the same as `total`. Infinite mode: every matching row once known (counted, or the end reached), -1 until then. Reactive. */
+    totalCount(): number;
+    /** Column order, widths, visibility, sticky sides and sort. Store it and assign it back later, or give the grid a `layoutKey`. */
+    get layout(): GridLayout;
+    set layout(layout: GridLayout);
+    /** The row of the active cell; `undefined` on the header or while it loads. */
+    get activeRow(): T | undefined;
+    get activeField(): string;
+    /** Whether there are unsaved changes (edited, new or deleted rows). Reactive. */
+    get hasChanges(): boolean;
+    /** The unsaved changes: new rows, updated rows (the row itself and what changed) and deleted rows. */
+    get changes(): GridChanges<T>;
+    /** Rows whose save failed or that have messages to fix. Reactive. */
+    get errorCount(): number;
+    /** Back to the columns' own settings and the initial sort; with `layoutKey`, that is what is kept from now on. Filters stay. */
+    resetLayout(): void;
+    /**
+     * Loads the rows again, keeping the position, and the texts of the lookup columns; saved new rows
+     * leave the new-row area and take their place among the rows. Everything that shows the app's data
+     * is read again too (`repaint()`), and the summaries are worked out again.
+     */
+    refresh(): void;
+    /** Forgets the texts of the lookup columns and asks for the ones on the screen again. */
+    refreshLookups(): void;
+    /** Raised before a cell editor is made: change its props (`e.options`), or `e.cancel` the edit. */
+    get onEditorPreparing(): MotifEvent<GridEditorPreparingEventArgs<T>>;
+    /** Loads what failed to load again; in infinite mode a part that failed, after `onMoreRowsLoading`. */
+    retry(): void;
+    /** Scrolls row `index` into view (in paged mode, goes to its page). New rows count as rows. */
+    scrollToIndex(index: number, align?: 'nearest' | 'start' | 'end'): void;
+    /** Fits every visible, resizable column to its header and the rows shown. */
+    autoSizeColumns(): void;
+    /** Moves keyboard focus to the active cell. */
+    focus(): boolean;
+    /**
+     * Opens a new row, as the "New row" button does: at the bottom (the grid goes to the end; in a
+     * virtual list only the last block is loaded) or at the top, with its first cell a new row can fill
+     * in edit mode. The row being edited is left first; when it cannot be left no row is added.
+     * `values` fill the new row as if typed.
+     */
+    addRow(values?: Partial<T>): Promise<boolean>;
+    /**
+     * Deletes a row (default: the active one) as the save mode says: `batch` marks it until
+     * `saveChanges()`, `wait` sends it and resolves when the answer is in, `background` sends it
+     * through the queue. A new row never saved is just dropped. With `confirmDelete` (and not in batch
+     * mode) the user is asked first. Resolves to `false` when it failed or was not confirmed.
+     */
+    deleteRow(row?: T): Promise<boolean>;
+    /**
+     * Deletes several rows in one save, as `deleteRow` does one: in `wait` and `background` they are
+     * sent together, in one request when the adapter saves in batches. The user is asked once.
+     * Resolves to `false` when a row failed or the deletion was not confirmed.
+     */
+    deleteRows(rows: readonly T[]): Promise<boolean>;
+    /** Takes back the deletion mark of a row (batch mode). */
+    restoreRow(row: T): void;
+    /**
+     * Sends every unsaved change: deleted rows, then updated rows, then new rows. The row being edited
+     * is included when it passes its checks. Rows the backend rejects keep their marks and messages.
+     */
+    saveChanges(): Promise<{
+        saved: number;
+        failed: number;
+    }>;
+    /** Drops every unsaved change: edits, new rows and deletion marks. */
+    discardChanges(): void;
+    /** Moves to the next row whose save failed or that has messages. Returns whether there was one. */
+    goToNextError(): boolean;
+    private on;
+    /** Raised after an editor was made, in a cell or in the edit form. */
+    get onEditorPrepared(): MotifEvent<GridEditorPreparedEventArgs<T>>;
+    /** Raised when a row is checked before it is saved: add messages to `e.errors`, or `e.isValid = false`. */
+    get onRowValidating(): MotifEvent<GridRowValidatingEventArgs<T>>;
+    /** Raised when a cell is clicked: `e.cancel` stops what the grid does with it (select, open or close a group, edit). */
+    get onCellClick(): MotifEvent<GridCellClickEventArgs<T>>;
+    /** Raised when a cell is double-clicked: `e.cancel` keeps its editor closed. */
+    get onCellDblClick(): MotifEvent<GridCellClickEventArgs<T>>;
+    /** Raised when a row is clicked, after its cell's event: `e.cancel` stops what the grid does with it. */
+    get onRowClick(): MotifEvent<GridRowClickEventArgs<T>>;
+    /** Raised when a row is double-clicked: `e.cancel` keeps the editor closed. */
+    get onRowDblClick(): MotifEvent<GridRowClickEventArgs<T>>;
+    /** Raised when a cell is drawn for a row: style it. The element is reused; set and clear what you change. */
+    get onCellPrepared(): MotifEvent<GridCellPreparedEventArgs<T>>;
+    /** Raised when a row is drawn: style it. The element is reused; set and clear what you change. */
+    get onRowPrepared(): MotifEvent<GridRowPreparedEventArgs<T>>;
+    /** Raised when rows arrived and are laid out. */
+    get onContentReady(): MotifEvent<GridContentReadyEventArgs>;
+    /** Raised when loading or saving fails. */
+    get onDataErrorOccurred(): MotifEvent<GridDataErrorEventArgs<T>>;
+    /** Raised before a cell editor opens: `e.cancel` keeps it closed. */
+    get onEditingStart(): MotifEvent<GridEditingStartEventArgs<T>>;
+    /** Raised before a new row opens: change `e.data` or `e.values`, or `e.cancel`. */
+    get onInitNewRow(): MotifEvent<GridInitNewRowEventArgs<T>>;
+    /** Raised before changes are sent: `e.cancel` keeps them unsent. */
+    get onSaving(): MotifEvent<GridSavingEventArgs<T>>;
+    /** Raised when the answer to a save came. */
+    get onSaved(): MotifEvent<GridSavedEventArgs<T>>;
+    /** Raised before a new row is sent: change `e.data`, or `e.cancel`. */
+    get onRowInserting(): MotifEvent<GridRowInsertingEventArgs<T>>;
+    /** Raised when a new row was saved. */
+    get onRowInserted(): MotifEvent<GridRowInsertedEventArgs<T>>;
+    /** Raised before a row's changes are sent: change `e.changes`, or `e.cancel`. */
+    get onRowUpdating(): MotifEvent<GridRowUpdatingEventArgs<T>>;
+    /** Raised when a row's changes were saved. */
+    get onRowUpdated(): MotifEvent<GridRowUpdatedEventArgs<T>>;
+    /** Raised before a row's deletion is sent: `e.cancel` keeps the row. */
+    get onRowRemoving(): MotifEvent<GridRowRemovingEventArgs<T>>;
+    /** Raised when a row was deleted on the backend. */
+    get onRowRemoved(): MotifEvent<GridRowRemovedEventArgs<T>>;
+    /** Raised before unsaved changes are dropped: `e.cancel` keeps them. */
+    get onEditCanceling(): MotifEvent<GridEditCancelingEventArgs<T>>;
+    /** Raised when unsaved changes were dropped. */
+    get onEditCanceled(): MotifEvent<GridEditCanceledEventArgs<T>>;
+    /** Raised before the active cell moves: `e.cancel` keeps it. */
+    get onFocusedCellChanging(): MotifEvent<GridFocusedCellChangingEventArgs<T>>;
+    /** Raised when the active cell moved. */
+    get onFocusedCellChanged(): MotifEvent<GridFocusedCellChangedEventArgs<T>>;
+    /** Raised before the active row changes: `e.cancel` keeps it. */
+    get onFocusedRowChanging(): MotifEvent<GridFocusedRowChangingEventArgs<T>>;
+    /** Raised when the active row changed. */
+    get onFocusedRowChanged(): MotifEvent<GridFocusedRowChangedEventArgs<T>>;
+    /** Raised when a key goes down in the grid, before the grid handles it: `e.cancel` stops the grid's handling. */
+    get onKeyHandling(): MotifEvent<GridKeyHandlingEventArgs>;
+    /** Raised when a setting of the grid, a column or the toolbar is assigned. */
+    get onOptionChanged(): MotifEvent<GridOptionChangedEventArgs>;
+    /** Raised before an export starts: change `e.options`, or `e.cancel`. */
+    get onExporting(): MotifEvent<GridExportingEventArgs>;
+    /** Raised when an export finished. */
+    get onExported(): MotifEvent<GridExportedEventArgs>;
+    /** Raised before a column menu or a row menu opens: change `e.items`, or `e.cancel`. */
+    get onContextMenuPreparing(): MotifEvent<GridContextMenuPreparingEventArgs<T>>;
+    /** Raised when the toolbar is laid out: change `e.items`. */
+    get onToolbarPreparing(): MotifEvent<GridToolbarPreparingEventArgs>;
+    /** Raised before the sort changes: `e.cancel` keeps it. */
+    get onSortChanging(): MotifEvent<GridSortChangingEventArgs>;
+    /** Raised when the sort changed. */
+    get onSortChanged(): MotifEvent<GridSortChangedEventArgs>;
+    /** Raised before the filters apply: `e.cancel` puts the ones before back. */
+    get onFilterChanging(): MotifEvent<GridFilterChangingEventArgs>;
+    /** Raised when the filters applied. */
+    get onFilterChanged(): MotifEvent<GridFilterChangedEventArgs>;
+    /** Raised before another page shows: `e.cancel` stays. */
+    get onPageChanging(): MotifEvent<GridPageChangingEventArgs>;
+    /** Raised when another page shows. */
+    get onPageChanged(): MotifEvent<GridPageChangedEventArgs>;
+    /** Raised before the rows per page change (the pager's page sizes, `pageSize(n)`): `e.cancel` keeps them. */
+    get onPageSizeChanging(): MotifEvent<GridPageSizeChangingEventArgs>;
+    get onPageSizeChanged(): MotifEvent<GridPageSizeChangedEventArgs>;
+    /** Infinite mode: raised before the next part of the rows loads (the view nears the end, `loadMore()`, Ctrl+End): `e.cancel` keeps the rows as they are. */
+    get onMoreRowsLoading(): MotifEvent<GridMoreRowsLoadingEventArgs>;
+    /** Infinite mode: raised when a part of the rows came. */
+    get onMoreRowsLoaded(): MotifEvent<GridMoreRowsLoadedEventArgs>;
+    /** Raised before a layout change by the user is kept: `e.cancel` puts the one before back. */
+    get onLayoutChanging(): MotifEvent<GridLayoutChangingEventArgs>;
+    /** Raised after the user changed the layout. */
+    get onLayoutChange(): MotifEvent<GridLayout>;
+    /** Raised before cells go to the clipboard: change `e.text` / `e.html`, or `e.cancel`. */
+    get onCopying(): MotifEvent<GridCopyingEventArgs>;
+    /** Raised before text is pasted: change `e.text`, or `e.cancel`. */
+    get onPasting(): MotifEvent<GridPastingEventArgs>;
+    /** `'loading'` until the rows arrive (again after a new query), `'error'` when the load failed, else `'ready'`. Reactive. */
+    get status(): 'loading' | 'ready' | 'error';
+    /** The error of the last load, or `null`. Reactive. */
+    get loadError(): data.DataError | null;
+    /** Blocks of rows that failed to load after the first answer; `retry()` loads them again. Reactive. */
+    get failedBlocks(): number;
+    /** The cell whose editor is open, or `null`. Reactive. */
+    get editingCell(): GridEditingCell<T> | null;
+    /** A row is being saved and the grid waits for it (`wait` mode); keys and clicks wait too. Reactive. */
+    get saving(): boolean;
+    /** An export is running. Reactive. */
+    get exporting(): boolean;
+    /** The active row's index (new rows count; -1 the header, -2 the filter row). Assigning moves there. */
+    get focusedRowIndex(): number;
+    set focusedRowIndex(index: number);
+    /** The active row's key; `undefined` on the header, a group row or a new row. Assigning goes to the row with that key, when it is loaded. */
+    get focusedRowKey(): unknown;
+    set focusedRowKey(key: unknown);
+    /** The rows drawn now (the ones in view, and the active one wherever it is), in order. */
+    getVisibleRows(): GridVisibleRow<T>[];
+    /** The element of grid row `rowIndex` while it is drawn. */
+    getRowElement(rowIndex: number): HTMLElement | undefined;
+    /** The element of a cell while its row is drawn; a group row's one cell for any field. */
+    getCellElement(rowIndex: number, field: string): HTMLElement | undefined;
+    /** The key of grid row `rowIndex`; `undefined` for a new row, a group row, the header or a row still loading. */
+    getKeyByRowIndex(rowIndex: number): unknown;
+    /** The grid index of the row with this key while it is loaded (rows in memory: always), else -1. */
+    getRowIndexByKey(key: unknown): number;
+    /** The row with this key: a loaded one, one found before, or asked of the data source. */
+    byKey(key: unknown): Promise<T | undefined>;
+    /**
+     * The value a cell shows (its unsaved edit when there is one). With `value`, writes it as the user
+     * would: into the row's draft, checked, and sent as the save mode says (batch: on `saveChanges()`).
+     */
+    cellValue(rowIndex: number, field: string, value?: unknown): unknown;
+    /**
+     * Goes to the row with this key (its page in paged mode) and makes it the active row; focus moves
+     * along only while the grid has it. Resolves to whether the row was found among the loaded rows.
+     */
+    navigateToRow(key: unknown): Promise<boolean>;
+    /** Moves the active cell and focus to a cell, as the arrow keys do (leaving an edited row saves it first). Returns whether it moved. */
+    focusCell(rowIndex: number, field?: string): boolean;
+    /** Opens a cell's editor, as Enter does. Returns whether the move to it could start. */
+    editCell(rowIndex: number, field: string): boolean;
+    /** Opens the editor of a row's first cell the user can fill; with `editMode` `'form'` or `'popup'`, the row's edit form. */
+    editRow(rowIndex: number): boolean;
+    /** `editRow` for the row with this key, while it is loaded. */
+    editRowByKey(key: unknown): boolean;
+    /**
+     * Saves what is being edited, as Save does: the edit form, else the row being edited (as the save
+     * mode says); in batch mode every unsaved change (`saveChanges()`). Resolves to whether it worked.
+     */
+    saveEditData(): Promise<boolean>;
+    /** Gives up what is being edited, as Cancel does: the edit form or the row being edited; in batch mode every unsaved change (`discardChanges()`). */
+    cancelEditData(): void;
+    /**
+     * Keeps the open editor's value and closes it (the row stays the edited one until it is left; in
+     * `'cell'` mode it is saved). In the edit form, keeps every field's value. `false` when a value cannot be read.
+     */
+    closeEditCell(): boolean;
+    /** Starts changes made from code together: the rows are laid out once, at the last `endUpdate()`. */
+    beginUpdate(): void;
+    endUpdate(): void;
+    /**
+     * Draws again what shows the app's data, without loading: the rows, their details and adaptive
+     * detail, the group rows and footers, the totals, the bars and their actions. Your data may be
+     * plain or reactive; the grid reads it as it is, so after changing it in place call this (or
+     * `repaintRows(keys)` for some rows, `refresh()` to load again).
+     */
+    /**
+     * What `reState()` does here: the options given (the grid's, its parts', the columns') are read again, and
+     * what shows the app's data is drawn again (`repaint()`). Nothing is loaded.
+     */
+    private readGivenAgain;
+    /** Every set of options the grid was given: its own, its parts', each column's. */
+    private givenHolders;
+    /**
+     * The options given as functions (`actionsWidth: () => state.width`) are the developer's live values: followed here
+     * together (a reactive source by itself, plain data on `reState()`); a value that changed touches its key, and the grid
+     * tells it. Made again when the columns change, each column having its own.
+     */
+    private followGiven;
+    repaint(): void;
+    /** Draws again the rows with these keys (and their details), after their data was changed in place; the other rows stay as they are. */
+    repaintRows(keys: readonly unknown[]): void;
+    /** Asks every row and bar for its actions again: what the `actions` function, an action's `visible` or `disabled` reads was changed in place. */
+    refreshActions(): void;
+    /** The whole filter of the rows: the source's own, the filter row, the header filters and the search. Reactive. */
+    getCombinedFilter(): data.FilterExpression | null;
+    /**
+     * Adds a column, at `index` among the data columns (default: last), as the user would see it after
+     * the ones given: its width, visibility and sticky side, or what the kept layout says of it; its
+     * `groupIndex` groups the rows by it. A band comes with its columns; a column with `ownerBand`
+     * goes into that band. The layout and the kept layout follow.
+     */
+    addColumn(column: GridColumnItem<T>, index?: number): void;
+    /** Takes a column out: its sort, grouping and filter go with it (without `…Changing` events), and the layout follows. */
+    deleteColumn(field: string): void;
+    /** The data columns, the hidden ones too. */
+    columnCount(): number;
+    /** The definitions of the data columns shown now, in display order, those the width hides too (`adaptiveHiddenColumns`). Reactive. */
+    getVisibleColumns(): GridColumn<T>[];
+    /**
+     * An option of a column, read or written: its layout (`width`, `visible` or `hidden`, `flex`,
+     * `sticky`, `visibleIndex` among the visible columns), sort (`sortOrder`, `sortIndex`),
+     * `groupIndex`, its header filter (`filterValues`, `filterType`), a feature switch (`sortable`,
+     * `resizable` …, as `columnSettings` has them) or any other field of its definition (`title`,
+     * `format`, `lookup`, `cell` …; the column is drawn again with it). Without a name: all of them.
+     * An object sets several at once.
+     */
+    columnOption(field: string): Record<string, unknown>;
+    columnOption(field: string, name: ColumnOptionName): unknown;
+    columnOption(field: string, name: ColumnOptionName, value: unknown): void;
+    columnOption(field: string, options: Partial<Record<ColumnOptionName, unknown>>): void;
+    /** `columnOption` of a band: `visible` / `hidden`, `sticky`, `visibleIndex` among the columns and bands beside it, `title`, its feature switches. */
+    private bandOption;
+    /** Other fields of a column's definition: the column is made again with them, its layout, sort and filter kept. */
+    private changeDefinition;
+    /** A column's cells in every row, header and bar. */
+    private placeColumn;
+    private removeCells;
+    /**
+     * Follows a column's own functions: a new `groupIndex` moves the column in the grouping, none
+     * ungroups it; new `filterValues` or `filterType` filter it again.
+     */
+    private watchColumn;
+    private stopWatching;
+    /** What the user set up: the layout (columns, sort, grouping), filters, search text, page and page size, selection and active row. */
+    state(): GridStateValue;
+    /** Puts a state back (parts left out stay as they are). */
+    state(value: Partial<GridStateValue>): void;
+    /** The grid's ready actions, to put in `actions` or to call: `grid.actions.remove`. */
+    get actions(): GridBuiltInActions<T>;
+    /**
+     * The rows the toolbar's and the bottom bar's actions act on now (`actionsTarget`): the selected
+     * rows or the active one. Empty for nothing, and for a selection whose rows are not loaded (read
+     * `selection` then). Reactive.
+     */
+    get actionTargets(): T[];
+    /** The actions the toolbar and the bottom bar show now, for those rows. Reactive. */
+    get barActions(): GridBarAction<T>[];
+    /**
+     * Runs an action from code, as a press does: on `rows`, or on the rows the bars act on now. Rows
+     * share an action by its `id`; it runs only where it is visible and enabled for them. Resolves to
+     * the outcome, or `null` when the action is not there or `onActionRunning` cancelled it.
+     */
+    runAction(id: string, rows?: readonly T[]): Promise<GridActionRanEventArgs<T> | null>;
+    /** Stops the action working on several rows (the rows not started are left). */
+    stopAction(): void;
+    /** Raised before an action runs (in a row, a bar, a row's menu or from code): `e.cancel` keeps it from running. */
+    get onActionRunning(): MotifEvent<GridActionRunningEventArgs<T>>;
+    /** Raised when an action ran: on how many rows it worked or failed, and whether it was stopped. */
+    get onActionRan(): MotifEvent<GridActionRanEventArgs<T>>;
+    /** The selection as a state: rows one by one, or every row of a filter but some. Reactive. */
+    get selection(): GridSelection;
+    /** Raised whenever the selection changes. */
+    get onSelectionChanged(): MotifEvent<GridSelectionChangedEventArgs>;
+    /** Raised before the selection changes (by the user or by code): `e.cancel` keeps it. */
+    get onSelectionChanging(): MotifEvent<GridSelectionChangingEventArgs>;
+    /** Selected rows. Reactive. With "all" selected, the total of the filter less the rows taken out. */
+    get selectedCount(): number;
+    /**
+     * Keys of the selected rows. With "all" selected over data that loads in parts, only the rows
+     * loaded now are known: read `selection` for the whole state. Assign to select exactly these rows.
+     */
+    get selectedKeys(): unknown[];
+    set selectedKeys(keys: readonly unknown[]);
+    /** The selected rows that are loaded (rows in memory: all of them). */
+    get selectedRows(): T[];
+    /**
+     * The selection as a filter of the data layer, for work on the server: the selected keys, or the
+     * filter of "all" without the rows taken out. `undefined` when nothing is selected or the key is
+     * not one field.
+     */
+    get selectionFilter(): data.FilterExpression | null | undefined;
+    isSelected(row: T): boolean;
+    /** Selects a row; `add` keeps the rows selected before (multiple selection). */
+    selectRow(row: T, add?: boolean): void;
+    deselectRow(row: T): void;
+    /** Selects every row of the current filter (multiple selection), loaded or not. */
+    selectAll(): void;
+    clearSelection(): void;
+    /**
+     * The cell ranges (`settings.cellSelection`), each from the cell it was started on to its far
+     * corner, by row key and field. Reactive. Assign to set them (`[]` clears them); a range whose
+     * corner names no row or column is left out.
+     */
+    get cellRanges(): GridCellRange[];
+    set cellRanges(ranges: readonly GridCellRange[]);
+    /** Raised before the cell ranges change (by the user or by code): `e.cancel` keeps them. */
+    get onCellSelectionChanging(): MotifEvent<GridCellSelectionChangingEventArgs>;
+    /** Raised whenever the cell ranges change; `e.byDrag` while one is drawn with the pointer. */
+    get onCellSelectionChanged(): MotifEvent<GridCellSelectionChangedEventArgs>;
+    /**
+     * Selects the cells from `from` to `to` (one cell when it is left out), in place of the ranges
+     * there are, or after them (`add`, with `cellSelection: 'multiple'`). Returns whether it shows.
+     */
+    selectCells(from: GridCellPoint, to?: GridCellPoint, add?: boolean): boolean;
+    clearCellSelection(): void;
+    /** The selected cells of the rows loaded, each once, row by row in the grid's order, with their values (unsaved edits included). */
+    getSelectedCellValues(): GridCellValue<T>[];
+    /** The count, sum, average, smallest and largest of the selected cells (rows loaded only), as a spreadsheet's status bar. Reactive. */
+    get cellSelectionSummary(): GridCellSummary;
+    /** The filters by field (filter row and header filter). Assign to replace them; `{}` clears them. */
+    get filters(): GridFilters;
+    set filters(filters: GridFilters);
+    /** The whole filter of the rows, as the data layer has it: the source's own and the grid's. Reactive. */
+    get filter(): data.FilterExpression | null;
+    /** Takes every filter away: the filter row's and header filters', the filter value, the search text (the conditions chosen in the filter row stay). */
+    clearFilters(): void;
+    /**
+     * The filter value, as the data layer has it: the filter builder's conditions, and with
+     * `settings.filterSyncEnabled` the filter row's and header filters' too. Reactive. Assigning
+     * gives the conditions the filter row and header filters can show to them (with sync); a
+     * function is followed.
+     */
+    get filterValue(): data.FilterExpression | null;
+    set filterValue(value: Bind<data.FilterExpression | null>);
+    /** Whether the filter value applies (the filter panel's check box). Reactive; a function is followed. */
+    get filterEnabled(): boolean;
+    set filterEnabled(value: Bind<boolean>);
+    /** The filter value as the filter panel writes it: `[City] Equals 'Ankara' And …` with the columns' titles and texts. Reactive. */
+    get filterText(): string;
+    /** The filter builder the filter panel opens, live: `grid.filterBuilder.maxGroupLevel = 1`; a function is followed. */
+    get filterBuilder(): GridFilterBuilderOptions;
+    /** The window the filter builder opens in, live: `grid.filterBuilderPopup.width = '50rem'`; a function is followed. */
+    get filterBuilderPopup(): GridFilterBuilderPopup;
+    /** Opens the filter builder on the filter value, in its window; `false` when `onFilterBuilderOpening` kept it closed. */
+    openFilterBuilder(): boolean;
+    /** Closes the filter builder's window: with `apply`, as OK. `false` when it is not open or `onFilterBuilderClosing` kept it. */
+    closeFilterBuilder(apply?: boolean): boolean;
+    /** The filter builder while its window is open. */
+    get filterBuilderInstance(): FilterBuilder | null;
+    /** Takes the filter value away (the panel's Clear); with sync, the filter row's and header filters' filters too. The search stays. */
+    clearFilterValue(): void;
+    /** Raised before the filter builder opens: `e.cancel` keeps it closed. */
+    get onFilterBuilderOpening(): MotifEvent<GridFilterBuilderOpeningEventArgs>;
+    get onFilterBuilderOpened(): MotifEvent<GridFilterBuilderOpenedEventArgs>;
+    /** Raised before the filter builder closes, with OK (`e.apply`) or not: `e.cancel` keeps it open. */
+    get onFilterBuilderClosing(): MotifEvent<GridFilterBuilderClosingEventArgs>;
+    get onFilterBuilderClosed(): MotifEvent<GridFilterBuilderClosedEventArgs>;
+    private takeFilterValue;
+    /**
+     * The search panel's text: the rows shown hold it in a searchable column. Reactive. Assigning
+     * searches at once; a function is followed.
+     */
+    get searchText(): string;
+    set searchText(text: Bind<string>);
+    /** Searches for a text at once, as the search panel does after a typing pause; `''` stops searching. */
+    searchByText(text: string): void;
+    /** Raised when the search text changes: typed in the search box, or set from code. */
+    get onSearchTextChanged(): MotifEvent<GridSearchTextChangedEventArgs>;
+    /** Raised before the search text changes: `e.cancel` keeps the one before. */
+    get onSearchTextChanging(): MotifEvent<GridSearchTextChangingEventArgs>;
+    /** Opens the list of columns (show and hide), under the toolbar's column button when it shows. */
+    showColumnChooser(): void;
+    /**
+     * The grouped columns, in order, with the order of their groups: `[{ field: 'city', dir: 'asc' }]`.
+     * Assigning groups the rows by them (`[]` ungroups); a column grouped now leaves the sort.
+     */
+    get group(): data.GroupItem[];
+    set group(items: data.GroupItem[]);
+    /** Takes every grouping away. */
+    clearGrouping(): void;
+    /** Groups by a column, at a place among the grouped ones (default: last); a grouped column moves there. */
+    groupBy(field: string, index?: number, dir?: 'asc' | 'desc'): void;
+    /** Takes one column out of the grouping. */
+    ungroup(field: string): void;
+    /** Sets the order of a grouped column's groups. */
+    setGroupOrder(field: string, dir: 'asc' | 'desc'): void;
+    /** Raised before the grouping changes, by the user or from code: `e.cancel` keeps it. */
+    get onGroupingChanging(): MotifEvent<GridGroupingChangingEventArgs>;
+    /** Raised after the grouping changed. */
+    get onGroupingChanged(): MotifEvent<GridGroupingChangedEventArgs>;
+    /** Raised before a dropped header or chip changes the grouping: `e.cancel` cancels the drop. */
+    get onGroupDropping(): MotifEvent<GridGroupDroppingEventArgs>;
+    /** Opens every group of a level (0 is the top level), or of every level. */
+    expandAll(level?: number): void;
+    /** Closes every group of a level (0 is the top level), or of every level. */
+    collapseAll(level?: number): void;
+    /**
+     * Opens a group by its key: the values of the groups from the top level down (`['Ankara']`,
+     * `['Ankara', 'Draft']`). Returns whether it opened; a group not known yet (still loading) is not.
+     */
+    expandGroup(key: readonly unknown[]): boolean;
+    /** Closes a group by its key (see `expandGroup`). Returns whether it closed. */
+    collapseGroup(key: readonly unknown[]): boolean;
+    /** Whether a group is open, by its key (see `expandGroup`). */
+    isGroupExpanded(key: readonly unknown[]): boolean;
+    /** Raised before a group or a row's details open: `e.kind` says which, `e.key` is its key; `e.cancel` keeps it closed. */
+    get onRowExpanding(): MotifEvent<GridRowExpandingEventArgs>;
+    /** Raised after a group or a row's details opened. */
+    get onRowExpanded(): MotifEvent<GridRowExpandedEventArgs>;
+    /** Raised before a group or a row's details close: `e.cancel` keeps it open. */
+    get onRowCollapsing(): MotifEvent<GridRowExpandingEventArgs>;
+    /** Raised after a group or a row's details closed. */
+    get onRowCollapsed(): MotifEvent<GridRowExpandedEventArgs>;
+    /** The `masterDetail` options, live: `grid.masterDetail.enabled = true`; a function is followed, `onOptionChanged` tells `masterDetail.enabled` …. */
+    get masterDetail(): GridMasterDetail<T>;
+    /**
+     * Opens a row's details by its key, as its arrow does (`onRowExpanding` can keep them closed).
+     * Returns whether they opened; a row not loaded, or one without details, does not.
+     */
+    expandRow(key: unknown): boolean;
+    /** Closes a row's details by its key (see `expandRow`). Returns whether they closed. */
+    collapseRow(key: unknown): boolean;
+    /** Whether a row's details are open, by its key. Reactive. */
+    isRowExpanded(key: unknown): boolean;
+    /** Opens the details of every row (DevExtreme's `expandAll(-1)`); like `expandAll()` for groups it raises no row events. */
+    expandAllRows(): void;
+    /** Closes the details of every row. */
+    collapseAllRows(): void;
+    /**
+     * The `rowDragging` options, live: `grid.rowDragging.allowReordering = true`; a function is
+     * followed, handlers can be set too, `onOptionChanged` tells `rowDragging.allowReordering` ….
+     */
+    get rowDragging(): GridRowDragging<T>;
+    /**
+     * Moves grid row `fromIndex` to `toIndex` as dropping it there would (the keys that move a row do
+     * this): `onDragStart`, `onDragChange` and `onDragEnd` of `rowDragging`, any of which can cancel it,
+     * then `onReorder`, whose handler moves the data. Resolves to whether `onReorder` was raised.
+     */
+    moveRow(fromIndex: number, toIndex: number): Promise<boolean>;
+    /** The `adaptiveDetail` options, live: `grid.adaptiveDetail.colCount = 1`; a function is followed, `onOptionChanged` tells `adaptiveDetail.colCount` …. */
+    get adaptiveDetail(): GridAdaptiveDetail;
+    /** The columns the width hides now (`settings.columnHidingEnabled`, a column's `hidingPriority`), by field, in display order. Reactive. */
+    get adaptiveHiddenColumns(): string[];
+    /**
+     * Opens the adaptive detail of the row with this key, as its "…" does (the one open before
+     * closes; `onAdaptiveDetailRowExpanding` can keep it closed). Returns whether it opened: a row not
+     * loaded, or a grid with no column hidden, does not.
+     */
+    expandAdaptiveDetailRow(key: unknown): boolean;
+    /** Closes the adaptive detail that is open. Returns whether it closed. */
+    collapseAdaptiveDetailRow(): boolean;
+    /** Whether the row with this key has its adaptive detail open. Reactive. */
+    isAdaptiveDetailRowExpanded(key: unknown): boolean;
+    /** Raised when a row's adaptive detail lays out its form: change `e.formOptions`. */
+    get onAdaptiveDetailRowPreparing(): MotifEvent<GridAdaptiveDetailRowPreparingEventArgs<T>>;
+    /** Raised before a row's adaptive detail opens: `e.cancel` keeps it closed. */
+    get onAdaptiveDetailRowExpanding(): MotifEvent<GridAdaptiveRowExpandingEventArgs<T>>;
+    get onAdaptiveDetailRowExpanded(): MotifEvent<GridAdaptiveRowExpandedEventArgs<T>>;
+    /** Raised before a row's adaptive detail closes: `e.cancel` keeps it open. */
+    get onAdaptiveDetailRowCollapsing(): MotifEvent<GridAdaptiveRowExpandingEventArgs<T>>;
+    get onAdaptiveDetailRowCollapsed(): MotifEvent<GridAdaptiveRowExpandedEventArgs<T>>;
+    /**
+     * The summaries: `totalItems` in the row under the rows, `groupItems` in group rows and footers. A
+     * function is followed, and so is a function in a field of an item; after a change in place (an
+     * item's field, the items, the rows' values) call `refreshSummary()`.
+     */
+    get summary(): GridSummary<T>;
+    set summary(summary: Bind<GridSummary<T>>);
+    /**
+     * A value of the total summary: by the item's `name`, its place in `totalItems`, its type, its
+     * column or `type_column` (`'sum_amount'`); `undefined` while it is not known. Reactive.
+     */
+    getTotalSummaryValue(name: string | number): unknown;
+    /** A value of the group summary of the group with this key (see `expandGroup`), by the item as `getTotalSummaryValue` finds it. Reactive. */
+    getGroupSummaryValue(key: readonly unknown[], name: string | number): unknown;
+    /** `'loading'` while a server works out the totals (or every row loads for them), `'error'` when that failed. */
+    get summaryStatus(): 'loading' | 'ready' | 'error';
+    /** Reads the summary items again and works the values out again (after a change in place). */
+    refreshSummary(): void;
+    /** Raised when the summary values were worked out again. */
+    get onSummaryChanged(): MotifEvent<GridSummaryChangedEventArgs>;
+    /**
+     * Copies as Ctrl+C does: the cell ranges, else the selected rows of a multiple selection, else the
+     * active cell, as tab-separated text and an HTML table, with the copyable visible columns. Returns
+     * the text; `''` when there was nothing to copy.
+     */
+    copy(): string;
+    /**
+     * Pastes as Ctrl+V does: tab-separated text into the cells the user can fill, from the active cell
+     * (with cell ranges: from the last range's first cell) rightwards and downwards; one value alone
+     * fills every cell of the ranges. Values go into the rows' drafts and are checked like typed ones;
+     * rows other than the active one are saved as the save mode says. Returns the number of cells written.
+     */
+    paste(text: string): number;
+    /**
+     * The rows of the filter in the sort order, with the visible exportable columns in display order,
+     * as objects by field: the text the cells show, or their values (`values: 'raw'`). Rows in memory
+     * are taken as they are; a server's are asked for in parts (`pageSize`) through the data source.
+     * Group footers follow their rows and the row of totals comes last, as objects of the same fields
+     * with the texts they show (`summaries: false` leaves them out).
+     */
+    exportRows(options?: GridExportOptions): Promise<Record<string, unknown>[]>;
+    /**
+     * Saves the rows as `exportRows` collects them in a CSV file a spreadsheet opens as it is: UTF-8
+     * with a byte order mark, the locale's separator, column titles first. Returns the text.
+     */
+    exportCsv(options?: GridExportOptions): Promise<string>;
+    /**
+     * What a command of the toolbar's export button does: `'csv'` runs `exportCsv`; any other format
+     * raises `onExporting` with that `format` and `selectedRowsOnly`, and the app writes the file
+     * there (`exportDataGrid` of the `excel` entry for `'xlsx'`, of the `pdf` entry for `'pdf'`), as in DevExtreme.
+     */
+    exportTo(format: string, options?: GridExportOptions): Promise<void>;
+    /**
+     * The rows of an export as a sheet of typed cells (header, group rows, data rows, group footers,
+     * totals), handed to `write`, a file writer: `exportDataGrid` writes it to an ExcelJS worksheet.
+     * The rows load as `exportRows` loads them (in parts from a server, with progress, stopped by
+     * `signal` or the load panel's button). `onExported` follows with `format` once `write` is done.
+     * Raises no `onExporting`: this is what an `onExporting` handler calls.
+     */
+    exportSheet<R>(options: GridSheetOptions, write: (sheet: GridSheet<T>) => R | Promise<R>): Promise<R>;
+    /** Stops the export the load panel shows (its promise rejects with an `AbortError`). */
+    cancelExport(): void;
+    onConfigured(): void;
+    /** What the grid does when a part of its state is no longer what it was (see `whenChanged`). */
+    private readonly reactions;
+    /**
+     * Runs `run` now, then whenever one of the values `values` reads is not what it read last: checked on every turn the
+     * grid tells changes, before the views draw. Nothing is followed.
+     */
+    private whenChanged;
+    /** The grid's own element as the grid is now: its mode, look and state. */
+    private drawRoot;
+    /** Follows the data, lays the body out, and tells that the rows are there. */
+    private layOut;
+    onBuilt(): void;
+    onMounted(): void;
+    onDisposing(): void;
+    /** The grid's own parts around the rows, made once in `view` and drawn by `drawShell`. */
+    private shell;
+    view(): import("@motifx/core").FragmentNode<any>;
+    /** The grid's own parts as the grid is now: what the rows' box says of them, the states, the bar, the live regions. */
+    private drawShell;
+    /** Whether the bottom bar holds actions now. Reactive. */
+    private bottomShown;
+    /** Whether the toolbar or the bottom bar holds actions now. Reactive. */
+    private barShown;
+    private isRtl;
+    /** New rows that are saved (they count as data rows). */
+    private savedAdded;
+    /** Reads the viewport, header and row heights. */
+    private measure;
+    /**
+     * After the data changed: saved new rows the source now has leave the new-row area, the active row
+     * follows a new row that moved, and until the user moves, the active cell follows the data (first
+     * row when there is one, else the header).
+     */
+    private followData;
+    private activeElement;
+    /** The header of a column, or of a band. */
+    private headerCellOf;
+    /** Exactly one cell is in the tab order: the active one. */
+    private syncTabStop;
+    private setActive;
+    /** Asks `onFocusedRowChanging` and `onFocusedCellChanging` before the active cell moves; whether it may. */
+    private canMoveTo;
+    /** A setting a column may give for itself: its own value, else the grid's. */
+    private columnSetting;
+    /** The kind of grid row `i`. */
+    private rowTypeOf;
+    private focusActive;
+    /** The column the active cell is in (a band's first one), drawn even while it is out of view. */
+    private keptColumn;
+    /** Works out the columns that get cells (virtual columns); whether that changed. */
+    private findColumns;
+    /** Puts the cells of the header, the filter row, the rows and the totals in display order, with the columns drawn. */
+    private arrangeColumns;
+    /** While columns are virtual, the columns that came into view get their cells. */
+    private updateColumns;
+    /** The rows scrolled: virtual columns follow at once, or once the scrolling stops (`renderAsync`). */
+    private columnsScrolled;
+    /** Scrolls sideways so the column is not under the sticky columns. */
+    private revealColumn;
+    /** Focus leaves the grid: to the next (or previous) element in the Tab order outside the rows. */
+    private moveFocusOut;
+    /** Visible data fields the user can fill in grid row `i` (a new row: `creatable`, else `editable`), in display order. */
+    private editableFields;
+    /** Opens the editor of the active cell. `initialText` is the character typed to start editing. */
+    private startEdit;
+    /** `onEditorPreparing` for an editor about to be made: whether it may be. */
+    private editorPreparing;
+    /** `onEditorPrepared` for an editor just made. */
+    private editorPrepared;
+    /** Whether an element is inside the edit form shown in place of a row. */
+    private inForm;
+    /**
+     * Opens the edit form of grid row `i` (`editMode` `'form'`: in place of the row; `'popup'`: in a
+     * modal window), with focus on `field` when it can be filled in. A form open on another row is
+     * given up first, as Cancel does.
+     */
+    private openForm;
+    /** The edit form in a modal window (`editMode: 'popup'`): Save and Cancel in its footer, Enter and Escape press them. */
+    private openWindow;
+    /** Save in the edit form: every field is kept, the row checked and saved as the save mode says; the form closes once it is. */
+    private saveForm;
+    /** A message stops the form from being saved: focus goes to its field. */
+    private formError;
+    /**
+     * Cancel in the edit form: the row's unsaved edits are dropped (a new row goes away) and the form
+     * closes; `onEditCanceling` may keep it open. `closing`: its window is closing already.
+     */
+    private cancelForm;
+    /** The data is about to change (sort, filter, page, refresh) or the edit mode changed: the form is given up. */
+    private dropForm;
+    /** Takes the edit form away (and its window); with `focusRow`, focus goes back to the row. */
+    private closeForm;
+    /** Writes the editor's value into the row's draft and closes it; `false` (the editor stays) when it cannot be read. */
+    private commitEditor;
+    /** Closes the editor without keeping its value. Focus goes back to its cell when it was inside. */
+    private closeEditor;
+    /** Enter in an editor: keep the value, then stay, go down or go on like Tab. */
+    private finishEdit;
+    /** `editMode: 'cell'`: a row that is not new is handed to saving as each of its cells is left. */
+    private savesEachCell;
+    /** In `'cell'` mode the cell just kept is saved now: the row is left (checked, then sent as the save mode says). */
+    private saveCell;
+    /** Escape in an editor: a new row goes away; elsewhere the editor closes without keeping the value. */
+    private cancelEdit;
+    /** Asks `onEditCanceling` before the unsaved changes of `rows` are dropped. */
+    private canDrop;
+    private dropped;
+    /** Escape on a cell: a new row goes away; an edited row gets its old values back. */
+    private cancelRowEdits;
+    /** Drops a new row; focus goes to the row above (same column), else the "New row" button, else the row below. */
+    private removeNewRow;
+    /** Writes a value into the active cell without an editor (Space on a check box column, Delete). */
+    private writeActiveCell;
+    /**
+     * Tab (or Shift+Tab) in edit mode: to the next editable cell of the row; at the end of a new row the
+     * chain opens the next new row; at the end of another row, to the next row; at the edge of the
+     * grid, out of the grid. Leaving a row saves it as the mode says.
+     */
+    private moveWithTab;
+    /** The Tab chain: finish the new row `rowId` and open the next one right below it. */
+    private openNextNewRow;
+    /** Brings a new row into view (to the very end or start for "New row", nearest for the chain) and opens the editor of its first cell a new row can fill. */
+    private openNewRow;
+    /**
+     * Leaves the row being edited so that `then` can run: the editor is read, the row is checked and
+     * sent as the mode says. Blocked (focus on the first message) when it does not pass; in `wait` mode
+     * `then` runs once the save worked. A new row nobody typed into is dropped; `then` gets its former
+     * grid index (rows after it moved up by one), else -1.
+     */
+    private leaveRowThen;
+    /**
+     * Focus left the rows, or the data is about to change: finish the editor and the row without
+     * blocking. A row with messages stays as it is (its edits kept, marked) and is remembered.
+     */
+    private leave;
+    /** The first visible field of a row with a message, or `''` (a message of the whole row). */
+    private firstErrorField;
+    /** Moves to the cell of a message (`field` `''`: the row's status cell, else the active column). */
+    private focusError;
+    /**
+     * Goes to a cell. Leaving the current row first saves it as the mode says and may block (messages)
+     * or wait (`wait` mode); the move happens once the row could be left.
+     */
+    private navigate;
+    private goToCell;
+    private onFocusIn;
+    private onFocusOut;
+    /** A press on a cell of another row: leave the current row first (it may block or wait). */
+    private onPointerDown;
+    private onDoubleClick;
+    /** The click events of a cell and of its row; whether the grid may go on with its own handling. */
+    private askClick;
+    /** A click on the row of totals: its cell's and its row's events (`rowType: 'totalFooter'`). */
+    private clickedTotals;
+    /** A right click on a row: its menu, when `onContextMenuPreparing` gives it items. */
+    private onContextMenu;
+    /** A row's menu: the row's actions, and what `onContextMenuPreparing` makes of them. Returns whether it opened. */
+    private openRowMenu;
+    /** The items of a menu about to open, as `onContextMenuPreparing` leaves them; `null` when it cancels. */
+    private prepareMenu;
+    /** `onKeyHandling`: whether the grid may handle the key. */
+    private askKey;
+    private onClick;
+    /** Opens or closes a group, telling it before (it can be cancelled) and after. */
+    private toggleGroup;
+    /** Opens or closes the details of grid row `i`, telling it before (it can be cancelled) and after. */
+    private toggleDetail;
+    /**
+     * Keys on the expand cell: `toggleKeys` open and close the details; with `arrowKeys` Right opens
+     * closed ones and Left closes open ones (otherwise they move, as on any cell).
+     */
+    private onExpandKey;
+    /** Focus went into a row's details: that row becomes the active one, as if focus were on it. */
+    private enterDetail;
+    /**
+     * Keys in a row's details belong to their content. What it leaves: Escape, and Shift+Tab on its
+     * first stop, go back to the row; Tab on its last stop leaves the grid; on the details' own cell
+     * Tab and Enter go into the content.
+     */
+    private onDetailKey;
+    /**
+     * Tab on the last stop of a row's adaptive detail or details: into the row's details after it;
+     * from an adaptive detail whose row is being edited, on to the next row's cells, as Tab goes in
+     * edit mode; else out of the grid.
+     */
+    private tabOnFrom;
+    /** Focus back on grid row `i` (the active cell's column), from its details. */
+    private backToRow;
+    /** Tab with details in the body: into the details of the row it is on, else out of the grid (never into another row's details). */
+    private tabFromRow;
+    /** Focus in a row's details goes back to the row (before every detail closes). */
+    private leaveDetails;
+    /** Focus in the adaptive detail goes back to its row (before it closes). */
+    private leaveAdaptive;
+    /**
+     * Opens or closes the adaptive detail of grid row `i` (a data or new row, while columns are
+     * hidden), telling it before (it can be cancelled) and after. Another row's open one closes first.
+     */
+    private toggleAdaptive;
+    /** Closes the adaptive detail that is open (as the user would, when its row is there). */
+    private closeAdaptive;
+    /** Keys on the "…" cell: `toggleKeys` open and close the adaptive detail. */
+    private onAdaptiveKey;
+    /** Editing a row whose hidden columns it can fill opens its adaptive detail (`expandOnEdit`, the `'row'` edit mode); leaving the row closes it. */
+    private openAdaptiveForEdit;
+    /** The adaptive detail's form under grid row `i`, while it is drawn. */
+    private adaptiveFormAt;
+    /** What a row's adaptive detail holds: the hidden columns' values, editors where the row can be edited in its cells. */
+    private adaptiveForm;
+    /**
+     * Keys on a group row: `groupToggleKeys` (Enter and Space) open or close it; with `groupArrowKeys`
+     * Right opens it, or goes to its first row when it is open, and Left closes it, or goes to the
+     * group it is in. Keys that edit do nothing there.
+     */
+    private onGroupKey;
+    private hasMenu;
+    private openMenu;
+    /**
+     * Keys on a band's header: Left and Right (Home, End) go along the bands of its row, Up to the band
+     * it is in, Down to the first column or band under it; Alt+Down and the context menu key open its
+     * menu.
+     */
+    private onBandKey;
+    /** Fits a column to its header and the rows shown now; in `'nextColumn'` mode the next column gives or takes the difference, unless `alone`. */
+    private autoSize;
+    /** A chip dropped on the headers: the column is ungrouped and, when it can move, put where it was dropped. */
+    private dropOnHeaders;
+    /** Keyboard move or resize, from the column menu. */
+    private startAdjust;
+    private endAdjust;
+    private onAdjustKey;
+    /**
+     * Up and Down in a text, number, date or check box editor keep the value and move to the row
+     * above or below; taken before the editor sees them (a number box would step its value).
+     */
+    private onEditorCapture;
+    /** Keys inside an open editor; the editor has had them first. */
+    private onEditorKey;
+    private onKey;
+    /** The selection id and key of grid row `i`; `null` for a new row or one still loading. */
+    private selectionEntry;
+    private selectOnly;
+    private toggleSelected;
+    /** Shift with the arrows or a click: the rows from the anchor to `to` join the selection made before the anchor. */
+    private extendSelection;
+    /** The header check box: every row of the filter, or none. */
+    private toggleAll;
+    /** The header check box state: all, none or some. Rows in memory are counted; elsewhere rows picked one by one are "some". */
+    private allState;
+    /** Rows loaded now: every row in memory, the page, or the blocks loaded. */
+    private loadedRows;
+    /** Whether the active cell can take a value (so Space edits it rather than selecting). */
+    private canFillActive;
+    /** A click on a row: a check box toggles it; Ctrl adds or takes out, Shift selects the range from the anchor, else only that row. */
+    private clickSelect;
+    /** Cells can be selected in ranges. Reactive. */
+    private cellMode;
+    /** There are cell ranges, and cells can be selected. */
+    private hasRanges;
+    /** A drag over the rows starts at grid row `index`: the run replaces the selection, joins it, goes from the anchor, or paints the check boxes. */
+    private beginRowDrag;
+    /** The pointer is over grid row `index`: the rows from the anchor to it are the run. */
+    private reachRows;
+    private finishRowDrag;
+    /** A drag over the cells starts at a cell: a range from it, alone or after the others, or the last range extended to it. */
+    private beginCellDrag;
+    private reachCells;
+    private finishCellDrag;
+    /** The last range (or one from the cell active before the press) extended to a cell. Returns whether a range shows. */
+    private extendCellsTo;
+    /** A click on a cell while cells can be selected: Shift extends the last range, Ctrl/⌘ adds the cell as a range, else the ranges go. */
+    private clickCells;
+    /** A key of `extendCellsKeys`: the last range's far corner (or a range from the active cell) moves, and focus with it. Returns whether the key was taken. */
+    private extendCellsByKey;
+    /** A key of `extendRowSelectionKeys` on grid row `row`: the active row moves and the rows from the anchor to it join the selection. Returns whether the key was taken. */
+    private extendRowsByKey;
+    /** Every cell of the rows the user can reach, in every selectable column. */
+    private selectAllCells;
+    /** Delete on cell ranges: every cell of them the user can fill is emptied, as typing would, and the rows are saved as the save mode says. */
+    private clearRangeCells;
+    /** After cells were written (paste, Delete): rows other than the active one are saved as the save mode says, the active one stays in edit. */
+    private saveWritten;
+    /** Says politely what the cell ranges hold: "3 × 5 cells selected", or the cells of several ranges. */
+    private announceCells;
+    /** The summary of the selected cells, worked out once per change, and the column all its numbers come from (for their format). */
+    private summarizeCells;
+    /** The summary in the bottom bar ("Avg: 12 · Count: 4 · Sum: 48"), `''` while it does not show. Reactive. */
+    private cellSummaryText;
+    /** The ready actions: edit, delete, take a deletion back, save and drop a row's edits. */
+    private createActions;
+    /** Opens the editor of a row's first cell the user can fill. */
+    private beginEdit;
+    /** Sends a row's edits now: the row being edited is left (checked, then saved as the mode says). */
+    private saveRow;
+    /** Drops a row's edits; a new row goes away. */
+    private cancelRow;
+    /** A press on an action button: the action runs, the "more" button opens its menu. */
+    private pressAction;
+    private openMore;
+    /** Runs an action; the ready `remove` asks once for all its rows first (`confirmDelete`). */
+    private run;
+    /** Asks before rows are deleted, unless `confirmDelete` is off or the deletion is only marked (batch). */
+    private askDelete;
+    /** One row's action as an entry to run. */
+    private entryOf;
+    /**
+     * Runs an action of a bar, a row's menu or code. The row being edited is left first (saved as the
+     * mode says) unless the action is for that row alone.
+     */
+    private startEntry;
+    /**
+     * A row's actions for its context menu: the common ones of the selection when the row is one of
+     * several selected rows, else the row's own; wherever they show.
+     */
+    private actionMenuItems;
+    /** Keys on an action button: Left and Right move between the buttons of the cell; Enter and Space press it. */
+    private onActionKey;
+    /** Puts copied cells on the clipboard: through the copy event the command raises (both forms), else as plain text. */
+    private writeClipboard;
+    /** Ctrl+V on a cell: the browser raises `paste` next, at the page when no field has focus; take that one event. */
+    private armPaste;
+    /** A paste while a cell (not a field) has focus. */
+    private onPaste;
+    /**
+     * Collects the rows of an export, after `onExporting` when `ask` (which may change the options or
+     * cancel: `null`). The load panel, when asked for, shows the progress and stops the export.
+     */
+    private runExport;
+    /** Shows the load panel for an export that asks for it; whether it shows. */
+    private openExportPanel;
+    private showProgress;
+    /** A column's width on screen: its header cell's, else the width the grid keeps for it. */
+    private shownWidth;
+    /** The commands of the toolbar's export button, from `export`. Reactive. */
+    private exportCommands;
+    private formatName;
+    private filterCell;
+    private openHeaderFilter;
+    /** The condition menu of a filter cell; a yes/no column opens its list instead. */
+    private openConditions;
+    /**
+     * Keys in a filter cell's condition button or editor. Escape and Enter go back to the cell (Enter
+     * applies at once), Tab goes to the next editor of the row, Up and Down in a text box leave the
+     * row, Alt+Down opens the conditions. Keys the editor uses are its own.
+     */
+    private onFilterEditorKey;
+    /** Tab between the editors of the filter row; past its ends focus leaves the grid. */
+    private filterTab;
+    /** The id, row object and grid index of a row the app gives (default: the active row). */
+    private locate;
+}