@gridkitjs/core 0.10.0 → 0.12.0

package/dist/index.d.ts

@@ -74,12 +74,19 @@ interface ColumnDefinition<Row, Node = string> {
      * same field differently.
      */
     id?: string;
+    /**
+     * The column's name as plain text. The header shows it when there is no
+     * `headerTemplate`, and anything that needs the name as text rather than
+     * markup — a screen-reader announcement, an export — reads it even when
+     * there is one, since a template's output need not be text at all.
+     */
+    header?: string | undefined;
     /** Header content, or a function returning it at render time. */
     headerTemplate?: Node | (() => Node) | undefined;
     /**
-     * Renders this column's cells in place of the raw value at `field`. The
-     * value is still resolved and handed over, so a template that only formats
-     * it never repeats the field path.
+     * Renders this column's cells in place of the text `formatCellValue` makes
+     * of the value at `field`. The raw value is still resolved and handed over,
+     * so a template never repeats the field path.
      */
     cellTemplate?: ((context: CellTemplateContext<Row>) => Node) | undefined;
     /**
@@ -94,6 +101,22 @@ interface ColumnDefinition<Row, Node = string> {
      * defaults to `string`;
      */
     type?: ColumnType;
+    /**
+     * `Intl` options for how this column's values read as text: number options
+     * for a numeric `type`, date options for a date or time one. Passed to
+     * `Intl.NumberFormat`/`Intl.DateTimeFormat` with the grid's `locale` — see
+     * `formatCellValue` for the defaults each `type` starts from. Setting it,
+     * or the grid's `locale`, is what turns that formatting on: without either,
+     * numbers print as-is and dates through `toLocaleString()`.
+     */
+    format?: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | undefined;
+    /**
+     * Turns a value into the text shown for it, in place of `format` and
+     * `type`. Applies wherever this column's values are shown as text — its
+     * cells and its aggregates. `row` is the cell's row, and `undefined` for a
+     * value no single row owns: an aggregate result, or a group header's value.
+     */
+    valueFormatter?: ((value: unknown, row: Row | undefined) => string) | undefined;
     /**
      * Alignment of this column's cells. This package is framework-agnostic so it
      * defaults to `left` (`right` for numbers);
@@ -156,6 +179,20 @@ interface ColumnDefinition<Row, Node = string> {
      * stays a plain string rather than taking the row.
      */
     cellClassName?: string;
+    /**
+     * Whether this column starts out hidden. A hidden column is not rendered
+     * but is still a column of the grid: a sort, filter or grouping on it
+     * still applies, and it keeps its place in the column order. The user
+     * showing or hiding it lives in `ColumnVisibilityState`, which wins over
+     * 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 {
@@ -202,6 +239,26 @@ interface ColumnResolveOptions {
     /** Whether columns may be dragged into the group-by bar, unless a column says otherwise. */
     groupByDraggable?: boolean | undefined;
 }
+/**
+ * How a column's width relates to the grid's.
+ *
+ * `"fit"` keeps the columns filling the grid: the space a column gives up is
+ * handed to the others, and the space it takes comes out of them. `"fixed"`
+ * lets every column keep its own width, so a resize moves one column and
+ * nothing else, and the grid scrolls or leaves a gap accordingly.
+ */
+type ResizeMode = "fit" | "fixed";
+/**
+ * A column as the data stages read it — filtering, sorting, grouping and
+ * aggregating need its id and its definition's `field` and `type`, never its
+ * width. Kept apart from `ResolvedColumn` so that a resize or a viewport
+ * change, which re-resolves every width, leaves these stages' input — and so
+ * their output — untouched. `ResolvedColumn` satisfies it structurally.
+ */
+interface DataColumn<Row, Node = string> {
+    readonly id: string;
+    readonly column: ColumnDefinition<Row, Node>;
+}
 /**
  * A column paired with everything it takes to render it. Each field is a
  * decision made once here rather than in each adapter, so a second framework
@@ -218,9 +275,9 @@ interface ResolvedColumn<Row, Node = string> {
      */
     sized: boolean;
     /**
-     * What the header shows: the column's own `headerTemplate`, or a label read
-     * off the field path. `string` is in the union because that fallback is text
-     * whatever `Node` is bound to.
+     * What the header shows: the column's own `headerTemplate`, else its
+     * `header`, else a label read off the field path. `string` is in the
+     * union because both fallbacks are text whatever `Node` is bound to.
      */
     label: Node | string;
     /** Whether this column can be resized, after the grid-level default. */
@@ -252,6 +309,22 @@ interface ColumnResizeEvent {
     readonly sizing: ColumnSizingState;
     readonly phase: "move" | "end";
 }
+/**
+ * Columns shown (`true`) or hidden (`false`) since the grid started, keyed by
+ * column id. Holding only what changed, the way `ColumnSizingState` does: a
+ * column absent from it follows its definition's `hidden`, so a definition
+ * edited later still takes effect for every column the user never touched.
+ */
+type ColumnVisibilityState = Readonly<Record<string, boolean>>;
+/**
+ * Reports columns shown or hidden. `columnIds` lists every column the one
+ * change touched — showing three columns at once is one event, not three —
+ * and `visibility` is the whole state to persist from.
+ */
+interface ColumnVisibilityEvent {
+    readonly columnIds: readonly string[];
+    readonly visibility: ColumnVisibilityState;
+}
 /**
  * Column ids in the order they render. It need not list every column: one
  * absent from it keeps its position among the definitions and follows those
@@ -484,13 +557,84 @@ interface GroupFilterEntry<Row> {
     readonly combinator: "and" | "or";
     readonly entries: FilterState<Row>;
 }
-type FilterEntry<Row> = TextFilterEntry<Row> | ValueFilterEntry<Row> | PredicateFilterEntry<Row> | GroupFilterEntry<Row>;
+/**
+ * What an `OperatorFilterEntry` asks of a cell. `contains`, `notContains`,
+ * `startsWith` and `endsWith` read the value as text; the rest compare it as
+ * the column's `type` says.
+ */
+type FilterOperator = "eq" | "ne" | "contains" | "notContains" | "startsWith" | "endsWith" | "gt" | "gte" | "lt" | "lte" | "between" | "in" | "isEmpty" | "isNotEmpty";
+/** A value an `OperatorFilterEntry` compares a cell against. */
+type FilterScalar = string | number | boolean | Date | null;
+/**
+ * Matches one column's value by a named operator — plain data, unlike a
+ * predicate, so a filter built from these can be saved and restored.
+ *
+ * `value` is one `FilterScalar` for most operators, a list of them for
+ * `in`, a `[low, high]` pair for `between` (both ends inclusive), and
+ * absent for `isEmpty`/`isNotEmpty`.
+ *
+ * - An empty cell is `null`, `undefined` or `""`. `isEmpty` matches it,
+ *   `isNotEmpty` does not, and so does no other operator — except `ne` and
+ *   `notContains`, which match it: a "not" filter must not quietly drop the
+ *   blanks. Each of those two is the exact opposite of `eq`/`contains`.
+ * - The text operators compare the stringified value, case-insensitively.
+ * - `eq`, `ne`, `gt`, `gte`, `lt`, `lte` and `between` compare as
+ *   `compareValues` does under the column's `type`: numerically,
+ *   chronologically, or as text (case-insensitively, like a query). A cell
+ *   of another kind — a string in a number column — is never equal, greater
+ *   or less.
+ * - `in` matches the values grouping would put in the same group.
+ * - A date column reads a string `value` as `new Date(value)`.
+ * - A `value` of the wrong kind for the column — a string against a number
+ *   column, a missing pair for `between` — matches no row at all, as a
+ *   `ValueFilterEntry` of the wrong type doesn't.
+ */
+interface OperatorFilterEntry<Row> {
+    readonly columnId: FieldPath<Row> | (string & {});
+    readonly operator: FilterOperator;
+    readonly value?: FilterScalar | readonly FilterScalar[];
+}
+type FilterEntry<Row> = TextFilterEntry<Row> | ValueFilterEntry<Row> | PredicateFilterEntry<Row> | OperatorFilterEntry<Row> | GroupFilterEntry<Row>;
 /**
  * The active filter, every entry ANDed together at the top level — nest a
  * `GroupFilterEntry` for anything that needs OR. Empty for an unfiltered
  * grid, mirroring `ColumnSortState`'s empty array for "no sort".
  */
 type FilterState<Row> = readonly FilterEntry<Row>[];
