@gridkitjs/core 0.10.0 → 0.11.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,14 @@ 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;
 }
 /** Which parts of a column opt out of the grid's default single-line text. */
 interface ColumnWrapConfig {
@@ -202,6 +233,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 +269,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 +303,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 +551,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 +661,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 +727,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 +802,828 @@ 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;
+}
+
+/**
+ * Every string a grid shows or announces of its own — the pager, the group-by
+ * bar, the loading row, the text of a boolean or missing value, and the
+ * live-region announcements — so a grid can speak a language other than
+ * English. A message that names something takes a function, so a translation
+ * can put the name where its own grammar wants it.
+ *
+ * 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;
+}
+/** 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;
+
+/** 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,
+     * and every live-region announcement. Keys left out keep their default.
+     * Formatting is `locale`'s, not this.
+     */
+    messages?: Partial<GridMessages> | undefined;
+}
+/**
+ * Reported as the user selects. Every one of these is fanned out from a single
+ * diff of the transition it describes, so no two can disagree about what one
+ * interaction did.
+ *
+ * Kept apart from `GridOptions` because the column payloads carry resolved
+ * columns, whose labels are whatever a renderer's `headerTemplate` returns —
+ * `Node` is that renderer's node type.
+ */
+interface SelectionCallbacks<Row, Node = string> {
+    /** Called once per row newly selected. The last call names the last row. */
+    onRowSelect?: ((event: RowSelectEvent<Row>) => void) | undefined;
+    /** Called once with every row one interaction selected. */
+    onRowsSelect?: ((event: RowsSelectEvent<Row>) => void) | undefined;
+    onRowDeselect?: ((event: RowSelectEvent<Row>) => void) | undefined;
+    onRowsDeselect?: ((event: RowsSelectEvent<Row>) => void) | undefined;
+    /**
+     * Called once per change with what it added, what it removed and everything
+     * selected after it — the one to persist from.
+     */
+    onRowSelectionChange?: ((event: RowSelectionChangeEvent<Row>) => void) | undefined;
+    onColumnSelect?: ((event: ColumnSelectEvent<Row, Node>) => void) | undefined;
+    onColumnsSelect?: ((event: ColumnsSelectEvent<Row, Node>) => void) | undefined;
+    onColumnDeselect?: ((event: ColumnSelectEvent<Row, Node>) => void) | undefined;
+    onColumnsDeselect?: ((event: ColumnsSelectEvent<Row, Node>) => void) | undefined;
+    onColumnSelectionChange?: ((event: ColumnSelectionChangeEvent<Row, Node>) => void) | undefined;
+    onCellSelect?: ((event: CellSelectEvent<Row, Node>) => void) | undefined;
+    onCellDeselect?: ((event: CellSelectEvent<Row, Node>) => void) | undefined;
+    onCellSelectionChange?: ((event: CellSelectionChangeEvent<Row, Node>) => void) | undefined;
+}
+
+/**
+ * A row or column selection change by id — see
+ * `GridControllerOptions.onSelectionDiff`.
+ */
+interface SelectionDiffEvent extends SelectionDiff {
+    /** Which selection changed. */
+    readonly target: "rows" | "columns";
+    /** The whole selection after the change. */
+    readonly selection: SelectionState;
+}
+/**
+ * What `createGridController` is given: the grid's options and selection
+ * callbacks, plus what a renderer supplies that is not a setting — the column
+ * definitions, whose templates name the renderer's own node type, the width
+ * the viewport measured, and a hook for its own selection feedback.
+ */
+interface GridControllerOptions<Row, Node = string> extends GridOptions<Row>, SelectionCallbacks<Row, Node> {
+    /**
+     * The columns to show. Omitted or empty, one column is inferred per field
+     * of `dataSource` — see `defineColumnsFromRows`.
+     */
+    columns?: readonly ColumnDefinition<Row, Node>[] | undefined;
+    /**
+     * The width, in px, `resizeMode: "fit"` fills. `null` or absent before it
+     * has been measured, or where there is no viewport at all (an export in
+     * Node), and then columns keep their resolved widths.
+     */
+    viewportWidth?: number | null | undefined;
+    /**
+     * Called once per row or column selection change, after the selection
+     * callbacks, with the change by id — every id it added or removed,
+     * including those with no row on screen (on another page, in a collapsed
+     * group, filtered out), which the callbacks' resolved rows leave out. For a
+     * renderer's own feedback, such as a live region announcing how many rows
+     * are selected; an application reads the selection callbacks instead.
+     */
+    onSelectionDiff?: ((event: SelectionDiffEvent) => void) | undefined;
+}
+/**
+ * A grid without a renderer: its state, the view derived from it, and every
+ * action that changes it. A renderer creates one per grid, hands it the
+ * current options on each update, draws `getView()` and calls the actions
+ * from its event handlers, so no renderer decides anything the user can see.
+ *
+ * Each slice of `GridState` is controlled or not on its own, the way a form
+ * input is: given as an option (`columnSort`), the grid shows that value and
+ * an action only asks for a change through the slice's callback
+ * (`onColumnSortChange`); left out, the controller keeps the slice itself,
+ * starting from its default (`defaultColumnSort`).
+ *
+ * Every action follows the same steps: work out the next value; stop if it
+ * is the very object the slice already holds; keep it, unless the slice is
+ * controlled; report it through the slice's callback; then call every
+ * subscriber, synchronously. The setters (`setColumnSort` and the like) also
+ * stop for a value equal to the current one, so restoring what is already
+ * there reports nothing.
+ *
+ * Every member is a plain function bound to its grid, safe to hand around on
+ * its own — `onClick={controller.nextPage}`.
+ */
+interface GridController<Row, Node = string> {
+    readonly getOptions: () => GridControllerOptions<Row, Node>;
+    /**
+     * Replaces the options, as a renderer does with its current props on every
+     * update; calling it again with equal options changes nothing. A controlled
+     * slice takes its new value from here.
+     *
+     * Does not call subscribers: a renderer calls this while it updates, and
+     * draws the result itself — a subscriber called mid-update would update
+     * mid-update too. A renderer that also tells other listeners about it does
+     * so once its update is done.
+     */
+    readonly setOptions: (options: GridControllerOptions<Row, Node>) => void;
+    /** Every slice as the grid now applies it. The same object until a slice changes. */
+    readonly getState: () => GridState<Row>;
+    /** What the user is looking at — see `resolveGridView`. The same object until something in it changes. */
+    readonly getView: () => GridView<Row, Node>;
+    /**
+     * Calls `listener` after each action that got as far as reporting a
+     * change. Returns the function that unsubscribes it.
+     */
+    readonly subscribe: (listener: () => void) => () => void;
+    /**
+     * Puts back state saved earlier — from `getState()`, or from
+     * `serializeGridState` and back through JSON. Every slice given is set as
+     * its own `set*` action would set it, so each that changes fires its
+     * callback and a controlled one only asks; slices left out keep their value.
+     * Subscribers are called once, after every slice is in place, and a
+     * restored pagination is kept even when the same call changed the sort,
+     * filter or grouping that would otherwise send it back to the first page.
+     */
+    readonly restoreState: (saved: Partial<GridState<Row>> | Partial<SerializedGridState<Row>>) => void;
+    /**
+     * Replaces the column widths. Reported through `onColumnResize` as the
+     * `"end"` of a resize of the first column whose width changed, at its new
+     * width — or, when its entry was removed, the width its definition gives
+     * it. Equal widths report nothing.
+     */
+    readonly setColumnSizing: (sizing: ColumnSizingState) => void;
+    /**
+     * Sets one column's width, as a resize gesture does: `"move"` while the
+     * gesture lasts, `"end"` once it is over. Never skipped for an unchanged
+     * width, so a drag held against a column's minimum still reports every
+     * move.
+     */
+    readonly resizeColumn: (columnId: string, width: number, phase: "move" | "end") => void;
+    /**
+     * Ends a resize gesture by putting its column back as it was when the
+     * gesture began — `startSizing` is the sizing state then, `startWidth` the
+     * width the column was drawn at — keeping any other column's change made in
+     * the meantime. Reported as the gesture's `"end"`, at `startWidth`.
+     */
+    readonly cancelColumnResize: (columnId: string, startSizing: ColumnSizingState, startWidth: number) => void;
+    /**
+     * Replaces the column order. Reported through `onColumnOrderChange` naming
+     * the first column whose position changed; an equal order reports nothing.
+     */
+    readonly setColumnOrder: (order: ColumnOrderState) => void;
+    /**
+     * Moves a column in front of `beforeId`, or to the end when that is
+     * `null`, among every column — hidden ones keep their place. A move that
+     * changes nothing reports nothing.
+     */
+    readonly moveColumn: (columnId: string, beforeId: string | null) => void;
+    /**
+     * Replaces the column visibility state. Reported through
+     * `onColumnVisibilityChange` with every column whose entry changed; an
+     * equal state reports nothing.
+     */
+    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;
+    /**
+     * 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. */
+    readonly goToPage: (pageIndex: number) => void;
+    readonly nextPage: () => void;
+    readonly previousPage: () => void;
+    /** Changes the page size and goes back to the first page. */
+    readonly setPageSize: (pageSize: number) => void;
+}
+
+/**
+ * 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>;
 
 /**
  * How a column of `type` aligns by default. Numeric types align right so that
@@ -654,8 +1639,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,10 +1662,18 @@ 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;
@@ -751,6 +1747,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 +1844,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 +1982,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 +1999,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 +2034,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 +2067,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 +2082,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 +2126,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 +2202,223 @@ 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;
+
+/**
+ * `resolveGridView`, memoised per stage: each stage remembers its last
+ * inputs and returns its last output when none of them changed identity, so
+ * a call that changes one slice of state recomputes only what depends on
+ * it. The data stages (filter → sort → group → aggregate → paginate) read
+ * `dataColumns`, which carry no width, so a resize or a viewport change
+ * leaves `rows`, `displayRows`, `pageRows`, `displayDataRows` and
+ * `grandTotal` reference-equal to the previous call's — only `columns` is
+ * new. The view object itself is reused when every field is unchanged, so a
+ * snapshot-based renderer sees nothing to re-render.
+ *
+ * Hold one resolver per grid and call it with the current input every time
+ * the view is needed; the memo only pays off across calls to the same one.
+ */
+declare function createGridViewResolver<Row, Node = string>(): (input: GridViewInput<Row, Node>) => GridView<Row, Node>;
+/**
+ * What the user is looking at, derived from the rows, the columns, the
+ * grid's state and its options in one call: rows filtered → sorted →
+ * grouped → aggregated → paginated, and columns ordered → hidden → sized.
+ * The one function a renderer, an export or a toolbar calls instead of
+ * composing the stages itself, so none of them can disagree about what is
+ * shown.
+ *
+ * Unmemoised — a one-off resolver. A renderer that derives the view on every
+ * change holds a `createGridViewResolver()` instead.
+ */
+declare function resolveGridView<Row, Node = string>(input: GridViewInput<Row, Node>): GridView<Row, Node>;
+
+/**
+ * `state` in a form that survives `JSON.stringify` and back unchanged, for
+ * saving a layout — to local storage, a URL, a user's profile — and handing
+ * it to `restoreState` later. Every slice is plain data already except the
+ * filter: a `Date` value or operand is written as its ISO string, and a
+ * predicate entry, being a function, cannot be written at all and is left
+ * out with a `console.error` naming its column.
+ */
+declare function serializeGridState<Row>(state: GridState<Row>): SerializedGridState<Row>;
+
+/**
+ * What one column's filter looks like to an editor — which of its forms can
+ * show it, or that none can.
+ *
+ * - `"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;
+}
+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;
+}
+/**
+ * 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 grouping keys them. */
+    readonly checked: ReadonlyMap<string, FilterScalar>;
+    readonly includeBlanks: boolean;
+    readonly conditions: readonly OperatorFilterEntry<Row>[];
+    readonly combinator: "and" | "or";
+}
+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 grouping
+ * tells them apart, ordered as the column sorts, labelled as its cells
+ * print; 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>;
 
 /**
  * One entry per row: its measured height once known, `undefined` until then.
@@ -1217,11 +2447,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 CellSelectEvent, type CellSelectionChangeEvent, type CellSelectionMode, type CellSelectionState, type CellTemplateContext, type ColumnAlignment, type ColumnConstraints, type ColumnDefinition, type ColumnFilterShape, type ColumnOrderEvent, type ColumnOrderState, type ColumnResizeEvent, type ColumnResizeSession, type ColumnResolveOptions, type ColumnSelectEvent, type ColumnSelectionChangeEvent, type ColumnSizeDefaults, type ColumnSizingState, type ColumnSortEntry, type ColumnSortEvent, type ColumnSortState, type ColumnType, type ColumnValueOption, type ColumnValueOptions, type ColumnValueQuery, type ColumnVisibilityEvent, type ColumnVisibilityState, type ColumnWrapConfig, type ColumnsSelectEvent, DEFAULT_COLUMN_SIZES, type DataColumn, type DisplayRow, type DropSide, type FieldPath, type FilterChangeEvent, type FilterEditorAction, type FilterEditorDraft, type FilterEntry, type FilterOperator, type FilterPredicate, type FilterScalar, type FilterState, type FooterTemplateContext, type FormatLocale, type GridController, type GridControllerOptions, type GridFocus, type GridMessages, type GridOptions, type GridState, type GridView, type GridViewInput, type GridViewOptions, type GridViewState, type GroupAggregateDisplay, type GroupByBarVisibility, type GroupByEntry, type GroupByEvent, type GroupByState, type GroupExpansionEvent, type GroupExpansionState, type GroupFilterEntry, HEADER_ROW, type HoverableConfig, KEYBOARD_STEP, type KeyShortcutCapabilities, type NavigationModifiers, type OperatorFilterEntry, type PaginatedRows, type PaginationChangeEvent, type PaginationState, type PaginationWindowEntry, type PredicateFilterEntry, type ResizeMode, type ResolvedColumn, type ResolvedGroupRow, type ResolvedGroupSummaryRow, type ResolvedRow, type RowHeights, type RowPointerEvent, type RowProps, type RowSelectEvent, type RowSelectionChangeEvent, type RowsSelectEvent, type SelectAllState, type SelectIntent, type SelectableConfig, type SelectedCell, type SelectedCellRef, type SelectedColumn, type SelectionCallbacks, type SelectionDiff, type SelectionDiffEvent, type SelectionMode, type SelectionState, type SerializedFilterEntry, type SerializedFilterScalar, type SerializedFilterState, type SerializedGridState, type SerializedGroupFilterEntry, type SerializedOperatorFilterEntry, type SerializedValueFilterEntry, type SortDirection, type TextFilterEntry, type ValueFilterEntry, type VisibleRange, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, applyColumnVisibility, applySelectionIntent, beginColumnResize, buildKeyShortcuts, clampColumnWidth, clampFocus, clearAllFilters, clearSelection, collapseAllGroups, columnValueOptions, compareValues, computeAggregates, createGridController, createGridViewResolver, defaultMessages, defineColumnsFromRows, describeColumnFilter, diffSelection, draftToFilter, expandAllGroups, filterEditorReducer, filterQueryFor, filterRows, fitColumnsToWidth, formatAggregateValue, formatCellValue, getColumnId, groupRowId, groupRows, initialFilterEditorDraft, intentOf, isColumnVisible, isSameCell, matchesQuery, moveColumnBefore, moveGroupByBefore, movesColumn, movesGroupBy, nextFocusForKey, paginateRows, paginationWindow, resolveCell, resolveColumnConstraints, resolveColumnHeaderText, resolveColumnLabel, resolveColumnWidths, resolveColumns, resolveDataColumns, resolveDropBefore, resolveGridView, resolveKeyboardDropTarget, resolveMessages, resolveRowId, resolveRows, resolveShownRows, revertColumnSize, selectAll, selectAllState, selectCell, selectOnly, selectRange, serializeGridState, setColumnFilter, setColumnVisibility, sizeColumnToContent, sortDirectionFor, sortPriorityFor, sortRows, toggleCellSelection, toggleColumnSort, toggleGroupExpansion, toggleSelection, totalColumnWidth, visibleFilterOptions, visibleRange, withGroupAggregates };