@gridkitjs/core 0.11.0 → 0.12.0

package/dist/index.d.ts

@@ -187,6 +187,12 @@ interface ColumnDefinition<Row, Node = string> {
      * this for as long as it holds an entry for the column.
      */
     hidden?: boolean | undefined;
+    /**
+     * Whether the user may hide this column — from its header's menu, or the
+     * column chooser. Defaults to `true`. Like `sortable`, it gates the user's
+     * ways to do it and nothing else: `hideColumns` still hides the column.
+     */
+    hideable?: boolean | undefined;
 }
 /** Which parts of a column opt out of the grid's default single-line text. */
 interface ColumnWrapConfig {
@@ -892,12 +898,254 @@ interface GridView<Row, Node = string> {
     readonly grandTotal: AggregateResults;
 }
 
+/**
+ * A row or column selection change by id — see
+ * `GridControllerOptions.onSelectionDiff`.
+ */
+interface SelectionDiffEvent extends SelectionDiff {
+    /** Which selection changed. */
+    readonly target: "rows" | "columns";
+    /** The whole selection after the change. */
+    readonly selection: SelectionState;
+}
+/**
+ * What `createGridController` is given: the grid's options and selection
+ * callbacks, plus what a renderer supplies that is not a setting — the column
+ * definitions, whose templates name the renderer's own node type, the width
+ * the viewport measured, and a hook for its own selection feedback.
+ */
+interface GridControllerOptions<Row, Node = string> extends GridOptions<Row>, SelectionCallbacks<Row, Node> {
+    /**
+     * The columns to show. Omitted or empty, one column is inferred per field
+     * of `dataSource` — see `defineColumnsFromRows`.
+     */
+    columns?: readonly ColumnDefinition<Row, Node>[] | undefined;
+    /**
+     * The width, in px, `resizeMode: "fit"` fills. `null` or absent before it
+     * has been measured, or where there is no viewport at all (an export in
+     * Node), and then columns keep their resolved widths.
+     */
+    viewportWidth?: number | null | undefined;
+    /**
+     * Called once per row or column selection change, after the selection
+     * callbacks, with the change by id — every id it added or removed,
+     * including those with no row on screen (on another page, in a collapsed
+     * group, filtered out), which the callbacks' resolved rows leave out. For a
+     * renderer's own feedback, such as a live region announcing how many rows
+     * are selected; an application reads the selection callbacks instead.
+     */
+    onSelectionDiff?: ((event: SelectionDiffEvent) => void) | undefined;
+}
+/**
+ * A grid without a renderer: its state, the view derived from it, and every
+ * action that changes it. A renderer creates one per grid, hands it the
+ * current options on each update, draws `getView()` and calls the actions
+ * from its event handlers, so no renderer decides anything the user can see.
+ *
+ * Each slice of `GridState` is controlled or not on its own, the way a form
+ * input is: given as an option (`columnSort`), the grid shows that value and
+ * an action only asks for a change through the slice's callback
+ * (`onColumnSortChange`); left out, the controller keeps the slice itself,
+ * starting from its default (`defaultColumnSort`).
+ *
+ * Every action follows the same steps: work out the next value; stop if it
+ * is the very object the slice already holds; keep it, unless the slice is
+ * controlled; report it through the slice's callback; then call every
+ * subscriber, synchronously. The setters (`setColumnSort` and the like) also
+ * stop for a value equal to the current one, so restoring what is already
+ * there reports nothing.
+ *
+ * Every member is a plain function bound to its grid, safe to hand around on
+ * its own — `onClick={controller.nextPage}`.
+ */
+interface GridController<Row, Node = string> {
+    readonly getOptions: () => GridControllerOptions<Row, Node>;
+    /**
+     * Replaces the options, as a renderer does with its current props on every
+     * update; calling it again with equal options changes nothing. A controlled
+     * slice takes its new value from here.
+     *
+     * Does not call subscribers: a renderer calls this while it updates, and
+     * draws the result itself — a subscriber called mid-update would update
+     * mid-update too. A renderer that also tells other listeners about it does
+     * so once its update is done.
+     */
+    readonly setOptions: (options: GridControllerOptions<Row, Node>) => void;
+    /** Every slice as the grid now applies it. The same object until a slice changes. */
+    readonly getState: () => GridState<Row>;
+    /** What the user is looking at — see `resolveGridView`. The same object until something in it changes. */
+    readonly getView: () => GridView<Row, Node>;
+    /**
+     * Calls `listener` after each action that got as far as reporting a
+     * change. Returns the function that unsubscribes it.
+     */
+    readonly subscribe: (listener: () => void) => () => void;
+    /**
+     * Puts back state saved earlier — from `getState()`, or from
+     * `serializeGridState` and back through JSON. Every slice given is set as
+     * its own `set*` action would set it, so each that changes fires its
+     * callback and a controlled one only asks; slices left out keep their value.
+     * Subscribers are called once, after every slice is in place, and a
+     * restored pagination is kept even when the same call changed the sort,
+     * filter or grouping that would otherwise send it back to the first page.
+     */
+    readonly restoreState: (saved: Partial<GridState<Row>> | Partial<SerializedGridState<Row>>) => void;
+    /**
+     * Replaces the column widths. Reported through `onColumnResize` as the
+     * `"end"` of a resize of the first column whose width changed, at its new
+     * width — or, when its entry was removed, the width its definition gives
+     * it. Equal widths report nothing.
+     */
+    readonly setColumnSizing: (sizing: ColumnSizingState) => void;
+    /**
+     * Sets one column's width, as a resize gesture does: `"move"` while the
+     * gesture lasts, `"end"` once it is over. Never skipped for an unchanged
+     * width, so a drag held against a column's minimum still reports every
+     * move.
+     */
+    readonly resizeColumn: (columnId: string, width: number, phase: "move" | "end") => void;
+    /**
+     * Ends a resize gesture by putting its column back as it was when the
+     * gesture began — `startSizing` is the sizing state then, `startWidth` the
+     * width the column was drawn at — keeping any other column's change made in
+     * the meantime. Reported as the gesture's `"end"`, at `startWidth`.
+     */
+    readonly cancelColumnResize: (columnId: string, startSizing: ColumnSizingState, startWidth: number) => void;
+    /**
+     * Replaces the column order. Reported through `onColumnOrderChange` naming
+     * the first column whose position changed; an equal order reports nothing.
+     */
+    readonly setColumnOrder: (order: ColumnOrderState) => void;
+    /**
+     * Moves a column in front of `beforeId`, or to the end when that is
+     * `null`, among every column — hidden ones keep their place. A move that
+     * changes nothing reports nothing.
+     */
+    readonly moveColumn: (columnId: string, beforeId: string | null) => void;
+    /**
+     * Replaces the column visibility state. Reported through
+     * `onColumnVisibilityChange` with every column whose entry changed; an
+     * equal state reports nothing.
+     */
+    readonly setColumnVisibility: (visibility: ColumnVisibilityState) => void;
+    /** Shows the given columns, each in the place it held when hidden. One report for the whole call. */
+    readonly showColumns: (columnIds: readonly string[]) => void;
+    /** Hides the given columns. A hidden column still sorts, filters and groups. */
+    readonly hideColumns: (columnIds: readonly string[]) => void;
+    /**
+     * Replaces the filter. Reported through `onFilterChange`; a filter equal to
+     * the current one — the same entries in the same order, a `Date` value
+     * compared by time and a predicate by identity — reports nothing.
+     */
+    readonly setFilter: (filter: FilterState<Row>) => void;
+    /**
+     * Replaces the selected row ids as given, whatever `selectable` allows —
+     * the way a controlled or default value is applied. The same ids in the
+     * same order report nothing.
+     */
+    readonly setRowSelection: (selection: SelectionState) => void;
+    /**
+     * Selects rows as a user could, within what `selectable.rows` allows:
+     * `"replace"` (the default) selects exactly these — only the last of them
+     * under `"single"` — and `"toggle"` flips each one. An id need not name a
+     * row on screen. A call that leaves the selection as it was reports
+     * nothing.
+     */
+    readonly selectRows: (rowIds: readonly string[], intent?: "replace" | "toggle") => void;
+    /**
+     * Applies one click or key press to a row: `"replace"`, `"toggle"` or
+     * `"range"` from the last row selected by anything but a range, across
+     * the data rows on the current page.
+     */
+    readonly selectRow: (rowId: string, intent: SelectIntent) => void;
+    /** Selects every data row on the current page, when `selectable.rows` is `"multiple"`. */
+    readonly selectAllRows: () => void;
+    /** Lets go of every row, column and cell selection at once, as Escape does. */
+    readonly clearSelection: () => void;
+    /** Replaces the selected column ids as given — see `setRowSelection`. */
+    readonly setColumnSelection: (selection: SelectionState) => void;
+    /** `selectRow`, for a column among the columns as rendered. */
+    readonly selectColumn: (columnId: string, intent: SelectIntent) => void;
+    /** Replaces the selected cell as given, `null` for none. */
+    readonly setCellSelection: (selection: CellSelectionState) => void;
+    /**
+     * Applies one click or key press to a cell: `"toggle"` lets go of it when
+     * it is the one selected; anything else selects it. A cell holds one value,
+     * so a range over cells reads as a plain click.
+     */
+    readonly selectCell: (cell: SelectedCellRef, intent: SelectIntent) => void;
+    /**
+     * Replaces the sort. Reported through `onColumnSortChange` naming the
+     * first column whose place or direction changed; a sort equal to the
+     * current one changes nothing and reports nothing.
+     */
+    readonly setColumnSort: (sort: ColumnSortState) => void;
+    /**
+     * Cycles a column's sort, as its header toggle does: ascending, descending,
+     * off. `stack` adds it to the sort rather than replacing the sort with it.
+     */
+    readonly toggleColumnSort: (columnId: string, options?: {
+        readonly stack?: boolean | undefined;
+    }) => void;
+    /**
+     * Takes one column out of the sort, keeping the rest in their order, and
+     * reports naming that column — which `setColumnSort` without it would not
+     * when it was the first key, naming instead the key that moved up. A
+     * column the sort leaves out already reports nothing.
+     */
+    readonly clearColumnSort: (columnId: string) => void;
+    /**
+     * Replaces the group-by stack. Reported through `onGroupByChange` naming
+     * the first level that changed; an equal stack reports nothing.
+     */
+    readonly setGroupBy: (groupBy: GroupByState) => void;
+    /** Adds a column to the end of the group-by stack, or removes it if it is already there. */
+    readonly toggleGroupBy: (columnId: string) => void;
+    /**
+     * Puts a column into the group-by stack in front of `beforeColumnId`, or at
+     * the end when that is `null` — adding it, or moving it if it is already
+     * there.
+     */
+    readonly moveGroupBy: (columnId: string, beforeColumnId: string | null) => void;
+    /**
+     * Replaces the collapsed groups. Reported with `groupId: null`, as a change
+     * to every group at once; the same ids in the same order report nothing.
+     */
+    readonly setGroupExpansion: (expansion: GroupExpansionState) => void;
+    readonly toggleGroupExpansion: (groupId: string) => void;
+    readonly expandAllGroups: () => void;
+    /** Collapses every group currently shown — see `collapseAllGroups`. */
+    readonly collapseAllGroups: () => void;
+    /**
+     * Replaces the page and page size as given; the view clamps a page past
+     * the last one. An equal pagination reports nothing.
+     */
+    readonly setPagination: (pagination: PaginationState) => void;
+    /**
+     * Moves to the given page, clamped into range. A page that clamps to the
+     * current one reports nothing.
+     */
+    readonly goToPage: (pageIndex: number) => void;
+    /** Moves one page on; on the last page it does nothing and reports nothing. */
+    readonly nextPage: () => void;
+    /** Moves one page back; on the first page it does nothing and reports nothing. */
+    readonly previousPage: () => void;
+    /**
+     * Changes the page size and goes back to the first page. The current size,
+     * already on the first page, reports nothing.
+     */
+    readonly setPageSize: (pageSize: number) => void;
+}
+
 /**
  * Every string a grid shows or announces of its own — the pager, the group-by
- * bar, the loading row, the text of a boolean or missing value, and the
- * live-region announcements — so a grid can speak a language other than
- * English. A message that names something takes a function, so a translation
- * can put the name where its own grammar wants it.
+ * bar, the loading row, the text of a boolean or missing value, the labels of
+ * its built-in commands, the names of its menus, toolbar and column chooser,
+ * and the live-region
+ * announcements — so a grid can
+ * speak a language other than English. A message that names something takes
+ * a function, so a translation can put the name where its own grammar wants
+ * it.
  *
  * Text the data supplies (cells, headers, labels) is not here: it is already
  * the app's to choose. Nor is formatting — dates and numbers follow
@@ -952,6 +1200,71 @@ interface GridMessages {
     selectedCount: (count: number, target: "rows" | "columns") => string;
     /** Announced when a cell is selected. `rowNumber` counts from one. */
     cellSelected: (columnName: string, rowNumber: number) => string;
+    /** Announced when one column is hidden. */
+    columnHidden: (columnName: string) => string;
+    /** Announced when one column is shown. */
+    columnShown: (columnName: string) => string;
+    /** Announced when one change hides more than one column. */
+    columnsHidden: (count: number) => string;
+    /** Announced when one change shows more than one column. */
+    columnsShown: (count: number) => string;
+    /**
+     * Announced when one action autofits more than one column, as
+     * `column.autoFitAll` does, in place of each column's `columnResized`.
+     */
+    columnsAutoFitted: (count: number) => string;
+    /** A column header's context menu's accessible name. */
+    headerMenuLabel: (columnName: string) => string;
+    /** A data cell's context menu's accessible name — a menu for its row. */
+    cellMenuLabel: string;
+    /** A group header row's context menu's accessible name. */
+    groupMenuLabel: string;
+    /** The accessible name of the menu in the body's empty space. */
+    bodyMenuLabel: string;
+    /** The built-in `sort.ascending` command's label. */
+    sortAscending: string;
+    sortDescending: string;
+    /** `sort.clear`: takes one column out of the sort. */
+    clearSort: string;
+    /** `sort.clearAll` */
+    clearAllSorting: string;
+    /** `group.add`, naming the column it groups by. */
+    groupByColumn: (columnName: string) => string;
+    /** `group.clearAll`. `group.remove` reads `removeGroupBy`, as the group-by chip's button does. */
+    ungroupAll: string;
+    expandAllGroups: string;
+    collapseAllGroups: string;
+    /** `column.hide` */
+    hideColumn: string;
+    /** `column.autoFit`: sizes the column to its content. */
+    autoFitColumn: string;
+    autoFitAllColumns: string;
+    /** `selection.selectAllRows` */
+    selectAllRows: string;
+    /** `selection.clear` */
+    clearSelection: string;
+    /** `filter.clearAll`, which clears the search too. */
+    clearFilters: string;
+    /** `column.choose`, which opens the column chooser. */
+    chooseColumns: string;
+    /** The toolbar's accessible name, unless its `label` gives one. */
+    toolbarLabel: string;
+    /** The toolbar's search box's accessible name. */
+    searchLabel: string;
+    /** Shown in the toolbar's empty search box. */
+    searchPlaceholder: string;
+    /** The toolbar's "More" button, holding the items that do not fit. */
+    moreToolbarItems: string;
+    /** Announced when a search settles: how many rows it found. */
+    searchResults: (count: number) => string;
+    /** The column chooser's accessible name. */
+    columnChooserLabel: string;
+    /** The column chooser's search box's accessible name. */
+    columnChooserSearchLabel: string;
+    /** The column chooser's checkbox showing or hiding every column its search lists. */
+    showAllColumns: string;
+    /** Shown in the column chooser when its search matches no column. */
+    noMatchingColumns: string;
 }
 /** The grid's own English, which `messages` replaces key by key. */
 declare const defaultMessages: GridMessages;