+/**
+ * A `ValueFilterEntry` as JSON holds it: a `Date` value becomes its ISO
+ * string, which restoring turns back into a `Date`.
+ */
+interface SerializedValueFilterEntry<Row> extends FilterEntryBase<Row> {
+    readonly value: number | boolean | string;
+}
+/** A `FilterScalar` as JSON holds it: a `Date` becomes its ISO string. */
+type SerializedFilterScalar = string | number | boolean | null;
+/**
+ * An `OperatorFilterEntry` as JSON holds it: each `Date` becomes its ISO
+ * string, which restoring turns back into a `Date` when the column is a
+ * date, date-time or time column.
+ */
+interface SerializedOperatorFilterEntry<Row> {
+    readonly columnId: FieldPath<Row> | (string & {});
+    readonly operator: FilterOperator;
+    readonly value?: SerializedFilterScalar | readonly SerializedFilterScalar[];
+}
+/** A `GroupFilterEntry` whose entries are serialised too. */
+interface SerializedGroupFilterEntry<Row> {
+    readonly combinator: "and" | "or";
+    readonly entries: SerializedFilterState<Row>;
+}
+/**
+ * A filter entry that survives `JSON.stringify`: every kind but a predicate,
+ * which is a function and cannot be written down.
+ */
+type SerializedFilterEntry<Row> = TextFilterEntry<Row> | SerializedValueFilterEntry<Row> | SerializedOperatorFilterEntry<Row> | SerializedGroupFilterEntry<Row>;
+type SerializedFilterState<Row> = readonly SerializedFilterEntry<Row>[];
+/** Reports a filter change whole — the filter to persist from. */
+interface FilterChangeEvent<Row> {
+    readonly filter: FilterState<Row>;
+}
 /**
  * Ids selected, in the order they were selected — so the most recent is last,
  * and a consumer wanting only that reads `at(-1)` rather than tracking it
@@ -523,6 +667,13 @@ interface SelectableConfig {
     rows?: SelectionMode | undefined;
     columns?: SelectionMode | undefined;
     cells?: CellSelectionMode | undefined;
+    /**
+     * Whether a plain click on a row toggles it rather than selecting it
+     * alone — a checklist, where picking rows one after another should not
+     * need Ctrl held down. Shift still selects a range and Ctrl/Cmd still
+     * toggles. Rows only: a column or cell click is unchanged.
+     */
+    toggleOnClick?: boolean | undefined;
 }
 /**
  * What an interaction means for the selection, read off its modifiers once at
@@ -582,6 +733,24 @@ interface SelectedCell<Row, Node = string> {
     /** Read off the column's field path — the value a `cellTemplate` receives. */
     readonly value: unknown;
 }