@@ -962,33 +1275,415 @@ declare const defaultMessages: GridMessages;
  */
 declare function resolveMessages(messages: Partial<GridMessages> | undefined): GridMessages;
 
-/** The locale(s) values are formatted for — `undefined` is the runtime's own. */
-type FormatLocale = string | readonly string[] | undefined;
 /**
- * The text a value reads as in `column` — what a cell shows when the column
- * has no `cellTemplate`, and what an export or a print writes, so the two
- * cannot disagree.
- *
- * A `valueFormatter` decides outright. `null`/`undefined` read `""`, a
- * boolean `"true"`/`"false"` — or `messages.booleanTrue`/`booleanFalse`
- * when given, for a grid speaking another language — a string as it is, a
- * plain object or array as JSON.
- *
- * Dates and numbers are formatted through `Intl` only once asked to — the
- * column has a `format`, or a `locale` is given. Until then they print as a
- * grid always printed them, so adopting this changes nothing on screen: a
- * `Date` through `toLocaleString()`, a number as-is (`1234.5`, never
- * `1,234.5`). Once asked:
- *
- * - A `Date` → `Intl.DateTimeFormat`: the date alone under `"date"`, the time
- *   alone under `"time"`, both otherwise.
- * - A number under a numeric `type` → `Intl.NumberFormat`: `"currency"` with
- *   a currency symbol once `format.currency` names one (two fraction digits
- *   until then), `"percent"` reading `0.25` as 25 %. Under any other type it
- *   is still printed as-is, the way a number id should be.
- *
- * `format` and `locale` go to the `Intl` constructor unchanged, so any
- * option it accepts is honoured.
+ * Where a command was asked for: the part of the grid a menu was opened on,
+ * the toolbar item pressed, or nowhere in particular for a call through a
+ * renderer's API. A built-in reads the column, row or group it acts on from
+ * here, and is hidden on a target that has none.
+ */
+type GridCommandTarget = {
+    readonly area: "header";
+    readonly columnId: string;
+} | {
+    readonly area: "cell";
+    readonly rowId: string;
+    readonly columnId: string;
+} | {
+    readonly area: "group";
+    readonly groupId: string;
+    readonly columnId: string;
+}
+/** Empty body space, or a grid with no rows. */
+ | {
+    readonly area: "body";
+} | {
+    readonly area: "toolbar";
+    readonly itemId: string;
+}
+/** A renderer's API, with no particular place. */
+ | {
+    readonly area: "grid";
+};
+/** Where a command was run from: a context menu, the toolbar, or a renderer's API. */
+type GridCommandSource = "contextMenu" | "toolbar" | "api";
+/** What `onCommand` is told of a command, or an inline menu item, that ran. */
+interface GridCommandEvent {
+    /** The command's id, or the inline item's. */
+    readonly commandId: string;
+    /** Where it was asked for. */
+    readonly target: GridCommandTarget;
+    readonly source: GridCommandSource;
+}
+/**
+ * The panels a command can ask a renderer to open. A union so the filter UI
+ * can add its own kind through the same door.
+ */
+type GridPanelKind = "columnChooser";
+/**
+ * What a command needs that only a renderer has: a DOM to measure, panels to
+ * open, a live region to speak through. A caller with none of these — a test,
+ * a script in Node — passes members that do nothing.
+ */
+interface GridCommandHost {
+    /** Sizes each column to fit its content, as double-clicking its resize handle does. */
+    readonly autoFitColumns: (columnIds: readonly string[]) => void;
+    /** Opens one of the grid's panels, anchored to where the command was asked for. */
+    readonly openPanel: (kind: GridPanelKind, target: GridCommandTarget) => void;
+    /** Reads `text` out through the grid's live region. */
+    readonly announce: (text: string) => void;
+}
+/**
+ * Every action of the controller — the only way a command changes state, so
+ * each change reports through its slice's callback exactly as the user's own
+ * gesture would. Leaves out `setOptions`, which is the renderer's alone,
+ * `subscribe`, and the getters whose results the context already carries.
+ *
+ * Nothing left names the renderer's node type, so a controller of any `Node`
+ * is one.
+ */
+type GridCommandActions<Row> = Omit<GridController<Row, unknown>, "getOptions" | "setOptions" | "subscribe" | "getState" | "getView">;
+/**
+ * Everything a command reads to decide whether it shows, whether it is
+ * enabled and what it does — one snapshot of the grid, taken when a menu or
+ * toolbar is resolved. Build one with `createCommandContext`.
+ */
+interface GridCommandContext<Row> {
+    readonly target: GridCommandTarget;
+    readonly state: GridState<Row>;
+    readonly view: GridView<Row, unknown>;
+    readonly options: GridOptions<Row>;
+    readonly messages: GridMessages;
+    readonly actions: GridCommandActions<Row>;
+    readonly host: GridCommandHost;
+    /** The row a cell target is on; `null` for any other target, or a row the filter hides. */
+    readonly row: ResolvedRow<Row> | null;
+    /** The column a header, cell or group target names, hidden or not; `null` otherwise. */
+    readonly column: DataColumn<Row, unknown> | null;
+    /**
+     * The selected rows that pass the filter, in the order they are shown,
+     * across every page and collapsed group. A function, computed on first
+     * call and remembered: resolving it walks every filtered row, and a toolbar
+     * builds a context on every change without most commands ever asking.
+     */
+    readonly selectedRows: () => readonly ResolvedRow<Row>[];
+}
+/**
+ * The one implementation behind a menu item, a toolbar button and a
+ * renderer's `runCommand`. Whether it shows and whether it is enabled are
+ * predicates over the context, asked each time a menu or toolbar is resolved,
+ * so a command follows the grid's state without being told about it.
+ */
+interface GridCommand<Row> {
+    /** `"sort.ascending"` for a built-in, or any id of the app's own. Never `"separator"`, which a menu reads as one. */
+    readonly id: string;
+    readonly label: string | ((context: GridCommandContext<Row>) => string);
+    /** A key the renderer maps to an icon of its own; a key it does not know draws nothing. */
+    readonly icon?: string | undefined;
+    /** A key-combination hint in `aria-keyshortcuts` syntax, such as `"Alt+ArrowUp"`. Shown, not bound. */
+    readonly shortcut?: string | undefined;
+    /** Whether the command shows here at all. Defaults to always. */
+    readonly isVisible?: ((context: GridCommandContext<Row>) => boolean) | undefined;
+    /** Whether it can run. A disabled command still shows, so a user can see what is not possible. Defaults to always. */
+    readonly isEnabled?: ((context: GridCommandContext<Row>) => boolean) | undefined;
+    /** Present for a checkable command — drawn as a checkbox item or a toggle button — and says whether it is checked. */
+    readonly isChecked?: ((context: GridCommandContext<Row>) => boolean) | undefined;
+    readonly execute: (context: GridCommandContext<Row>) => void;
+}
+
+/** The id of every command `builtInCommands` returns. */
+type BuiltInCommandId = "sort.ascending" | "sort.descending" | "sort.clear" | "sort.clearAll" | "group.add" | "group.remove" | "group.clearAll" | "group.expandAll" | "group.collapseAll" | "column.hide" | "column.autoFit" | "column.autoFitAll" | "column.choose" | "selection.selectAllRows" | "selection.clear" | "filter.clearAll";
+/**
+ * The icon keys the built-ins carry, which a renderer draws as icons of its
+ * own. An app command may use them too, to look like the built-ins.
+ */
+type BuiltInCommandIcon = "sortAscending" | "sortDescending" | "group" | "hide" | "autoFit";
+/**
+ * The grid's own commands, one per action its menus and toolbar offer —
+ * sorting, grouping, hiding, fitting and choosing columns, selecting and
+ * clearing.
+ * Labels come from `messages`, so they follow the grid's language.
+ *
+ * A function rather than a constant so each comes typed for the caller's
+ * `Row`; the commands hold no state, and two calls build equal ones.
+ */
+declare function builtInCommands<Row>(): readonly GridCommand<Row>[];
+
+/** A value given outright, or worked out from the context each time the menu is resolved. */
+type FromContext<Row, Value> = Value | ((context: GridCommandContext<Row>) => Value);
+/**
+ * An item written into the menu itself rather than registered as a command —
+ * for an action only one menu offers.
+ */
+interface MenuItemEntry<Row> {
+    readonly type: "item";
+    readonly id: string;
+    readonly label: FromContext<Row, string>;
+    readonly icon?: string | undefined;
+    readonly shortcut?: string | undefined;
+    readonly hidden?: FromContext<Row, boolean> | undefined;
+    readonly disabled?: FromContext<Row, boolean> | undefined;
+    /** Present for a checkable item, and says whether it is checked. */
+    readonly checked?: FromContext<Row, boolean> | undefined;
+    readonly onSelect: (context: GridCommandContext<Row>) => void;
+}
+/** An item that opens a menu of its own. Left out when nothing in it shows. */
+interface MenuSubmenuEntry<Row> {
+    readonly type: "submenu";
+    readonly id: string;
+    readonly label: FromContext<Row, string>;
+    readonly icon?: string | undefined;
+    readonly items: readonly MenuEntry<Row>[];
+}
+/**
+ * One entry of a menu as an app writes it: a command id — a built-in's or
+ * one of its own — `"separator"`, an inline item or a submenu. The same
+ * vocabulary every menu and toolbar is listed in.
+ */
+type MenuEntry<Row> = BuiltInCommandId | "separator" | (string & {}) | MenuItemEntry<Row> | MenuSubmenuEntry<Row>;
+/**
+ * A menu item ready to draw: every label a string, every flag a boolean, and
+ * `run` bound to the context the menu was resolved in.
+ */
+interface ResolvedMenuItem {
+    readonly type: "item";
+    /** The command's id, or the inline item's. */
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: string | undefined;
+    readonly shortcut?: string | undefined;
+    /** Drawn, and focusable, but `run` does nothing. */
+    readonly disabled: boolean;
+    /** `undefined` for an item that is not checkable. */
+    readonly checked: boolean | undefined;
+    /**
+     * Runs the item — a command only when it is still visible and enabled —
+     * and says whether it ran, so a renderer reports only what did something.
+     */
+    readonly run: () => boolean;
+}
+interface ResolvedMenuSubmenu {
+    readonly type: "submenu";
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: string | undefined;
+    /** Never empty: a submenu with nothing to show is left out. */
+    readonly items: readonly ResolvedMenuEntry[];
+}
+interface ResolvedMenuSeparator {
+    readonly type: "separator";
+    /**
+     * The separator's place among the entries it was resolved from, which
+     * stays put however the items around it come and go — a key for a
+     * renderer that needs one, unique among its menu's separators.
+     */
+    readonly key: string;
+}
+/** One entry of a menu as `resolveMenu` hands it to a renderer to draw. */
+type ResolvedMenuEntry = ResolvedMenuItem | ResolvedMenuSubmenu | ResolvedMenuSeparator;
+
+/** The parts of a grid that open a context menu of their own. */
+type GridContextMenuArea = "header" | "cell" | "group" | "body";
+/**
+ * Where a context menu opens: a command target in one of the context menu
+ * areas — a column header, a data cell, a group header row, or empty space
+ * in the body — or in `Area` alone.
+ */
+type GridContextMenuTarget<Area extends GridContextMenuArea = GridContextMenuArea> = Extract<GridCommandTarget, {
+    readonly area: Area;
+}>;
+/** What `onContextMenuOpenChange` is told as a context menu opens or closes. */
+interface ContextMenuOpenChangeEvent {
+    readonly open: boolean;
+    /** Where the menu opened, or where the one closing had. */
+    readonly target: GridContextMenuTarget;
+}
+/** What a function given for an area is asked, each time its menu opens. */
+interface GridContextMenuRequest<Row, Area extends GridContextMenuArea = GridContextMenuArea> {
+    /** Where the menu opens. */
+    readonly target: GridContextMenuTarget<Area>;
+    /** The area's default entries, to keep, trim, reorder or add to. */
+    readonly defaults: readonly MenuEntry<Row>[];
+    /** The grid as the menu sees it — the context its items run in. */
+    readonly context: GridCommandContext<Row>;
+}
+/**
+ * An area's menu: its entries, or a function that works them out each time
+ * the menu opens — from where it opens, the area's defaults and the grid's
+ * state. A function giving `null` or `[]` shows no grid menu there, so the
+ * browser's own menu shows.
+ */
+type GridContextMenuEntries<Row, Area extends GridContextMenuArea = GridContextMenuArea> = readonly MenuEntry<Row>[] | ((request: GridContextMenuRequest<Row, Area>) => readonly MenuEntry<Row>[] | null);
+/**
+ * A grid's context menus, by area, in the vocabulary every grid menu is
+ * written in. An area left out shows its defaults; one given `[]` shows no
+ * grid menu, so the browser's own menu shows there.
+ */
+interface GridContextMenuOptions<Row> {
+    /** A column header's menu. */
+    readonly header?: GridContextMenuEntries<Row, "header"> | undefined;
+    /** A data cell's menu, acting on its row and cell. */
+    readonly cell?: GridContextMenuEntries<Row, "cell"> | undefined;
+    /** A group header row's menu. */
+    readonly group?: GridContextMenuEntries<Row, "group"> | undefined;
+    /** The menu of the body's empty space, below the last row or in a grid with none. */
+    readonly body?: GridContextMenuEntries<Row, "body"> | undefined;
+}
+/**
+ * The menu each area shows unless the grid says otherwise — built-in
+ * commands only, each hidden where it has nothing to act on, so the menu a
+ * column header shows holds only what that column can do. The body has
+ * none: empty space keeps the browser's menu until a grid gives it one.
+ */
+declare const defaultContextMenu: {
+    readonly [Area in GridContextMenuArea]: readonly (BuiltInCommandId | "separator")[];
+};
+/**
+ * Whether the `contextMenu` option opens a grid menu on `area` at all: it is
+ * on, and gives the area entries or a function rather than `[]`. A function
+ * may still give no menu for one place or another; this answers for the
+ * area, as a cell's `aria-keyshortcuts` needs to before anything is asked.
+ */
+declare function hasContextMenu<Row>(contextMenu: boolean | GridContextMenuOptions<Row> | undefined, area: GridContextMenuArea): boolean;
+/**
+ * The entries a grid's `contextMenu` option gives the place `context.target`
+ * names, to resolve with `resolveMenu` in that same context: none while the
+ * option is off — left out or `false` — or for a target no context menu
+ * opens on; the area's defaults under `true` or when the option leaves the
+ * area out; the entries it lists; or what its function gives this request.
+ * No entries means no grid menu there.
+ */
+declare function contextMenuEntries<Row>(contextMenu: boolean | GridContextMenuOptions<Row> | undefined, context: GridCommandContext<Row>): readonly MenuEntry<Row>[];
+
+/** Where a toolbar item's command runs: the toolbar item it was asked from. */
+type GridToolbarTarget = Extract<GridCommandTarget, {
+    readonly area: "toolbar";
+}>;
+/**
+ * A place in the toolbar the renderer fills with content of the app's own —
+ * React's `renderToolbarItem(id)` — for anything the entries cannot say.
+ */
+interface ToolbarCustomEntry {
+    readonly type: "custom";
+    readonly id: string;
+}
+/**
+ * One entry of a toolbar as an app writes it: anything a menu lists — a
+ * command id, `"separator"`, an inline item, or a submenu, which the toolbar
+ * draws as a dropdown button — plus the entries only a toolbar has:
+ * `"search"`, the box searching every column; `"spacer"`, which takes up the
+ * free space and so pushes what follows it to the far end; and a custom
+ * entry.
+ */
+type ToolbarEntry<Row> = MenuEntry<Row> | "search" | "spacer" | ToolbarCustomEntry;
+/**
+ * A toolbar button ready to draw — a command, or an inline item — with
+ * every label a string, every flag a boolean, and `run` bound to the
+ * context of its place in the toolbar.
+ */
+interface ResolvedToolbarButton {
+    readonly type: "button";
+    /** The command's id, or the inline item's. */
+    readonly id: string;
+    /** The same as `id`. */
+    readonly key: string;
+    readonly label: string;
+    readonly icon?: string | undefined;
+    readonly shortcut?: string | undefined;
+    /** Drawn, and focusable, but `run` does nothing. */
+    readonly disabled: boolean;
+    /**
+     * Whether a toggle button is pressed — `undefined` for a button that is
+     * not one: a checkable command or item draws as a toggle.
+     */
+    readonly pressed: boolean | undefined;
+    /** Runs the button, and says whether it ran — see `ResolvedMenuItem.run`. */
+    readonly run: () => boolean;
+}
+/** A dropdown button, opening the menu its submenu entry lists. */
+interface ResolvedToolbarMenu {
+    readonly type: "menu";
+    readonly id: string;
+    /** The same as `id`. */
+    readonly key: string;
+    readonly label: string;
+    readonly icon?: string | undefined;
+    /** Never empty: a dropdown with nothing to show is left out. */
+    readonly items: readonly ResolvedMenuEntry[];
+}
+/** The search box, over the grid's global text filter. */
+interface ResolvedToolbarSearch {
+    readonly type: "search";
+    /** Always `"search"`. */
+    readonly key: string;
+}
+/** The free space between the entries either side of it. */
+interface ResolvedToolbarSpacer {
+    readonly type: "spacer";
+    /** `spacer-<index>`, from its place among the entries it was resolved from. */
+    readonly key: string;
+}
+/** A custom entry's place, for the renderer to fill. */
+interface ResolvedToolbarCustom {
+    readonly type: "custom";
+    readonly id: string;
+    /** The same as `id`. */
+    readonly key: string;
+}
+/**
+ * One entry of a toolbar as `resolveToolbar` hands it to a renderer to draw.
+ * Each has a `key` — an item's id, `"search"`, or a separator's or spacer's
+ * place among the entries — unique among the toolbar's entries, which the
+ * renderer writes into the entry's `data-gridkit-toolbar-item`.
+ */
+type ResolvedToolbarItem = ResolvedToolbarButton | ResolvedToolbarMenu | ResolvedToolbarSearch | ResolvedToolbarSpacer | ResolvedMenuSeparator | ResolvedToolbarCustom;
+
+/** A grid's toolbar: what it lists, and what a screen reader calls it. */
+interface GridToolbarOptions<Row> {
+    /** The toolbar's entries, in order. Left out, the defaults. */
+    readonly items?: readonly ToolbarEntry<Row>[] | undefined;
+    /** The toolbar's accessible name. Left out, `messages.toolbarLabel`. */
+    readonly label?: string | undefined;
+}
+/**
+ * What a toolbar lists unless the grid says otherwise: the search box, then
+ * the free space, then "Clear filters" and "Choose columns" at the far end.
+ */
+declare const defaultToolbar: readonly (BuiltInCommandId | "search" | "spacer")[];
+/**
+ * The entries a grid's `toolbar` option lists, to resolve with
+ * `resolveToolbar`: none while it is off — left out or `false` — the
+ * defaults under `true` or an object without `items`, else its `items`.
+ * No entries means no toolbar.
+ */
+declare function toolbarEntries<Row>(toolbar: boolean | GridToolbarOptions<Row> | undefined): readonly ToolbarEntry<Row>[];
+
+/** The locale(s) values are formatted for — `undefined` is the runtime's own. */
+type FormatLocale = string | readonly string[] | undefined;
+/**
+ * The text a value reads as in `column` — what a cell shows when the column
+ * has no `cellTemplate`, and what an export or a print writes, so the two
+ * cannot disagree.
+ *
+ * A `valueFormatter` decides outright. `null`/`undefined` read `""`, a
+ * boolean `"true"`/`"false"` — or `messages.booleanTrue`/`booleanFalse`
+ * when given, for a grid speaking another language — a string as it is, a
+ * plain object or array as JSON.
+ *
+ * Dates and numbers are formatted through `Intl` only once asked to — the
+ * column has a `format`, or a `locale` is given. Until then they print as a
+ * grid always printed them, so adopting this changes nothing on screen: a
+ * `Date` through `toLocaleString()`, a number as-is (`1234.5`, never
+ * `1,234.5`). Once asked:
+ *
+ * - A `Date` → `Intl.DateTimeFormat`: the date alone under `"date"`, the time
+ *   alone under `"time"`, both otherwise.
+ * - A number under a numeric `type` → `Intl.NumberFormat`: `"currency"` with
+ *   a currency symbol once `format.currency` names one (two fraction digits
+ *   until then), `"percent"` reading `0.25` as 25 %. Under any other type it
+ *   is still printed as-is, the way a number id should be.
+ *
+ * `format` and `locale` go to the `Intl` constructor unchanged, so any
+ * option it accepts is honoured.
  */
 declare function formatCellValue<Row>(value: unknown, column: ColumnDefinition<Row, unknown>, locale?: FormatLocale, row?: Row, messages?: Pick<GridMessages, "booleanTrue" | "booleanFalse">): string;
 /**
@@ -1325,297 +2020,112 @@ interface GridOptions<Row> {
      */
     virtualized?: boolean | undefined;
     /**
-     * Rows rendered outside the visible range on each side, to reduce
-     * blank-frame flashes on fast scrolling. Only meaningful with `virtualized`
-     * on.
-     */
-    overscan?: number | undefined;
-    /**
-     * Assumed height for a row never yet measured — only matters for the very
-     * first paint and for `scrollToRow`'s initial jump before it corrects
-     * itself against that row's real, measured height. Only meaningful with
-     * `virtualized` on.
-     */
-    estimatedRowHeight?: number | undefined;
-    /**
-     * The grid's accessible name, announced when it takes focus. A grid without
-     * one is read only as "grid", which says nothing about which grid.
-     */
-    label?: string | undefined;
-    /**
-     * The id of an element naming the grid, for a heading already on the page.
-     * Takes precedence over `label`, as `aria-labelledby` does.
-     */
-    labelledBy?: string | undefined;
-    /**
-     * The locale values are formatted for — a BCP 47 tag such as `"de-DE"`, or
-     * a list to fall back through. Setting it turns on `Intl` formatting of
-     * dates and numbers in every cell and aggregate shown without a template;
-     * without it, only a column with its own `format` is formatted, in the
-     * runtime's locale, and the rest print as they always have.
-     */
-    locale?: FormatLocale;
-    /**
-     * The grid's own strings, replacing its English key by key — the pager's
-     * buttons, the group-by bar, the loading row, boolean and blank values,
-     * and every live-region announcement. Keys left out keep their default.
-     * Formatting is `locale`'s, not this.
-     */
-    messages?: Partial<GridMessages> | undefined;
-}
-/**
- * Reported as the user selects. Every one of these is fanned out from a single
- * diff of the transition it describes, so no two can disagree about what one
- * interaction did.
- *
- * Kept apart from `GridOptions` because the column payloads carry resolved
- * columns, whose labels are whatever a renderer's `headerTemplate` returns —
- * `Node` is that renderer's node type.
- */
-interface SelectionCallbacks<Row, Node = string> {
-    /** Called once per row newly selected. The last call names the last row. */
-    onRowSelect?: ((event: RowSelectEvent<Row>) => void) | undefined;
-    /** Called once with every row one interaction selected. */
-    onRowsSelect?: ((event: RowsSelectEvent<Row>) => void) | undefined;
-    onRowDeselect?: ((event: RowSelectEvent<Row>) => void) | undefined;
-    onRowsDeselect?: ((event: RowsSelectEvent<Row>) => void) | undefined;
-    /**
-     * Called once per change with what it added, what it removed and everything
-     * selected after it — the one to persist from.
-     */
-    onRowSelectionChange?: ((event: RowSelectionChangeEvent<Row>) => void) | undefined;
-    onColumnSelect?: ((event: ColumnSelectEvent<Row, Node>) => void) | undefined;
-    onColumnsSelect?: ((event: ColumnsSelectEvent<Row, Node>) => void) | undefined;
-    onColumnDeselect?: ((event: ColumnSelectEvent<Row, Node>) => void) | undefined;
-    onColumnsDeselect?: ((event: ColumnsSelectEvent<Row, Node>) => void) | undefined;
-    onColumnSelectionChange?: ((event: ColumnSelectionChangeEvent<Row, Node>) => void) | undefined;
-    onCellSelect?: ((event: CellSelectEvent<Row, Node>) => void) | undefined;
-    onCellDeselect?: ((event: CellSelectEvent<Row, Node>) => void) | undefined;
-    onCellSelectionChange?: ((event: CellSelectionChangeEvent<Row, Node>) => void) | undefined;
-}
-
-/**
- * A row or column selection change by id — see
- * `GridControllerOptions.onSelectionDiff`.
- */
-interface SelectionDiffEvent extends SelectionDiff {
-    /** Which selection changed. */
-    readonly target: "rows" | "columns";
-    /** The whole selection after the change. */
-    readonly selection: SelectionState;
-}
-/**
- * What `createGridController` is given: the grid's options and selection
- * callbacks, plus what a renderer supplies that is not a setting — the column
- * definitions, whose templates name the renderer's own node type, the width
- * the viewport measured, and a hook for its own selection feedback.
- */
-interface GridControllerOptions<Row, Node = string> extends GridOptions<Row>, SelectionCallbacks<Row, Node> {
-    /**
-     * The columns to show. Omitted or empty, one column is inferred per field
-     * of `dataSource` — see `defineColumnsFromRows`.
-     */
-    columns?: readonly ColumnDefinition<Row, Node>[] | undefined;
-    /**
-     * The width, in px, `resizeMode: "fit"` fills. `null` or absent before it
-     * has been measured, or where there is no viewport at all (an export in
-     * Node), and then columns keep their resolved widths.
-     */
-    viewportWidth?: number | null | undefined;
-    /**
-     * Called once per row or column selection change, after the selection
-     * callbacks, with the change by id — every id it added or removed,
-     * including those with no row on screen (on another page, in a collapsed
-     * group, filtered out), which the callbacks' resolved rows leave out. For a
-     * renderer's own feedback, such as a live region announcing how many rows
-     * are selected; an application reads the selection callbacks instead.
-     */
-    onSelectionDiff?: ((event: SelectionDiffEvent) => void) | undefined;
-}
-/**
- * A grid without a renderer: its state, the view derived from it, and every
- * action that changes it. A renderer creates one per grid, hands it the
- * current options on each update, draws `getView()` and calls the actions
- * from its event handlers, so no renderer decides anything the user can see.
- *
- * Each slice of `GridState` is controlled or not on its own, the way a form
- * input is: given as an option (`columnSort`), the grid shows that value and
- * an action only asks for a change through the slice's callback
- * (`onColumnSortChange`); left out, the controller keeps the slice itself,
- * starting from its default (`defaultColumnSort`).
- *
- * Every action follows the same steps: work out the next value; stop if it
- * is the very object the slice already holds; keep it, unless the slice is
- * controlled; report it through the slice's callback; then call every
- * subscriber, synchronously. The setters (`setColumnSort` and the like) also
- * stop for a value equal to the current one, so restoring what is already
- * there reports nothing.
- *
- * Every member is a plain function bound to its grid, safe to hand around on
- * its own — `onClick={controller.nextPage}`.
- */
-interface GridController<Row, Node = string> {
-    readonly getOptions: () => GridControllerOptions<Row, Node>;
-    /**
-     * Replaces the options, as a renderer does with its current props on every
-     * update; calling it again with equal options changes nothing. A controlled
-     * slice takes its new value from here.
-     *
-     * Does not call subscribers: a renderer calls this while it updates, and
-     * draws the result itself — a subscriber called mid-update would update
-     * mid-update too. A renderer that also tells other listeners about it does
-     * so once its update is done.
-     */
-    readonly setOptions: (options: GridControllerOptions<Row, Node>) => void;
-    /** Every slice as the grid now applies it. The same object until a slice changes. */
-    readonly getState: () => GridState<Row>;
-    /** What the user is looking at — see `resolveGridView`. The same object until something in it changes. */
-    readonly getView: () => GridView<Row, Node>;
-    /**
-     * Calls `listener` after each action that got as far as reporting a
-     * change. Returns the function that unsubscribes it.
-     */
-    readonly subscribe: (listener: () => void) => () => void;
-    /**
-     * Puts back state saved earlier — from `getState()`, or from
-     * `serializeGridState` and back through JSON. Every slice given is set as
-     * its own `set*` action would set it, so each that changes fires its
-     * callback and a controlled one only asks; slices left out keep their value.
-     * Subscribers are called once, after every slice is in place, and a
-     * restored pagination is kept even when the same call changed the sort,
-     * filter or grouping that would otherwise send it back to the first page.
-     */
-    readonly restoreState: (saved: Partial<GridState<Row>> | Partial<SerializedGridState<Row>>) => void;
-    /**
-     * Replaces the column widths. Reported through `onColumnResize` as the
-     * `"end"` of a resize of the first column whose width changed, at its new
-     * width — or, when its entry was removed, the width its definition gives
-     * it. Equal widths report nothing.
-     */
-    readonly setColumnSizing: (sizing: ColumnSizingState) => void;
-    /**
-     * Sets one column's width, as a resize gesture does: `"move"` while the
-     * gesture lasts, `"end"` once it is over. Never skipped for an unchanged
-     * width, so a drag held against a column's minimum still reports every
-     * move.
-     */
-    readonly resizeColumn: (columnId: string, width: number, phase: "move" | "end") => void;
-    /**
-     * Ends a resize gesture by putting its column back as it was when the
-     * gesture began — `startSizing` is the sizing state then, `startWidth` the
-     * width the column was drawn at — keeping any other column's change made in
-     * the meantime. Reported as the gesture's `"end"`, at `startWidth`.
-     */
-    readonly cancelColumnResize: (columnId: string, startSizing: ColumnSizingState, startWidth: number) => void;
-    /**
-     * Replaces the column order. Reported through `onColumnOrderChange` naming
-     * the first column whose position changed; an equal order reports nothing.
-     */
-    readonly setColumnOrder: (order: ColumnOrderState) => void;
-    /**
-     * Moves a column in front of `beforeId`, or to the end when that is
-     * `null`, among every column — hidden ones keep their place. A move that
-     * changes nothing reports nothing.
-     */
-    readonly moveColumn: (columnId: string, beforeId: string | null) => void;
-    /**
-     * Replaces the column visibility state. Reported through
-     * `onColumnVisibilityChange` with every column whose entry changed; an
-     * equal state reports nothing.
+     * Rows rendered outside the visible range on each side, to reduce
+     * blank-frame flashes on fast scrolling. Only meaningful with `virtualized`
+     * on.
      */
-    readonly setColumnVisibility: (visibility: ColumnVisibilityState) => void;
-    /** Shows the given columns, each in the place it held when hidden. One report for the whole call. */
-    readonly showColumns: (columnIds: readonly string[]) => void;
-    /** Hides the given columns. A hidden column still sorts, filters and groups. */
-    readonly hideColumns: (columnIds: readonly string[]) => void;
+    overscan?: number | undefined;
     /**
-     * Replaces the filter. Reported through `onFilterChange`; a filter equal to
-     * the current one — the same entries in the same order, a `Date` value
-     * compared by time and a predicate by identity — reports nothing.
+     * Assumed height for a row never yet measured — only matters for the very
+     * first paint and for `scrollToRow`'s initial jump before it corrects
+     * itself against that row's real, measured height. Only meaningful with
+     * `virtualized` on.
      */
-    readonly setFilter: (filter: FilterState<Row>) => void;
+    estimatedRowHeight?: number | undefined;
     /**
-     * Replaces the selected row ids as given, whatever `selectable` allows —
-     * the way a controlled or default value is applied. The same ids in the
-     * same order report nothing.
+     * The grid's accessible name, announced when it takes focus. A grid without
+     * one is read only as "grid", which says nothing about which grid.
      */
-    readonly setRowSelection: (selection: SelectionState) => void;
+    label?: string | undefined;
     /**
-     * Selects rows as a user could, within what `selectable.rows` allows:
-     * `"replace"` (the default) selects exactly these — only the last of them
-     * under `"single"` — and `"toggle"` flips each one. An id need not name a
-     * row on screen. A call that leaves the selection as it was reports
-     * nothing.
+     * The id of an element naming the grid, for a heading already on the page.
+     * Takes precedence over `label`, as `aria-labelledby` does.
      */
-    readonly selectRows: (rowIds: readonly string[], intent?: "replace" | "toggle") => void;
+    labelledBy?: string | undefined;
     /**
-     * Applies one click or key press to a row: `"replace"`, `"toggle"` or
-     * `"range"` from the last row selected by anything but a range, across
-     * the data rows on the current page.
+     * The locale values are formatted for — a BCP 47 tag such as `"de-DE"`, or
+     * a list to fall back through. Setting it turns on `Intl` formatting of
+     * dates and numbers in every cell and aggregate shown without a template;
+     * without it, only a column with its own `format` is formatted, in the
+     * runtime's locale, and the rest print as they always have.
      */
-    readonly selectRow: (rowId: string, intent: SelectIntent) => void;
-    /** Selects every data row on the current page, when `selectable.rows` is `"multiple"`. */
-    readonly selectAllRows: () => void;
-    /** Lets go of every row, column and cell selection at once, as Escape does. */
-    readonly clearSelection: () => void;
-    /** Replaces the selected column ids as given — see `setRowSelection`. */
-    readonly setColumnSelection: (selection: SelectionState) => void;
-    /** `selectRow`, for a column among the columns as rendered. */
-    readonly selectColumn: (columnId: string, intent: SelectIntent) => void;
-    /** Replaces the selected cell as given, `null` for none. */
-    readonly setCellSelection: (selection: CellSelectionState) => void;
+    locale?: FormatLocale;
     /**
-     * Applies one click or key press to a cell: `"toggle"` lets go of it when
-     * it is the one selected; anything else selects it. A cell holds one value,
-     * so a range over cells reads as a plain click.
+     * The grid's own strings, replacing its English key by key — the pager's
+     * buttons, the group-by bar, the loading row, boolean and blank values,
+     * the built-in commands' labels, the menus' names, and every live-region
+     * announcement. Keys
+     * left out keep their default.
+     * Formatting is `locale`'s, not this.
      */
-    readonly selectCell: (cell: SelectedCellRef, intent: SelectIntent) => void;
+    messages?: Partial<GridMessages> | undefined;
     /**
-     * Replaces the sort. Reported through `onColumnSortChange` naming the
-     * first column whose place or direction changed; a sort equal to the
-     * current one changes nothing and reports nothing.
+     * The grid's own context menu, opened on a column header, a data cell, a
+     * group row or the body's empty space by a right-click, Shift+F10 or the
+     * ContextMenu key. Off by default, like every other feature, leaving the
+     * browser's menu. `true` shows each area's defaults — see
+     * `defaultContextMenu`; an object lists an area's entries, an area left
+     * out keeping its defaults and one given `[]` showing the browser's menu
+     * there.
      */
-    readonly setColumnSort: (sort: ColumnSortState) => void;
+    contextMenu?: boolean | GridContextMenuOptions<Row> | undefined;
     /**
-     * Cycles a column's sort, as its header toggle does: ascending, descending,
-     * off. `stack` adds it to the sort rather than replacing the sort with it.
+     * Called when the grid's context menu opens or closes, with where. A menu
+     * opened in place of another reports that one closing first. The open
+     * state is the renderer's to keep, so no option holds it.
      */
-    readonly toggleColumnSort: (columnId: string, options?: {
-        readonly stack?: boolean | undefined;
-    }) => void;
+    onContextMenuOpenChange?: ((event: ContextMenuOpenChangeEvent) => void) | undefined;
     /**
-     * Replaces the group-by stack. Reported through `onGroupByChange` naming
-     * the first level that changed; an equal stack reports nothing.
+     * The app's own commands, for its menus to list by id. One with a
+     * built-in's id replaces it wherever that id is listed — a translated,
+     * privilege-gated or differently behaving "Hide column" — see
+     * `resolveCommands`.
      */
-    readonly setGroupBy: (groupBy: GroupByState) => void;
-    /** Adds a column to the end of the group-by stack, or removes it if it is already there. */
-    readonly toggleGroupBy: (columnId: string) => void;
+    commands?: readonly GridCommand<Row>[] | undefined;
     /**
-     * Puts a column into the group-by stack in front of `beforeColumnId`, or at
-     * the end when that is `null` — adding it, or moving it if it is already
-     * there.
+     * Called after a command or an inline menu item runs — chosen from a menu,
+     * or run through a renderer's API — saying which, where it was asked for
+     * and from where. One that did not run, being hidden or disabled, is not
+     * reported.
      */
-    readonly moveGroupBy: (columnId: string, beforeColumnId: string | null) => void;
+    onCommand?: ((event: GridCommandEvent) => void) | undefined;
     /**
-     * Replaces the collapsed groups. Reported with `groupId: null`, as a change
-     * to every group at once; the same ids in the same order report nothing.
+     * A toolbar above the grid: its own commands, a search box over the
+     * filter's global text entry, dropdowns and the app's own content, in the
+     * menu vocabulary. Off by default. `true` lists `defaultToolbar`; an object
+     * lists its `items` and may name it with `label` — see `ToolbarEntry`.
      */
-    readonly setGroupExpansion: (expansion: GroupExpansionState) => void;
-    readonly toggleGroupExpansion: (groupId: string) => void;
-    readonly expandAllGroups: () => void;
-    /** Collapses every group currently shown — see `collapseAllGroups`. */
-    readonly collapseAllGroups: () => void;
+    toolbar?: boolean | GridToolbarOptions<Row> | undefined;
+}
+/**
+ * Reported as the user selects. Every one of these is fanned out from a single
+ * diff of the transition it describes, so no two can disagree about what one
+ * interaction did.
+ *
+ * Kept apart from `GridOptions` because the column payloads carry resolved
+ * columns, whose labels are whatever a renderer's `headerTemplate` returns —
+ * `Node` is that renderer's node type.
+ */
+interface SelectionCallbacks<Row, Node = string> {
+    /** Called once per row newly selected. The last call names the last row. */
+    onRowSelect?: ((event: RowSelectEvent<Row>) => void) | undefined;
+    /** Called once with every row one interaction selected. */
+    onRowsSelect?: ((event: RowsSelectEvent<Row>) => void) | undefined;
+    onRowDeselect?: ((event: RowSelectEvent<Row>) => void) | undefined;
+    onRowsDeselect?: ((event: RowsSelectEvent<Row>) => void) | undefined;
     /**
-     * Replaces the page and page size as given; the view clamps a page past
-     * the last one. An equal pagination reports nothing.
+     * Called once per change with what it added, what it removed and everything
+     * selected after it — the one to persist from.
      */
-    readonly setPagination: (pagination: PaginationState) => void;
-    /** Moves to the given page, clamped into range. */
-    readonly goToPage: (pageIndex: number) => void;
-    readonly nextPage: () => void;
-    readonly previousPage: () => void;
-    /** Changes the page size and goes back to the first page. */
-    readonly setPageSize: (pageSize: number) => void;
+    onRowSelectionChange?: ((event: RowSelectionChangeEvent<Row>) => void) | undefined;
+    onColumnSelect?: ((event: ColumnSelectEvent<Row, Node>) => void) | undefined;
+    onColumnsSelect?: ((event: ColumnsSelectEvent<Row, Node>) => void) | undefined;
+    onColumnDeselect?: ((event: ColumnSelectEvent<Row, Node>) => void) | undefined;
+    onColumnsDeselect?: ((event: ColumnsSelectEvent<Row, Node>) => void) | undefined;
+    onColumnSelectionChange?: ((event: ColumnSelectionChangeEvent<Row, Node>) => void) | undefined;
+    onCellSelect?: ((event: CellSelectEvent<Row, Node>) => void) | undefined;
+    onCellDeselect?: ((event: CellSelectEvent<Row, Node>) => void) | undefined;
+    onCellSelectionChange?: ((event: CellSelectionChangeEvent<Row, Node>) => void) | undefined;
 }
 
 /**
@@ -1625,6 +2135,187 @@ interface GridController<Row, Node = string> {
  */
 declare function createGridController<Row, Node = string>(initial: GridControllerOptions<Row, Node>): GridController<Row, Node>;
 
+/** What `createCommandContext` builds a context from. */
+interface GridCommandContextInput<Row, Node> {
+    readonly controller: GridController<Row, Node>;
+    readonly target: GridCommandTarget;
+    /** The grid's messages, already laid over the defaults — see `resolveMessages`. */
+    readonly messages: GridMessages;
+    readonly host: GridCommandHost;
+}
+/**
+ * A command context for `target`, over the controller's state, view and
+ * options as they are now. The controller itself serves as `actions`, typed
+ * down to them, so a command cannot reach `setOptions`.
+ *
+ * `row` and `column` are looked up once here, against every filtered row and
+ * every column, hidden ones included, so a target the API names off screen
+ * still resolves.
+ */
+declare function createCommandContext<Row, Node>({ controller, target, messages, host, }: GridCommandContextInput<Row, Node>): GridCommandContext<Row>;
+
+/**
+ * Every command a grid knows, by id: the built-ins, then `commands` — an app
+ * command with a built-in's id replacing it, so every menu and toolbar
+ * listing that id gets the app's version (translated, gated by a privilege,
+ * or doing something else) without being changed itself.
+ *
+ * A fresh map per call; a renderer resolves it once per change to
+ * `commands`, not per menu.
+ */
+declare function resolveCommands<Row>(commands: readonly GridCommand<Row>[] | undefined): ReadonlyMap<string, GridCommand<Row>>;
+/**
+ * Runs `command` when it is visible and enabled on `context`'s target, and
+ * says whether it did — so a renderer reports only a command that ran, and a
+ * stale button or a call through the API cannot run one the grid's state no
+ * longer allows.
+ */
+declare function runCommand<Row>(command: GridCommand<Row>, context: GridCommandContext<Row>): boolean;
+
+/** What `resolveMenu` resolves a menu's entries against. */
+interface MenuResolveOptions<Row> {
+    /** Every command the grid knows, by id — see `resolveCommands`. */
+    readonly commands: ReadonlyMap<string, GridCommand<Row>>;
+    readonly context: GridCommandContext<Row>;
+}
+/**
+ * A menu's entries resolved against the grid as `context` sees it, ready to
+ * draw:
+ *
+ * - A command id becomes its command's item, and a hidden command or item
+ *   is left out. An id naming no command is left out too, and reported once
+ *   per command map through `console.error`.
+ * - Labels become strings and flags booleans; `checked` stays `undefined`
+ *   for an item that is not checkable.
+ * - A submenu is resolved the same way, and left out when nothing in it
+ *   shows.
+ * - Separators never lead, trail or double up, however the items around
+ *   them came and went.
+ *
+ * An empty result means there is nothing to show — no grid menu at all
+ * here.
+ */
+declare function resolveMenu<Row>(entries: readonly MenuEntry<Row>[], options: MenuResolveOptions<Row>): readonly ResolvedMenuEntry[];
+
+/** Where an arrow, Home or End key moves a menu's focus. */
+type MenuMove = "next" | "previous" | "first" | "last";
+/**
+ * The index of the item focus moves to from `from` — `-1` when nothing is
+ * focused yet, so `"next"` lands on the first item and `"previous"` on the
+ * last. Separators are skipped and `"next"`/`"previous"` wrap round the
+ * ends; disabled items count, since they stay focusable for a screen reader
+ * to find. `-1` when there is no item at all.
+ *
+ * Takes anything with a `type`, so a behaviour that reads its items off the
+ * page can pass `{ type: "item" }` for each.
+ */
+declare function nextMenuIndex(entries: readonly Pick<ResolvedMenuEntry, "type">[], from: number, move: MenuMove): number;
+/**
+ * The index of the item `query` — what was typed, buffered for a moment —
+ * picks, matched case-insensitively against the start of each label and
+ * wrapping round the end; `-1` when none matches.
+ *
+ * `from` is the item focused now. A single letter, or the same letter
+ * typed again and again, searches from the item after it, so repeating a
+ * letter steps through every item it starts. A longer query searches from
+ * `from` itself, so the item already found stays put while what is typed
+ * still matches it.
+ */
+declare function typeaheadIndex(labels: readonly string[], from: number, query: string): number;
+
+/** What `resolveToolbar` resolves a toolbar's entries against. */
+interface ToolbarResolveOptions<Row> {
+    /** Every command the grid knows, by id — see `resolveCommands`. */
+    readonly commands: ReadonlyMap<string, GridCommand<Row>>;
+    /**
+     * The context an item resolves and runs in, for its target — the item
+     * itself, or the dropdown an item in one is listed under. A command that
+     * opens a panel anchors it there.
+     */
+    readonly contextFor: (target: GridToolbarTarget) => GridCommandContext<Row>;
+}
+/**
+ * A toolbar's entries resolved against the grid, ready to draw, by the
+ * rules `resolveMenu` follows:
+ *
+ * - A command id becomes its command's button, and an inline item a button
+ *   of its own; either is a toggle, with `pressed`, when it is checkable. A
+ *   hidden one is left out, and so is an id naming no command, reported
+ *   once per command map through `console.error`.
+ * - A submenu becomes a dropdown, its items resolved as a menu's, and is
+ *   left out when nothing in it shows.
+ * - `"search"`, `"spacer"` and custom entries stay as they are.
+ * - Separators never lead, trail, double up or sit next to a spacer, which
+ *   already parts what is on either side of it.
+ *
+ * Resolve again whenever the grid changes, so each button's label, flags
+ * and `run` follow its state.
+ */
+declare function resolveToolbar<Row>(entries: readonly ToolbarEntry<Row>[], options: ToolbarResolveOptions<Row>): readonly ResolvedToolbarItem[];
+
+/** What `fitToolbarItems` fits: a toolbar's entries, by width, into its space. */
+interface ToolbarFitInput {
+    /** Each entry's width, in order — `0` for a spacer, whose width is only the space left over. */
+    readonly widths: readonly number[];
+    /** The width the entries share. */
+    readonly available: number;
+    /** The width of the "More" button the entries that do not fit go into. */
+    readonly moreWidth: number;
+    /** Whether each entry, in order, stays however little room there is. */
+    readonly pinned: readonly boolean[];
+}
+/**
+ * How many of a toolbar's entries fit, from the start: the first `count`
+ * stay in the toolbar, with every pinned entry after them, and the rest go
+ * into a "More" menu.
+ *
+ * Pinned entries take their room first, wherever they are. Room for "More"
+ * is kept only when something does not fit — when everything does, the
+ * result is every entry and no "More" is drawn. Entries are taken in order
+ * and the first that does not fit ends the count, so the toolbar keeps its
+ * order rather than filling gaps with later, narrower entries; one with no
+ * width, a spacer, fits wherever the entries before it did.
+ */
+declare function fitToolbarItems({ widths, available, moreWidth, pinned, }: ToolbarFitInput): number;
+/**
+ * Whether a toolbar entry stays in the toolbar however narrow it gets: the
+ * search box and custom entries, which have no menu item to become.
+ */
+declare function isPinnedToolbarItem(item: Pick<ResolvedToolbarItem, "type">): boolean;
+/** A toolbar split at the count `fitToolbarItems` gave — see `splitToolbarItems`. */
+interface ToolbarSplit {
+    /** What stays in the toolbar. */
+    readonly shown: readonly ResolvedToolbarItem[];
+    /** The "More" menu's entries, empty when everything fits. */
+    readonly overflow: readonly ResolvedMenuEntry[];
+}
+/**
+ * `items` split at the first `fit`: those before it, and every pinned item,
+ * stay in the toolbar; the rest become the "More" menu's entries — a button
+ * an item, checked where it was pressed, and a dropdown a submenu. Neither
+ * side keeps a separator at its ends, doubled, or beside a spacer.
+ */
+declare function splitToolbarItems(items: readonly ResolvedToolbarItem[], fit: number): ToolbarSplit;
+
+/**
+ * What a search box shows for `filter`: the global text entry's query — the
+ * one naming no column — without the `%` anchors that make it a "contains"
+ * match, or `""` when there is none. A `%` the user typed inside the text
+ * stays: only the first and last characters are anchors.
+ */
+declare function searchTextOf<Row>(filter: FilterState<Row>): string;
+/**
+ * `filter` with its global text entry set to search for `text` anywhere in
+ * any column — the query `%text%` — or removed for an empty `text`. Every
+ * entry naming a column stays as it was. `filter` itself, unchanged, when
+ * it already searches for `text`.
+ *
+ * `text` is written as typed, spaces and all: a search box reads its text
+ * back from the filter, and trimming here would take a space away from
+ * under the caret as the user types it.
+ */
+declare function setSearchText<Row>(filter: FilterState<Row>, text: string): FilterState<Row>;
+
 /**
  * How a column of `type` aligns by default. Numeric types align right so that
  * their digits line up by place value; everything else reads from the left.
@@ -1680,6 +2371,8 @@ interface KeyShortcutCapabilities {
     resizable: boolean;
     sortable: boolean;
     groupable: boolean;
+    /** Whether the header opens the grid's context menu. Defaults to `false`. */
+    contextMenu?: boolean | undefined;
 }
 /**
  * The `aria-keyshortcuts` string for a column header, naming only the keys
@@ -2226,44 +2919,6 @@ declare function applyColumnVisibility<Row, Node>(columns: readonly DataColumn<R
  */
 declare function setColumnVisibility<Row>(columns: readonly DataColumn<Row, unknown>[], visibility: ColumnVisibilityState, columnIds: readonly string[], visible: boolean): ColumnVisibilityState;
 