+/**
+ * Reports a click or double-click on a data row. Carries the modifiers and
+ * button rather than the browser's own event, so a handler reads the same
+ * payload whichever renderer drew the row.
+ */
+interface RowPointerEvent<Row> {
+    readonly row: ResolvedRow<Row>;
+    /** The column of the cell the pointer was on, or `null` when it was on no cell. */
+    readonly columnId: string | null;
+    readonly native: {
+        readonly ctrlKey: boolean;
+        readonly metaKey: boolean;
+        readonly shiftKey: boolean;
+        readonly altKey: boolean;
+        /** Which button was pressed, numbered as `MouseEvent.button` numbers them — `0` for the main one. */
+        readonly button: number;
+    };
+}
 /** Reports one row selected or deselected. */
 interface RowSelectEvent<Row> {
     readonly row: ResolvedRow<Row>;
@@ -639,6 +808,1513 @@ interface CellSelectionChangeEvent<Row, Node = string> {
     readonly deselected: SelectedCell<Row, Node> | null;
     readonly selection: CellSelectionState;
 }
+/**
+ * Everything about a grid the user can change, one slice per feature. Each
+ * slice is the same `*State` type its own `default*` prop and change event
+ * already use, so state read from here can be fed straight back as a default.
+ */
+interface GridState<Row> {
+    readonly columnSizing: ColumnSizingState;
+    readonly columnOrder: ColumnOrderState;
+    readonly columnVisibility: ColumnVisibilityState;
+    readonly columnSort: ColumnSortState;
+    readonly filter: FilterState<Row>;
+    readonly groupBy: GroupByState;
+    readonly groupExpansion: GroupExpansionState;
+    readonly pagination: PaginationState;
+    readonly rowSelection: SelectionState;
+    readonly columnSelection: SelectionState;
+    readonly cellSelection: CellSelectionState;
+}
+/**
+ * `GridState` as `serializeGridState` writes it: safe to pass through
+ * `JSON.stringify` and back, and to hand straight to `restoreState`.
+ */
+interface SerializedGridState<Row> extends Omit<GridState<Row>, "filter"> {
+    readonly filter: SerializedFilterState<Row>;
+}
+/**
+ * The slices the view is derived from: every one but the selections, which
+ * change what is highlighted and never what is shown. A whole `GridState`
+ * is one.
+ */
+type GridViewState<Row> = Omit<GridState<Row>, "rowSelection" | "columnSelection" | "cellSelection">;
+/**
+ * The settings that shape the view but are not user state: what the grid is
+ * configured to do, plus the one measurement — `viewportWidth` — that fitting
+ * columns needs from the page. Every field falls back to the same default
+ * the React grid's matching prop does.
+ */
+interface GridViewOptions<Row> {
+    /** Whether `pageRows` is one page of `displayRows` rather than all of it. Defaults to `false`. */
+    readonly paginated?: boolean | undefined;
+    readonly aggregates?: AggregateState<Row> | undefined;
+    /** Defaults to `"inline"`. */
+    readonly groupAggregateDisplay?: GroupAggregateDisplay | undefined;
+    readonly columnSizeDefaults?: Partial<ColumnSizeDefaults> | undefined;
+    readonly resizableColumns?: boolean | undefined;
+    readonly reorderableColumns?: boolean | undefined;
+    readonly groupByDraggableColumns?: boolean | undefined;
+    /** Defaults to `"fit"`, which only takes effect once `viewportWidth` is known. */
+    readonly resizeMode?: ResizeMode | undefined;
+    /**
+     * The width, in px, `"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.
+     */
+    readonly viewportWidth?: number | null | undefined;
+}
+/** What `resolveGridView` derives the view from. */
+interface GridViewInput<Row, Node = string> {
+    readonly rows: readonly Row[];
+    readonly getRowId?: ((row: Row, index: number) => string) | undefined;
+    readonly columns: readonly ColumnDefinition<Row, Node>[];
+    readonly state: GridViewState<Row>;
+    readonly options: GridViewOptions<Row>;
+}
+/**
+ * What the user is looking at, derived once from `GridViewInput` — every
+ * list a renderer draws, and the ones an export, a toolbar or a status line
+ * reads, so none of them composes the pipeline for itself.
+ */
+interface GridView<Row, Node = string> {
+    /** Every column, hidden ones included, ordered but not sized — what the data stages read. */
+    readonly dataColumns: readonly DataColumn<Row, Node>[];
+    /** The columns as rendered: visible, ordered and sized. */
+    readonly columns: readonly ResolvedColumn<Row, Node>[];
+    /** The rows, filtered then sorted. */
+    readonly rows: readonly ResolvedRow<Row>[];
+    /** `rows` grouped, with each group's aggregates attached — every page of it. */
+    readonly displayRows: readonly DisplayRow<Row>[];
+    /** The current page of `displayRows`; all of it when not paginated. */
+    readonly pageRows: readonly DisplayRow<Row>[];
+    /** `pageRows` narrowed to its data rows, in display order — what a range selection spans. */
+    readonly displayDataRows: readonly ResolvedRow<Row>[];
+    /** `1` when not paginated. */
+    readonly pageCount: number;
+    /** `state.pagination.pageIndex` clamped into range; `0` when not paginated. */
+    readonly pageIndex: number;
+    /** Every aggregate over all of `rows`, ungrouped and unpaginated. */
+    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, 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
+ * `locale`.
+ */
+interface GridMessages {
+    /** The pager's accessible name. */
+    pagerLabel: string;
+    previousPage: string;
+    nextPage: string;
+    /** The page-size control's label. */
+    pageSizeLabel: string;
+    /** A numbered pager button's accessible name. */
+    pageButtonLabel: (page: number) => string;
+    /**
+     * The compact pager's status, and what a page change announces. `page`
+     * counts from one, and is `0` while there are no pages.
+     */
+    pageStatus: (page: number, pageCount: number) => string;
+    /** The row shown while `infiniteScroll` loads more. */
+    loadingMore: string;
+    /** A boolean cell's text. */
+    booleanTrue: string;
+    booleanFalse: string;
+    /** What a group header names a group of missing values. */
+    blankGroupValue: string;
+    /** The group-by bar's accessible name. */
+    groupByBarLabel: string;
+    /** Shown in an empty group-by bar a header can be dragged into. */
+    groupByBarPlaceholder: string;
+    /** A group-by chip's accessible name. `level` counts from one. */
+    groupByChipLabel: (columnName: string, level: number, levelCount: number) => string;
+    /** A group-by chip's remove button's accessible name. */
+    removeGroupBy: (columnName: string) => string;
+    /** Announced when a resize ends, `width` in whole pixels. */
+    columnResized: (columnName: string, width: number) => string;
+    /** Announced when a column is moved. `position` counts from one. */
+    columnMoved: (columnName: string, position: number, columnCount: number) => string;
+    /** Announced when a column is sorted. `key` is its place in the sort, from one. */
+    columnSorted: (columnName: string, direction: SortDirection, key: number, keyCount: number) => string;
+    /** Announced when a column leaves the sort. */
+    sortCleared: (columnName: string) => string;
+    /** Announced when a column is grouped by. `level` counts from one. */
+    groupedBy: (columnName: string, level: number, levelCount: number) => string;
+    /** Announced when a column leaves the grouping. */
+    groupingRemoved: (columnName: string) => string;
+    groupExpanded: string;
+    groupCollapsed: string;
+    allGroupsExpanded: string;
+    allGroupsCollapsed: string;
+    /** Announced when one change selects or deselects more than one row or column. */
+    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;
+/**
+ * `messages` over the defaults — every key the grid needs, whichever the
+ * caller gave. The defaults themselves, same object, when it gave none, so a
+ * renderer memoising on the result does not see a change that is not one.
+ */
+declare function resolveMessages(messages: Partial<GridMessages> | undefined): GridMessages;
+
+/**
+ * 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;
+/**
+ * The text an aggregate result reads as — a footer cell, a group's subtotal
+ * — through `formatCellValue`, so once a `format` or `locale` asks for it a
+ * `sum` of a currency column reads as currency and a `max` of a date column
+ * as a date. `column` is `undefined` for a spec naming a column the grid
+ * does not have, which then formats by its value alone.
+ *
+ * Until then a numeric result reads through `toLocaleString()`, with digit
+ * grouping, where a cell prints its number as-is: that is how a grid has
+ * always shown its totals, and a sum easily runs into the thousands.
+ */
+declare function formatAggregateValue<Row>(value: unknown, spec: AggregateSpec<Row>, column: ColumnDefinition<Row, unknown> | undefined, locale?: FormatLocale): string;
+
+/** Which cell borders a grid draws. */
+type Borders = "horizontal" | "vertical" | "all" | "none";
+/** Which hover highlighting a grid shows. Every member defaults to on. */
+interface HoverableConfig {
+    rows?: boolean;
+    columns?: boolean;
+    cells?: boolean;
+}
+/**
+ * How the group-by bar's visibility follows the active grouping. `"always"`
+ * renders it even with an empty `groupBy` — a fixed drop target and a
+ * constant reminder grouping exists. `"never"` never renders it, for a grid
+ * driving `groupBy` entirely by its own UI (a header toggle, `Alt+ArrowDown`)
+ * or programmatically. `"auto"` renders it once `groupBy` is non-empty, or
+ * while a header drag eligible to drop into it is in progress — so there is
+ * always somewhere to drop the very first column, even from a fully empty
+ * grouping.
+ */
+type GroupByBarVisibility = "always" | "auto" | "never";
+/**
+ * What `getRowProps` adds to a data row: a class for the theme or the
+ * app's own stylesheet to target, and `data-*` attributes for a test or a
+ * script to find the row by. No inline style — styling belongs to the
+ * stylesheet, which a class already reaches.
+ */
+interface RowProps {
+    className?: string | undefined;
+    /**
+     * Set on the row alongside the grid's own `data-gridkit-*` attributes,
+     * which win over one of the same name — the grid finds its rows by them.
+     */
+    attributes?: Readonly<Record<`data-${string}`, string>> | undefined;
+}
+/**
+ * Every setting of a grid that names no renderer's types: the data, what the
+ * user may do with it, the state it starts in and the callbacks that report
+ * changes. A renderer's own props are this plus what only it can express —
+ * React's `columns` (whose templates return `ReactNode`), its pager and
+ * infinite-scroll templates, its `ref` — so two renderers cannot drift apart
+ * on what a setting is called or what it means.
+ */
+interface GridOptions<Row> {
+    dataSource?: readonly Row[] | undefined;
+    /**
+     * A row's stable identity, for state keyed by it. Defaults to the row's
+     * position, which is enough for a static grid but ties that state to where a
+     * row sits rather than to the row — so anything sorting, filtering or paging
+     * its data should give one.
+     *
+     * Called for every row on every change to `dataSource`, so it should be
+     * cheap and stable; an inline arrow is fine, one that re-reads the data is
+     * not.
+     */
+    getRowId?: ((row: Row, index: number) => string) | undefined;
+    /**
+     * A class and `data-*` attributes for each data row, worked out from the
+     * row — an `is-overdue` class, a `data-status` to style or find it by.
+     * Group headers and summary rows are not passed to it.
+     *
+     * Called for each data row as it renders, so it should be cheap. A row
+     * whose result reads the same as last time is not redrawn for it, so an
+     * inline arrow returning a fresh object each time is fine.
+     */
+    getRowProps?: ((row: ResolvedRow<Row>) => RowProps) | undefined;
+    /**
+     * Called when a data row is clicked, after the click has changed the
+     * selection — so a handler reading the selection sees the new one. Not
+     * called for a group header, whose click expands or collapses it.
+     */
+    onRowClick?: ((event: RowPointerEvent<Row>) => void) | undefined;
+    /**
+     * Called once when a data row is double-clicked — the usual "open this
+     * record" gesture. The two clicks before it still report through
+     * `onRowClick` and select as clicks do.
+     */
+    onRowDoubleClick?: ((event: RowPointerEvent<Row>) => void) | undefined;
+    borders?: Borders | undefined;
+    hoverable?: HoverableConfig | undefined;
+    /**
+     * Which parts of the grid the user may select, and how many of each —
+     * `{ rows: "multiple", cells: "single" }`. A cell addresses one value, so it
+     * has no `"multiple"`.
+     *
+     * Off by default, unlike `hoverable`: selection claims the click, which a
+     * grid that only displays data should not do. Give `getRowId` alongside it
+     * for data that sorts, filters or pages, or a selection follows the position
+     * rather than the row.
+     */
+    selectable?: SelectableConfig | undefined;
+    /** Row ids selected to start with, keyed as `getRowId` resolves them. Uncontrolled. */
+    defaultRowSelection?: SelectionState | undefined;
+    /**
+     * The selected row ids, controlled — applied as given, changed only through
+     * the row selection callbacks (`onRowSelectionChange` carries the whole
+     * next state). Leave it `undefined` for the grid to keep it itself,
+     * starting from `defaultRowSelection`.
+     */
+    rowSelection?: SelectionState | undefined;
+    /** Column ids selected to start with. Uncontrolled. */
+    defaultColumnSelection?: SelectionState | undefined;
+    /**
+     * The selected column ids, controlled — changed only through the column
+     * selection callbacks. Leave it `undefined` for the grid to keep it.
+     */
+    columnSelection?: SelectionState | undefined;
+    /** The cell selected to start with. Uncontrolled. */
+    defaultCellSelection?: CellSelectionState | undefined;
+    /**
+     * The selected cell, controlled — `null` for none, changed only through
+     * the cell selection callbacks. Leave it `undefined` for the grid to keep
+     * it.
+     */
+    cellSelection?: CellSelectionState | undefined;
+    /** Whether columns can be dragged wider, unless a column says otherwise. */
+    resizableColumns?: boolean | undefined;
+    /**
+     * Whether columns can be dragged into a new position, unless a column says
+     * otherwise. Turning it off leaves an order the user already made in place.
+     */
+    reorderableColumns?: boolean | undefined;
+    /**
+     * Whether columns fill the grid's width or sit at their own. Defaults to
+     * `"fit"`, under which columns the user has sized keep their width and the
+     * rest share what is left.
+     */
+    resizeMode?: ResizeMode | undefined;
+    /** Column widths to start from, keyed by column id. Uncontrolled. */
+    defaultColumnSizing?: ColumnSizingState | undefined;
+    /**
+     * Column widths, controlled — applied as given, changed only through
+     * `onColumnResize`, whose `sizing` is the next state. Leave it
+     * `undefined` for the grid to keep the widths itself, starting from
+     * `defaultColumnSizing`.
+     */
+    columnSizing?: ColumnSizingState | undefined;
+    /**
+     * Column ids in the order to start in. Uncontrolled, and partial: ids it
+     * omits keep their position among `columns` and follow those it lists.
+     */
+    defaultColumnOrder?: ColumnOrderState | undefined;
+    /**
+     * The column order, controlled — applied as given, changed only through
+     * `onColumnOrderChange`. Leave it `undefined` for the grid to keep the
+     * order itself, starting from `defaultColumnOrder`.
+     */
+    columnOrder?: ColumnOrderState | undefined;
+    /**
+     * Columns shown (`true`) or hidden (`false`) to start with, keyed by
+     * column id, over each definition's own `hidden`. Uncontrolled.
+     */
+    defaultColumnVisibility?: ColumnVisibilityState | undefined;
+    /**
+     * Which columns are shown, controlled — applied as given, changed only
+     * through `onColumnVisibilityChange`. Leave it `undefined` for the grid to
+     * keep it itself, starting from `defaultColumnVisibility`.
+     */
+    columnVisibility?: ColumnVisibilityState | undefined;
+    /**
+     * Called once when columns are shown or hidden, with every column that one
+     * change touched. A call that changes nothing does not call it.
+     */
+    onColumnVisibilityChange?: ((event: ColumnVisibilityEvent) => void) | undefined;
+    /**
+     * Sizes applied to columns that do not set their own — the width they start
+     * at and the bounds they may be resized between. Distinct from
+     * `defaultColumnSizing`, which sets specific columns' starting widths.
+     */
+    columnSizeDefaults?: Partial<ColumnSizeDefaults> | undefined;
+    /**
+     * Called as the user resizes a column. Fires continuously with
+     * `phase: "move"` and once on release with `phase: "end"` — the latter being
+     * the one to persist. Auto-fit does not call it; it reports user intent only.
+     */
+    onColumnResize?: ((event: ColumnResizeEvent) => void) | undefined;
+    /**
+     * Called once when the user drops a column somewhere new. A drop that leaves
+     * the order as it was does not call it.
+     */
+    onColumnOrderChange?: ((event: ColumnOrderEvent) => void) | undefined;
+    /**
+     * Whether columns can be sorted by clicking their header toggle, unless a
+     * column says otherwise. Shift-click stacks a column into the sort instead
+     * of replacing it.
+     */
+    sortableColumns?: boolean | undefined;
+    /** The sort to start with, in priority order. Uncontrolled. */
+    defaultColumnSort?: ColumnSortState | undefined;
+    /**
+     * The sort, controlled: the grid shows exactly this, and a header click
+     * only asks for a change through `onColumnSortChange`, which takes effect
+     * once this prop follows it. Leave it `undefined` for the grid to keep the
+     * sort itself, starting from `defaultColumnSort`.
+     */
+    columnSort?: ColumnSortState | undefined;
+    /**
+     * Called once when the user changes the sort — a toggle, a stack, or a
+     * clear back to "none".
+     */
+    onColumnSortChange?: ((event: ColumnSortEvent) => void) | undefined;
+    /**
+     * Whether columns can be grouped by — a header's click/`Alt+ArrowDown`
+     * toggle — unless a column says otherwise. The grouping itself still
+     * applies when this is off, via `defaultGroupBy` or the imperative API;
+     * this only gates that one interaction, the same way `sortableColumns`
+     * gates the sort toggle without disabling `defaultColumnSort`. Independent
+     * of `groupByBarVisibility` and `groupByDraggableColumns`, which gate the
+     * bar and the drag-in gesture respectively.
+     */
+    groupableColumns?: boolean | undefined;
+    /**
+     * Whether a groupable header shows its group-toggle icon, unless a column
+     * says otherwise. Purely a rendering choice: `Alt+ArrowDown` keeps working
+     * on a groupable header with the icon hidden.
+     */
+    groupToggleIconColumns?: boolean | undefined;
+    /**
+     * Whether a column's header may be dragged into the group-by bar to add
+     * it to the grouping, unless a column says otherwise. Independent of
+     * `groupableColumns`: a column can be groupable via its header's
+     * click/keyboard toggle, via this drag, both, or neither.
+     */
+    groupByDraggableColumns?: boolean | undefined;
+    /** How the group-by bar's visibility follows the active grouping. */
+    groupByBarVisibility?: GroupByBarVisibility | undefined;
+    /** The group-by stack to start with, outer to inner. Uncontrolled. */
+    defaultGroupBy?: GroupByState | undefined;
+    /**
+     * The group-by stack, controlled — applied as given, changed only through
+     * `onGroupByChange`. Leave it `undefined` for the grid to keep it itself,
+     * starting from `defaultGroupBy`.
+     */
+    groupBy?: GroupByState | undefined;
+    /**
+     * Called once when the user changes the group-by stack — adding, removing,
+     * or reordering a level.
+     */
+    onGroupByChange?: ((event: GroupByEvent) => void) | undefined;
+    /** Group keys collapsed to start with — every other group starts expanded. Uncontrolled. */
+    defaultGroupExpansion?: GroupExpansionState | undefined;
+    /**
+     * The collapsed groups, controlled — applied as given, changed only
+     * through `onGroupExpansionChange`. Leave it `undefined` for the grid to
+     * keep it itself, starting from `defaultGroupExpansion`.
+     */
+    groupExpansion?: GroupExpansionState | undefined;
+    /** Called once when the user expands or collapses a group, or every group at once. */
+    onGroupExpansionChange?: ((event: GroupExpansionEvent) => void) | undefined;
+    /** The filter to start with — every applied entry, ANDed together. Uncontrolled. */
+    defaultFilter?: FilterState<Row> | undefined;
+    /**
+     * The filter, controlled — applied as given, changed only through
+     * `onFilterChange`. Leave it `undefined` for the grid to keep it itself,
+     * starting from `defaultFilter`.
+     */
+    filter?: FilterState<Row> | undefined;
+    /**
+     * Called once when the filter changes — through `setFilter` for now, as
+     * the grid has no filter UI of its own yet.
+     */
+    onFilterChange?: ((event: FilterChangeEvent<Row>) => void) | undefined;
+    /**
+     * Whether the grid's rows are split into pages. A page's unit is a
+     * top-level group or a bare data row, never a leaf row — a group is never
+     * split across a page boundary. Off by default, matching `sortableColumns`.
+     */
+    paginated?: boolean | undefined;
+    /**
+     * The page and page size to start on. Uncontrolled. Defaults to
+     * `{ pageIndex: 0, pageSize: 25 }` when `paginated` is on and this is
+     * omitted.
+     */
+    defaultPagination?: PaginationState | undefined;
+    /**
+     * The page and page size, controlled — applied as given, changed only
+     * through `onPaginationChange`. Leave it `undefined` for the grid to keep
+     * them itself, starting from `defaultPagination`.
+     *
+     * The grid sends an uncontrolled pagination back to the first page when
+     * the filter, sort or grouping changes; a controlled one is the parent's
+     * to reset alongside that change. Until it does, the grid shows the last
+     * page that exists rather than an empty one.
+     */
+    pagination?: PaginationState | undefined;
+    /** Called once when the user changes the page or the page size. */
+    onPaginationChange?: ((event: PaginationChangeEvent) => void) | undefined;
+    /**
+     * Aggregates to compute — a subtotal per group (rendered in that group's
+     * header) plus a grand total over the whole filtered/grouped dataset
+     * (rendered in a footer). Always computed over every row, never scoped to
+     * the current page. A plain controlled prop, unlike `sort`/`filter`/
+     * `groupBy`/`pagination`: there is no built-in UI for a user to add or
+     * remove an aggregate interactively, so there is no `defaultAggregates`/
+     * `onAggregatesChange` pair to go with it.
+     */
+    aggregates?: AggregateState<Row> | undefined;
+    /**
+     * Where a group's own aggregate results render. `"inline"` (the default)
+     * keeps them as text in the group header, next to its leaf-row count.
+     * `"row"` instead renders a dedicated row after that group's last visible
+     * entry, with each aggregate's value in the `<td>` for its own column —
+     * the same alignment the grand-total footer's own cells have. Has no
+     * effect when `aggregates` is empty or omitted.
+     */
+    groupAggregateDisplay?: GroupAggregateDisplay | undefined;
+    /**
+     * Bounds the row area's height, independently scrollable — the grid's own
+     * chrome (group-by bar, header, footer, pager) stays outside it and
+     * always visible. A number is pixels; a string is passed through as a CSS
+     * length (e.g. "60vh"). Omitted, the body's height stays content-driven,
+     * same as today.
+     */
+    height?: number | string | undefined;
+    /**
+     * Renders only the rows near the current scroll position rather than every
+     * row at once — for a dataset too large to mount in full. Requires
+     * `height` to be set; a grid without a bounded body has no viewport to
+     * window rows against (a dev-time console warning fires when it's
+     * missing). Off by default, matching every other opt-in behavior here.
+     */
+    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,
+     * 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.
+     */
+    messages?: Partial<GridMessages> | undefined;
+    /**
+     * 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.
+     */
+    contextMenu?: boolean | GridContextMenuOptions<Row> | undefined;
+    /**
+     * 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.
+     */
+    onContextMenuOpenChange?: ((event: ContextMenuOpenChangeEvent) => void) | undefined;
+    /**
+     * 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`.
+     */
+    commands?: readonly GridCommand<Row>[] | undefined;
+    /**
+     * 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.
+     */
+    onCommand?: ((event: GridCommandEvent) => void) | undefined;
+    /**
+     * 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`.
+     */
+    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;
+    /**
+     * 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;
+}
+
+/**
+ * Creates the state container for one grid — see `GridController`. Hold one
+ * per grid for its whole life: it keeps the uncontrolled slices, and its view
+ * is memoised across calls the way `createGridViewResolver`'s is.
+ */
+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
@@ -654,8 +2330,11 @@ declare function alignmentForType(type: ColumnType): ColumnAlignment;
  *
  * Order follows `Object.entries`, which lists integer-like keys first
  * regardless of the order they were written in.
+ *
+ * `Node` is whatever the caller's renderer draws: an inferred column sets no
+ * template, so it suits any.
  */
-declare function defineColumnsFromRows<Row>(rows: readonly Row[]): readonly ColumnDefinition<Row>[];
+declare function defineColumnsFromRows<Row, Node = string>(rows: readonly Row[]): readonly ColumnDefinition<Row, Node>[];
 /**
  * The key state about a column is stored under, and the key it renders with.
  * Every such lookup goes through here so the two can never disagree.
@@ -674,16 +2353,26 @@ declare function getColumnId<Row>(column: ColumnDefinition<Row, unknown>): strin
 declare function resolveRowId<Row>(row: Row, index: number, getRowId?: (row: Row, index: number) => string): string;
 /**
  * What a column's header shows: its own `headerTemplate`, called first if it is
- * a function, or else a label read off the field path — `"Application.Id"`
- * reading as `"Application Id"`.
+ * a function, or else its plain-text `header`, or else a label read off the
+ * field path.
  */
 declare function resolveColumnLabel<Row, Node>(column: ColumnDefinition<Row, Node>): Node | string;
+/**
+ * A column's name as text, for wherever markup will not do — an
+ * announcement, an export. Its `header` first, even beside a
+ * `headerTemplate`, since a template's output need not be text; then the
+ * label `resolveColumnLabel` gives, when that is a string; then the label
+ * read off the field path.
+ */
+declare function resolveColumnHeaderText<Row>(column: ColumnDefinition<Row, unknown>): string;
 /** Which of a column header's keyboard interactions to announce. */
 interface KeyShortcutCapabilities {
     reorderable: boolean;
     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
@@ -751,6 +2440,14 @@ declare function nextFocusForKey(key: string, modifiers: NavigationModifiers, fo
  * was made against.
  */
 declare function applyColumnOrder<Row, Node>(columns: readonly ColumnDefinition<Row, Node>[], order: ColumnOrderState): readonly ColumnDefinition<Row, Node>[];
+/**
+ * `columns` in the order `order` gives, each paired with its id — the
+ * width-free column list the data stages (filter, sort, group, aggregate)
+ * read. Ordered here, ahead of sizing, so every later stage sees the one
+ * already-ordered list and no part of the grid has to know a reorder
+ * happened.
+ */
+declare function resolveDataColumns<Row, Node>(columns: readonly ColumnDefinition<Row, Node>[], order: ColumnOrderState): readonly DataColumn<Row, Node>[];
 /**
  * The order with `movedId` lifted out and put back in front of `beforeId`, or
  * at the end when that is `null`.
@@ -840,11 +2537,19 @@ declare function selectCell(selection: CellSelectionState, cell: SelectedCellRef
  * Ctrl-click, matching `toggleSelection`.
  */
 declare function toggleCellSelection(selection: CellSelectionState, cell: SelectedCellRef, mode: CellSelectionMode): CellSelectionState;
-/** The intent a click or key press carries, by the modifiers held with it. */
+/**
+ * The intent a click or key press carries, by the modifiers held with it.
+ *
+ * `toggleOnClick` makes the unmodified press a toggle — the
+ * `selectable.toggleOnClick` checklist behaviour — leaving Shift and Ctrl
+ * to mean what they always do.
+ */
 declare function intentOf(event: {
     ctrlKey: boolean;
     metaKey: boolean;
     shiftKey: boolean;
+}, options?: {
+    toggleOnClick?: boolean | undefined;
 }): SelectIntent;
 /**
  * The transform an intent asks for. A function rather than a branch inside
@@ -970,7 +2675,7 @@ declare function toggleColumnSort(sort: ColumnSortState, columnId: string, optio
  * columns absent from `columns` — a stored sort tolerates a column removed
  * from the definition the same way a stored `ColumnOrderState` does.
  */
-declare function sortRows<Row>(rows: readonly ResolvedRow<Row>[], sort: ColumnSortState, columns: readonly ResolvedColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
+declare function sortRows<Row>(rows: readonly ResolvedRow<Row>[], sort: ColumnSortState, columns: readonly DataColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
 
 /**
  * Whether `value`, stringified, matches `query`'s SQL LIKE-style pattern —
@@ -987,8 +2692,8 @@ declare function matchesQuery(value: unknown, query: string): boolean;
  * This column's current text query, or the global entry's when `columnId`
  * is omitted; `null` if no `TextFilterEntry` names it — including when the
  * entry that exists for that key is a `ValueFilterEntry`/
- * `PredicateFilterEntry`/`GroupFilterEntry` instead, since none of those
- * hold a query string to report.
+ * `PredicateFilterEntry`/`OperatorFilterEntry`/`GroupFilterEntry` instead,
+ * since none of those hold a query string to report.
  */
 declare function filterQueryFor<Row>(filter: FilterState<Row>, columnId?: FieldPath<Row> | (string & {})): string | null;
 /**
@@ -1022,7 +2727,7 @@ declare function clearAllFilters<Row>(filter: FilterState<Row>): FilterState<Row
  * columns absent from `columns` — a stored filter tolerates a column
  * removed from the definition the same way a stored `ColumnSortState` does.
  */
-declare function filterRows<Row>(rows: readonly ResolvedRow<Row>[], filter: FilterState<Row>, columns: readonly ResolvedColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
+declare function filterRows<Row>(rows: readonly ResolvedRow<Row>[], filter: FilterState<Row>, columns: readonly DataColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
 
 /**
  * This group's id, from its path. Every group-id producer/consumer in this
@@ -1055,7 +2760,7 @@ declare function groupRowId(path: readonly unknown[]): string;
  * columns absent from `columns` — a stored grouping tolerates a column
  * removed from the definition the same way a stored `ColumnSortState` does.
  */
-declare function groupRows<Row>(rows: readonly ResolvedRow<Row>[], groupBy: GroupByState, expansion: GroupExpansionState, columns: readonly ResolvedColumn<Row, unknown>[]): readonly DisplayRow<Row>[];
+declare function groupRows<Row>(rows: readonly ResolvedRow<Row>[], groupBy: GroupByState, expansion: GroupExpansionState, columns: readonly DataColumn<Row, unknown>[]): readonly DisplayRow<Row>[];
 /**
  * The expansion with `groupId` collapsed if it was expanded, or expanded if
  * it was collapsed.
@@ -1070,6 +2775,9 @@ declare function expandAllGroups(expansion: GroupExpansionState): GroupExpansion
  * absent from `rows`) keeps whatever expansion it already had rather than
  * being forced closed too; expanding that ancestor again reveals it exactly
  * as it was left.
+ *
+ * Group headers only: a summary row (`groupAggregateDisplay: "row"`) carries
+ * its group's id too, and counting it would list that group twice.
  */
 declare function collapseAllGroups<Row>(rows: readonly DisplayRow<Row>[]): GroupExpansionState;
 /**
@@ -1111,7 +2819,7 @@ declare function movesGroupBy(groupBy: GroupByState, columnId: string, beforeCol
  * order-preserving predicate and sort is a stable total order over whatever
  * it's handed, so the final order is identical either way.
  */
-declare function resolveShownRows<Row>(rows: readonly ResolvedRow<Row>[], filter: FilterState<Row>, sort: ColumnSortState, columns: readonly ResolvedColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
+declare function resolveShownRows<Row>(rows: readonly ResolvedRow<Row>[], filter: FilterState<Row>, sort: ColumnSortState, columns: readonly DataColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
 /**
  * `ids` resolved back to the rows behind them, keyed by `rowsById`.
  *
@@ -1187,8 +2895,290 @@ declare function paginationWindow(currentPage: number, pageCount: number, option
  * shared singleton — matching this codebase's general avoidance of shared
  * mutable module state.
  */
-declare function computeAggregates<Row>(rows: readonly Row[], specs: AggregateState<Row>, columns: readonly ResolvedColumn<Row, unknown>[]): AggregateResults;
-declare function withGroupAggregates<Row>(displayRows: readonly DisplayRow<Row>[], flatRows: readonly ResolvedRow<Row>[], groupBy: GroupByState, specs: AggregateState<Row>, columns: readonly ResolvedColumn<Row, unknown>[], display?: GroupAggregateDisplay): readonly DisplayRow<Row>[];
+declare function computeAggregates<Row>(rows: readonly Row[], specs: AggregateState<Row>, columns: readonly DataColumn<Row, unknown>[]): AggregateResults;
+declare function withGroupAggregates<Row>(displayRows: readonly DisplayRow<Row>[], flatRows: readonly ResolvedRow<Row>[], groupBy: GroupByState, specs: AggregateState<Row>, columns: readonly DataColumn<Row, unknown>[], display?: GroupAggregateDisplay): readonly DisplayRow<Row>[];
+
+/**
+ * Whether `column` is shown: what the user last chose for it, if anything,
+ * else what its definition says. The one place that precedence is decided,
+ * so the view and an imperative "is it showing?" cannot disagree.
+ */
+declare function isColumnVisible<Row>(column: ColumnDefinition<Row, unknown>, visibility: ColumnVisibilityState): boolean;
+/**
+ * `columns` without the hidden ones, in the same order. `columns` itself when
+ * every column is shown — the common case — so a stage memoised on this
+ * output sees nothing change.
+ */
+declare function applyColumnVisibility<Row, Node>(columns: readonly DataColumn<Row, Node>[], visibility: ColumnVisibilityState): readonly DataColumn<Row, Node>[];
+/**
+ * `visibility` with each of `columnIds` shown (`visible: true`) or hidden.
+ * Only a column whose visibility actually changes gets an entry, and ids
+ * naming no column are ignored, so asking to show what is already showing
+ * hands back `visibility` itself — the same reference, for a caller deciding
+ * whether anything happened.
+ */
+declare function setColumnVisibility<Row>(columns: readonly DataColumn<Row, unknown>[], visibility: ColumnVisibilityState, columnIds: readonly string[], visible: boolean): ColumnVisibilityState;
+
+/**
+ * What one column's filter looks like to an editor — which of its forms can
+ * show it, or that none can.
+ *
+ * - `"none"`: no entry touches the column.
+ * - `"values"`: a checklist — one `in` entry, optionally OR-grouped with an
+ *   `isEmpty` on the same column (`includeBlanks`).
+ * - `"conditions"`: one or two operator entries on the column (any but
+ *   `in`), at the top level (ANDed) or alone in one group with its
+ *   combinator.
+ * - `"custom"`: anything else that touches the column — a text query, a
+ *   predicate, a group spanning several columns. An editor shows it as
+ *   such, and applying an editor's draft replaces it.
+ */
+type ColumnFilterShape<Row> = {
+    readonly kind: "none";
+} | {
+    readonly kind: "values";
+    readonly values: readonly FilterScalar[];
+    readonly includeBlanks: boolean;
+} | {
+    readonly kind: "conditions";
+    readonly conditions: readonly OperatorFilterEntry<Row>[];
+    readonly combinator: "and" | "or";
+} | {
+    readonly kind: "custom";
+};
+/** One distinct value a column holds, as a checklist offers it. */
+interface ColumnValueOption {
+    readonly value: Exclude<FilterScalar, null>;
+    /** The value as the column prints it — what a search matches against. */
+    readonly label: string;
+    /** How many rows hold it, among the rows the other columns' filters keep. */
+    readonly count: number;
+}
+/** What `columnValueOptions` narrows its list by. */
+interface ColumnValueQuery {
+    /** Keeps the values whose label contains this, ignoring case. */
+    readonly search?: string;
+    /** Keeps at most this many values, first in sorted order. */
+    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`. */
+    readonly options: readonly ColumnValueOption[];
+    /** How many values matched the search, before `limit` cut them. */
+    readonly total: number;
+    /** Whether `limit` left values out. */
+    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,
+ * changed by `filterEditorReducer` and turned into a filter by
+ * `draftToFilter` only when the user applies it — so cancelling is just
+ * dropping the draft.
+ */
+interface FilterEditorDraft<Row> {
+    /** Which half of the draft `draftToFilter` applies: the last one changed. */
+    readonly mode: "values" | "conditions";
+    /** Every value the editor offers, from `columnValueOptions`. */
+    readonly options: readonly ColumnValueOption[];
+    /** 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 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";
+    readonly search: string;
+} | {
+    readonly type: "toggleValue";
+    readonly value: FilterScalar;
+}
+/** Checks every value the search shows, or unchecks them once all are. */
+ | {
+    readonly type: "toggleAll";
+} | {
+    readonly type: "setIncludeBlanks";
+    readonly includeBlanks: boolean;
+} | {
+    readonly type: "setConditions";
+    readonly conditions: readonly OperatorFilterEntry<Row>[];
+    /** Keeps the draft's own when omitted. */
+    readonly combinator?: "and" | "or";
+}
+/** Back to "no filter": every value checked, no conditions, no search. */
+ | {
+    readonly type: "clear";
+};
+/** A select-all checkbox's state over the values the search shows. */
+type SelectAllState = "checked" | "unchecked" | "mixed";
+/**
+ * How `filter` filters `columnId`, as one of the forms an editor can show —
+ * see `ColumnFilterShape`. Entries about other columns don't count, nor do
+ * entries across every column (a global search).
+ */
+declare function describeColumnFilter<Row>(filter: FilterState<Row>, columnId: string): ColumnFilterShape<Row>;
+/**
+ * The distinct values `columnId` holds, for a checklist editor: each with
+ * its label and how many rows hold it.
+ *
+ * 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 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
+ * list to `initialFilterEditorDraft`, whose search needs no recount.
+ */
+declare function columnValueOptions<Row>(rows: readonly Row[], dataColumns: readonly DataColumn<Row, unknown>[], filter: FilterState<Row>, columnId: string, query?: ColumnValueQuery): ColumnValueOptions;
+/**
+ * A draft showing `shape` over `values` — what an editor opens with. A
+ * column with no filter, or one only a custom editor could show, opens with
+ * every value checked; a checklist with its own values checked, kept even
+ * when the other filters now hide them; conditions as they are.
+ */
+declare function initialFilterEditorDraft<Row>(shape: ColumnFilterShape<Row>, values: ColumnValueOptions): FilterEditorDraft<Row>;
+/** The options the draft's search shows — those a select-all acts on. */
+declare function visibleFilterOptions<Row>(draft: FilterEditorDraft<Row>): readonly ColumnValueOption[];
+/**
+ * The select-all checkbox's state: whether every value the search shows is
+ * checked, none is, or some are — blanks included while nothing is
+ * searched.
+ */
+declare function selectAllState<Row>(draft: FilterEditorDraft<Row>): SelectAllState;
+/**
+ * The next draft after `action` — a plain reducer, so a renderer can hold
+ * the draft in whatever state it has (`useReducer`, a signal, a store).
+ * Changing a value or the blanks switches the draft to its checklist;
+ * setting conditions switches it to them.
+ */
+declare function filterEditorReducer<Row>(draft: FilterEditorDraft<Row>, action: FilterEditorAction<Row>): FilterEditorDraft<Row>;
+/**
+ * `current` with `columnId`'s filter replaced by what `draft` holds — what
+ * applying an editor sets. Every entry about the column goes (custom ones
+ * included); the draft's entries take the place of the first, so the rest
+ * keep their order.
+ *
+ * A checklist with everything checked is no filter at all, and a partial
+ * pick is one `in` entry, OR-grouped with an `isEmpty` when blanks are
+ * kept. One condition is stored as itself, two as a group with the
+ * draft's combinator. Returns `current` itself when nothing changes.
+ */
+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.
@@ -1217,11 +3207,11 @@ interface VisibleRange {
  *
  * `O(n)` in `heights.length`. Deliberately not a Fenwick tree or a
  * binary-searchable prefix-sum structure — that optimization belongs in the
- * mutable React-side cache that already owns mutability
- * (`useRowVirtualizer`), not in this pure function's contract, and is not
+ * mutable height cache that already owns mutability (`createRowVirtualizer`
+ * in `@gridkitjs/dom`), not in this pure function's contract, and is not
  * worth taking on until a profiled scenario actually shows it matters at
  * realistic row counts.
  */
 declare function visibleRange(heights: RowHeights, estimatedHeight: number, scrollTop: number, viewportHeight: number, overscan: number): VisibleRange;
 
-export { type AggregateFn, type AggregateResults, type AggregateSpec, type AggregateState, type BuiltInAggregate, type CellSelectEvent, type CellSelectionChangeEvent, type CellSelectionMode, type CellSelectionState, type CellTemplateContext, type ColumnAlignment, type ColumnConstraints, type ColumnDefinition, 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 ColumnWrapConfig, type ColumnsSelectEvent, DEFAULT_COLUMN_SIZES, type DisplayRow, type DropSide, type FieldPath, type FilterEntry, type FilterPredicate, type FilterState, type FooterTemplateContext, type GridFocus, type GroupAggregateDisplay, type GroupByEntry, type GroupByEvent, type GroupByState, type GroupExpansionEvent, type GroupExpansionState, type GroupFilterEntry, HEADER_ROW, KEYBOARD_STEP, type KeyShortcutCapabilities, type NavigationModifiers, type PaginatedRows, type PaginationChangeEvent, type PaginationState, type PaginationWindowEntry, type PredicateFilterEntry, type ResolvedColumn, type ResolvedGroupRow, type ResolvedGroupSummaryRow, type ResolvedRow, type RowHeights, type RowSelectEvent, type RowSelectionChangeEvent, type RowsSelectEvent, type SelectIntent, type SelectableConfig, type SelectedCell, type SelectedCellRef, type SelectedColumn, type SelectionDiff, type SelectionMode, type SelectionState, type SortDirection, type TextFilterEntry, type ValueFilterEntry, type VisibleRange, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, applySelectionIntent, beginColumnResize, buildKeyShortcuts, clampColumnWidth, clampFocus, clearAllFilters, clearSelection, collapseAllGroups, compareValues, computeAggregates, defineColumnsFromRows, diffSelection, expandAllGroups, filterQueryFor, filterRows, fitColumnsToWidth, getColumnId, groupRowId, groupRows, intentOf, isSameCell, matchesQuery, moveColumnBefore, moveGroupByBefore, movesColumn, movesGroupBy, nextFocusForKey, paginateRows, paginationWindow, resolveCell, resolveColumnConstraints, resolveColumnLabel, resolveColumnWidths, resolveColumns, resolveDropBefore, resolveKeyboardDropTarget, resolveRowId, resolveRows, resolveShownRows, revertColumnSize, selectAll, selectCell, selectOnly, selectRange, setColumnFilter, sizeColumnToContent, sortDirectionFor, sortPriorityFor, sortRows, toggleCellSelection, toggleColumnSort, toggleGroupExpansion, toggleSelection, totalColumnWidth, 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 };