-/**
- * `resolveGridView`, memoised per stage: each stage remembers its last
- * inputs and returns its last output when none of them changed identity, so
- * a call that changes one slice of state recomputes only what depends on
- * it. The data stages (filter → sort → group → aggregate → paginate) read
- * `dataColumns`, which carry no width, so a resize or a viewport change
- * leaves `rows`, `displayRows`, `pageRows`, `displayDataRows` and
- * `grandTotal` reference-equal to the previous call's — only `columns` is
- * new. The view object itself is reused when every field is unchanged, so a
- * snapshot-based renderer sees nothing to re-render.
- *
- * Hold one resolver per grid and call it with the current input every time
- * the view is needed; the memo only pays off across calls to the same one.
- */
-declare function createGridViewResolver<Row, Node = string>(): (input: GridViewInput<Row, Node>) => GridView<Row, Node>;
-/**
- * What the user is looking at, derived from the rows, the columns, the
- * grid's state and its options in one call: rows filtered → sorted →
- * grouped → aggregated → paginated, and columns ordered → hidden → sized.
- * The one function a renderer, an export or a toolbar calls instead of
- * composing the stages itself, so none of them can disagree about what is
- * shown.
- *
- * Unmemoised — a one-off resolver. A renderer that derives the view on every
- * change holds a `createGridViewResolver()` instead.
- */
-declare function resolveGridView<Row, Node = string>(input: GridViewInput<Row, Node>): GridView<Row, Node>;
-
-/**
- * `state` in a form that survives `JSON.stringify` and back unchanged, for
- * saving a layout — to local storage, a URL, a user's profile — and handing
- * it to `restoreState` later. Every slice is plain data already except the
- * filter: a `Date` value or operand is written as its ISO string, and a
- * predicate entry, being a function, cannot be written at all and is left
- * out with a `console.error` naming its column.
- */
-declare function serializeGridState<Row>(state: GridState<Row>): SerializedGridState<Row>;
-
 /**
  * What one column's filter looks like to an editor — which of its forms can
  * show it, or that none can.
@@ -2307,6 +2962,11 @@ interface ColumnValueQuery {
     readonly limit?: number;
     /** The locale labels are formatted for — the grid's own `locale`. */
     readonly locale?: FormatLocale;
+    /**
+     * The grid's own `messages`, over the defaults: a boolean is labelled
+     * `booleanTrue`/`booleanFalse`, as its cells print it.
+     */
+    readonly messages?: Partial<GridMessages>;
 }
 interface ColumnValueOptions {
     /** The distinct values, sorted as the column sorts, searched and cut to `limit`. */
@@ -2317,6 +2977,12 @@ interface ColumnValueOptions {
     readonly truncated: boolean;
     /** How many of the same rows hold a blank — `null`, `undefined` or `""`. */
     readonly blanks: number;
+    /**
+     * The column's `type`, which tells values apart the way an `in` filter
+     * does — on a date column, a date string and the `Date` it names are one
+     * value. `initialFilterEditorDraft` carries it into the draft.
+     */
+    readonly columnType?: ColumnType | undefined;
 }
 /**
  * A checklist or condition editor's working copy of one column's filter,
@@ -2332,11 +2998,13 @@ interface FilterEditorDraft<Row> {
     /** How many rows hold a blank; the blanks entry only matters when some do. */
     readonly blanks: number;
     readonly search: string;
-    /** The checked values, keyed as grouping keys them. */
+    /** The checked values, keyed as an `in` filter on the column keys them. */
     readonly checked: ReadonlyMap<string, FilterScalar>;
     readonly includeBlanks: boolean;
     readonly conditions: readonly OperatorFilterEntry<Row>[];
     readonly combinator: "and" | "or";
+    /** The column's `type`, from `ColumnValueOptions` — what values are keyed by. */
+    readonly columnType?: ColumnType | undefined;
 }
 type FilterEditorAction<Row> = {
     readonly type: "search";
@@ -2376,9 +3044,11 @@ declare function describeColumnFilter<Row>(filter: FilterState<Row>, columnId: s
  * Counted over the rows every *other* column's filter keeps — every entry
  * except those `describeColumnFilter` would count for this column — so a
  * column's list cascades from the other filters without its own pick
- * hiding the values the user unchecked. Values are told apart as grouping
- * tells them apart, ordered as the column sorts, labelled as its cells
- * print; blanks are counted apart, in `blanks`.
+ * hiding the values the user unchecked. Values are told apart as an `in`
+ * filter tells them apart — as grouping does, except that a date column's
+ * date strings are the dates they name — ordered as the column sorts, and
+ * labelled as its cells print, a boolean in `query.messages`' words; blanks
+ * are counted apart, in `blanks`.
  *
  * Costs one pass over `rows` (tens of milliseconds at 100k rows), so compute
  * it when an editor opens rather than on every render, and hand the whole
@@ -2420,6 +3090,96 @@ declare function filterEditorReducer<Row>(draft: FilterEditorDraft<Row>, action:
  */
 declare function draftToFilter<Row>(draft: FilterEditorDraft<Row>, columnId: string, current: FilterState<Row>): FilterState<Row>;
 
+/** What a column chooser is drawn from: every column, the visibility, and the search typed. */
+interface ColumnChooserInput<Row> {
+    /** Every column in its current order, hidden ones included — a view's `dataColumns`. */
+    readonly columns: readonly DataColumn<Row, unknown>[];
+    readonly visibility: ColumnVisibilityState;
+    /** Narrows the list to the columns whose header text contains it, ignoring case. */
+    readonly search?: string | undefined;
+}
+/** One column's checkbox in a column chooser. */
+interface ColumnChooserEntry {
+    readonly columnId: string;
+    /** The column's header text — what the search matches, and the checkbox's label. */
+    readonly label: string;
+    /** Whether the column is shown — whether its checkbox is checked. */
+    readonly visible: boolean;
+    /**
+     * Whether the checkbox cannot be unchecked: the column is shown and is
+     * either not `hideable` or the last column shown. A hidden column can
+     * always be shown, `hideable` or not.
+     */
+    readonly disabled: boolean;
+}
+/** What toggling a chooser's "Show all" checkbox does: shows these columns, or hides them. */
+interface ColumnChooserToggle {
+    readonly visible: boolean;
+    readonly columnIds: readonly string[];
+}
+interface ColumnChooserModel {
+    /** The columns the search matches, in column order. */
+    readonly entries: readonly ColumnChooserEntry[];
+    /**
+     * The "Show all" checkbox's state over the entries whose columns are
+     * `hideable` — the ones it acts on. A column the user cannot hide is
+     * always on, so counting it would leave "Show all" stuck at mixed.
+     */
+    readonly selectAll: SelectAllState;
+    /** What toggling "Show all" does, or `null` when it can do nothing — a disabled checkbox. */
+    readonly toggleAll: ColumnChooserToggle | null;
+}
+/**
+ * A column chooser's list for a search, and what its "Show all" checkbox
+ * says and does — the same tri-state over what the search shows that a
+ * filter editor's select-all is (`selectAllState`).
+ *
+ * "Show all" shows every hidden column the search shows once any is hidden,
+ * and hides those it shows once none is. It never touches a column that is
+ * not `hideable`, and never hides the last column shown: when that is all
+ * that would be left, the first of them in column order stays, since a grid
+ * with no column shown has no header to bring one back from.
+ */
+declare function resolveColumnChooser<Row>({ columns, visibility, search, }: ColumnChooserInput<Row>): ColumnChooserModel;
+
+/**
+ * `resolveGridView`, memoised per stage: each stage remembers its last
+ * inputs and returns its last output when none of them changed identity, so
+ * a call that changes one slice of state recomputes only what depends on
+ * it. The data stages (filter → sort → group → aggregate → paginate) read
+ * `dataColumns`, which carry no width, so a resize or a viewport change
+ * leaves `rows`, `displayRows`, `pageRows`, `displayDataRows` and
+ * `grandTotal` reference-equal to the previous call's — only `columns` is
+ * new. The view object itself is reused when every field is unchanged, so a
+ * snapshot-based renderer sees nothing to re-render.
+ *
+ * Hold one resolver per grid and call it with the current input every time
+ * the view is needed; the memo only pays off across calls to the same one.
+ */
+declare function createGridViewResolver<Row, Node = string>(): (input: GridViewInput<Row, Node>) => GridView<Row, Node>;
+/**
+ * What the user is looking at, derived from the rows, the columns, the
+ * grid's state and its options in one call: rows filtered → sorted →
+ * grouped → aggregated → paginated, and columns ordered → hidden → sized.
+ * The one function a renderer, an export or a toolbar calls instead of
+ * composing the stages itself, so none of them can disagree about what is
+ * shown.
+ *
+ * Unmemoised — a one-off resolver. A renderer that derives the view on every
+ * change holds a `createGridViewResolver()` instead.
+ */
+declare function resolveGridView<Row, Node = string>(input: GridViewInput<Row, Node>): GridView<Row, Node>;
+
+/**
+ * `state` in a form that survives `JSON.stringify` and back unchanged, for
+ * saving a layout — to local storage, a URL, a user's profile — and handing
+ * it to `restoreState` later. Every slice is plain data already except the
+ * filter: a `Date` value or operand is written as its ISO string, and a
+ * predicate entry, being a function, cannot be written at all and is left
+ * out with a `console.error` naming its column.
+ */
+declare function serializeGridState<Row>(state: GridState<Row>): SerializedGridState<Row>;
+
 /**
  * One entry per row: its measured height once known, `undefined` until then.
  * A row never yet rendered (or rendered but not yet observed) falls back to
@@ -2454,4 +3214,4 @@ interface VisibleRange {
  */
 declare function visibleRange(heights: RowHeights, estimatedHeight: number, scrollTop: number, viewportHeight: number, overscan: number): VisibleRange;
 
-export { type AggregateFn, type AggregateResults, type AggregateSpec, type AggregateState, type Borders, type BuiltInAggregate, type CellSelectEvent, type CellSelectionChangeEvent, type CellSelectionMode, type CellSelectionState, type CellTemplateContext, type ColumnAlignment, type ColumnConstraints, type ColumnDefinition, type ColumnFilterShape, type ColumnOrderEvent, type ColumnOrderState, type ColumnResizeEvent, type ColumnResizeSession, type ColumnResolveOptions, type ColumnSelectEvent, type ColumnSelectionChangeEvent, type ColumnSizeDefaults, type ColumnSizingState, type ColumnSortEntry, type ColumnSortEvent, type ColumnSortState, type ColumnType, type ColumnValueOption, type ColumnValueOptions, type ColumnValueQuery, type ColumnVisibilityEvent, type ColumnVisibilityState, type ColumnWrapConfig, type ColumnsSelectEvent, DEFAULT_COLUMN_SIZES, type DataColumn, type DisplayRow, type DropSide, type FieldPath, type FilterChangeEvent, type FilterEditorAction, type FilterEditorDraft, type FilterEntry, type FilterOperator, type FilterPredicate, type FilterScalar, type FilterState, type FooterTemplateContext, type FormatLocale, type GridController, type GridControllerOptions, type GridFocus, type GridMessages, type GridOptions, type GridState, type GridView, type GridViewInput, type GridViewOptions, type GridViewState, type GroupAggregateDisplay, type GroupByBarVisibility, type GroupByEntry, type GroupByEvent, type GroupByState, type GroupExpansionEvent, type GroupExpansionState, type GroupFilterEntry, HEADER_ROW, type HoverableConfig, KEYBOARD_STEP, type KeyShortcutCapabilities, type NavigationModifiers, type OperatorFilterEntry, type PaginatedRows, type PaginationChangeEvent, type PaginationState, type PaginationWindowEntry, type PredicateFilterEntry, type ResizeMode, type ResolvedColumn, type ResolvedGroupRow, type ResolvedGroupSummaryRow, type ResolvedRow, type RowHeights, type RowPointerEvent, type RowProps, type RowSelectEvent, type RowSelectionChangeEvent, type RowsSelectEvent, type SelectAllState, type SelectIntent, type SelectableConfig, type SelectedCell, type SelectedCellRef, type SelectedColumn, type SelectionCallbacks, type SelectionDiff, type SelectionDiffEvent, type SelectionMode, type SelectionState, type SerializedFilterEntry, type SerializedFilterScalar, type SerializedFilterState, type SerializedGridState, type SerializedGroupFilterEntry, type SerializedOperatorFilterEntry, type SerializedValueFilterEntry, type SortDirection, type TextFilterEntry, type ValueFilterEntry, type VisibleRange, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, applyColumnVisibility, applySelectionIntent, beginColumnResize, buildKeyShortcuts, clampColumnWidth, clampFocus, clearAllFilters, clearSelection, collapseAllGroups, columnValueOptions, compareValues, computeAggregates, createGridController, createGridViewResolver, defaultMessages, defineColumnsFromRows, describeColumnFilter, diffSelection, draftToFilter, expandAllGroups, filterEditorReducer, filterQueryFor, filterRows, fitColumnsToWidth, formatAggregateValue, formatCellValue, getColumnId, groupRowId, groupRows, initialFilterEditorDraft, intentOf, isColumnVisible, isSameCell, matchesQuery, moveColumnBefore, moveGroupByBefore, movesColumn, movesGroupBy, nextFocusForKey, paginateRows, paginationWindow, resolveCell, resolveColumnConstraints, resolveColumnHeaderText, resolveColumnLabel, resolveColumnWidths, resolveColumns, resolveDataColumns, resolveDropBefore, resolveGridView, resolveKeyboardDropTarget, resolveMessages, resolveRowId, resolveRows, resolveShownRows, revertColumnSize, selectAll, selectAllState, selectCell, selectOnly, selectRange, serializeGridState, setColumnFilter, setColumnVisibility, sizeColumnToContent, sortDirectionFor, sortPriorityFor, sortRows, toggleCellSelection, toggleColumnSort, toggleGroupExpansion, toggleSelection, totalColumnWidth, visibleFilterOptions, visibleRange, withGroupAggregates };
+export { type AggregateFn, type AggregateResults, type AggregateSpec, type AggregateState, type Borders, type BuiltInAggregate, type BuiltInCommandIcon, type BuiltInCommandId, type CellSelectEvent, type CellSelectionChangeEvent, type CellSelectionMode, type CellSelectionState, type CellTemplateContext, type ColumnAlignment, type ColumnChooserEntry, type ColumnChooserInput, type ColumnChooserModel, type ColumnChooserToggle, type ColumnConstraints, type ColumnDefinition, type ColumnFilterShape, type ColumnOrderEvent, type ColumnOrderState, type ColumnResizeEvent, type ColumnResizeSession, type ColumnResolveOptions, type ColumnSelectEvent, type ColumnSelectionChangeEvent, type ColumnSizeDefaults, type ColumnSizingState, type ColumnSortEntry, type ColumnSortEvent, type ColumnSortState, type ColumnType, type ColumnValueOption, type ColumnValueOptions, type ColumnValueQuery, type ColumnVisibilityEvent, type ColumnVisibilityState, type ColumnWrapConfig, type ColumnsSelectEvent, type ContextMenuOpenChangeEvent, DEFAULT_COLUMN_SIZES, type DataColumn, type DisplayRow, type DropSide, type FieldPath, type FilterChangeEvent, type FilterEditorAction, type FilterEditorDraft, type FilterEntry, type FilterOperator, type FilterPredicate, type FilterScalar, type FilterState, type FooterTemplateContext, type FormatLocale, type GridCommand, type GridCommandActions, type GridCommandContext, type GridCommandContextInput, type GridCommandEvent, type GridCommandHost, type GridCommandSource, type GridCommandTarget, type GridContextMenuArea, type GridContextMenuEntries, type GridContextMenuOptions, type GridContextMenuRequest, type GridContextMenuTarget, type GridController, type GridControllerOptions, type GridFocus, type GridMessages, type GridOptions, type GridPanelKind, type GridState, type GridToolbarOptions, type GridToolbarTarget, type GridView, type GridViewInput, type GridViewOptions, type GridViewState, type GroupAggregateDisplay, type GroupByBarVisibility, type GroupByEntry, type GroupByEvent, type GroupByState, type GroupExpansionEvent, type GroupExpansionState, type GroupFilterEntry, HEADER_ROW, type HoverableConfig, KEYBOARD_STEP, type KeyShortcutCapabilities, type MenuEntry, type MenuItemEntry, type MenuMove, type MenuResolveOptions, type MenuSubmenuEntry, type NavigationModifiers, type OperatorFilterEntry, type PaginatedRows, type PaginationChangeEvent, type PaginationState, type PaginationWindowEntry, type PredicateFilterEntry, type ResizeMode, type ResolvedColumn, type ResolvedGroupRow, type ResolvedGroupSummaryRow, type ResolvedMenuEntry, type ResolvedMenuItem, type ResolvedMenuSeparator, type ResolvedMenuSubmenu, type ResolvedRow, type ResolvedToolbarButton, type ResolvedToolbarCustom, type ResolvedToolbarItem, type ResolvedToolbarMenu, type ResolvedToolbarSearch, type ResolvedToolbarSpacer, type RowHeights, type RowPointerEvent, type RowProps, type RowSelectEvent, type RowSelectionChangeEvent, type RowsSelectEvent, type SelectAllState, type SelectIntent, type SelectableConfig, type SelectedCell, type SelectedCellRef, type SelectedColumn, type SelectionCallbacks, type SelectionDiff, type SelectionDiffEvent, type SelectionMode, type SelectionState, type SerializedFilterEntry, type SerializedFilterScalar, type SerializedFilterState, type SerializedGridState, type SerializedGroupFilterEntry, type SerializedOperatorFilterEntry, type SerializedValueFilterEntry, type SortDirection, type TextFilterEntry, type ToolbarCustomEntry, type ToolbarEntry, type ToolbarFitInput, type ToolbarResolveOptions, type ToolbarSplit, type ValueFilterEntry, type VisibleRange, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, applyColumnVisibility, applySelectionIntent, beginColumnResize, buildKeyShortcuts, builtInCommands, clampColumnWidth, clampFocus, clearAllFilters, clearSelection, collapseAllGroups, columnValueOptions, compareValues, computeAggregates, contextMenuEntries, createCommandContext, createGridController, createGridViewResolver, defaultContextMenu, defaultMessages, defaultToolbar, defineColumnsFromRows, describeColumnFilter, diffSelection, draftToFilter, expandAllGroups, filterEditorReducer, filterQueryFor, filterRows, fitColumnsToWidth, fitToolbarItems, formatAggregateValue, formatCellValue, getColumnId, groupRowId, groupRows, hasContextMenu, initialFilterEditorDraft, intentOf, isColumnVisible, isPinnedToolbarItem, isSameCell, matchesQuery, moveColumnBefore, moveGroupByBefore, movesColumn, movesGroupBy, nextFocusForKey, nextMenuIndex, paginateRows, paginationWindow, resolveCell, resolveColumnChooser, resolveColumnConstraints, resolveColumnHeaderText, resolveColumnLabel, resolveColumnWidths, resolveColumns, resolveCommands, resolveDataColumns, resolveDropBefore, resolveGridView, resolveKeyboardDropTarget, resolveMenu, resolveMessages, resolveRowId, resolveRows, resolveShownRows, resolveToolbar, revertColumnSize, runCommand, searchTextOf, selectAll, selectAllState, selectCell, selectOnly, selectRange, serializeGridState, setColumnFilter, setColumnVisibility, setSearchText, sizeColumnToContent, sortDirectionFor, sortPriorityFor, sortRows, splitToolbarItems, toggleCellSelection, toggleColumnSort, toggleGroupExpansion, toggleSelection, toolbarEntries, totalColumnWidth, typeaheadIndex, visibleFilterOptions, visibleRange, withGroupAggregates };