@gridkitjs/core 0.0.0-dev-20261106222533

package/dist/index.d.ts

@@ -0,0 +1,4229 @@
+/**
+ * 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;
+}
+
+/** How a column's values compare, which decides what an operand must be. */
+type ValueKind = "number" | "boolean" | "date" | "text";
+
+/**
+ * The kind of value a column filters as — what decides which conditions a
+ * filter menu offers on it, how their operators read, and what a typed
+ * operand must be.
+ */
+type FilterOperatorFamily = ValueKind;
+/**
+ * The family a column of `type` falls in: `"number"` for the numeric
+ * types, `"date"` for date, date-time and time, `"boolean"`, and `"text"`
+ * for everything else. It is the filter engine's own reading of `type`, so
+ * a menu never offers a condition the column would compare differently.
+ */
+declare function filterOperatorFamily(type: ColumnType | undefined): FilterOperatorFamily;
+/**
+ * The conditions a filter menu offers on a column of `type`, in the order it
+ * lists them, unless the column names its own. Never `in`: a list of values
+ * is the checklist's to pick, not a condition's to type.
+ */
+declare function defaultFilterOperators(type: ColumnType | undefined): readonly FilterOperator[];
+/**
+ * How many operands `operator` takes — how many inputs a condition row
+ * shows: none for the blanks, `between`'s two ends, one for the rest. `in`
+ * takes one list, which only a checklist writes.
+ */
+declare function filterOperandArity(operator: FilterOperator): 0 | 1 | 2;
+/**
+ * The operand a condition input's `text` stands for on a column of `type`,
+ * read as the column filters — or `undefined` when the text is empty or
+ * doesn't read as one, which an editor shows as a value still to fix.
+ *
+ * - Text is kept as typed, spaces and all.
+ * - A number reads with a point for decimals, as a number input gives it:
+ *   `"12abc"` and `"1,5"` read as nothing rather than as a guess.
+ * - A date reads as a date input gives it, `yyyy-mm-dd`, at that day's
+ *   local midnight; or as a date-time input does, `yyyy-mm-ddThh:mm`, at
+ *   that local time.
+ * - A boolean reads `"true"` or `"false"`.
+ */
+declare function parseFilterOperand(text: string, type: ColumnType | undefined): Exclude<FilterScalar, null> | undefined;
+/**
+ * The text a condition input shows for `value` — `parseFilterOperand`'s
+ * inverse, for opening a condition already applied. A date reads back in
+ * the form its column's input takes: the day alone on a `"date"` column,
+ * the day and time on a `"dateTime"` or `"time"` one. A blank operand is
+ * empty, and one that isn't a date on a date column — a string set in code
+ * that names none — shows as it is, for the user to fix.
+ */
+declare function formatFilterOperand(value: FilterScalar | undefined, type: ColumnType | undefined): string;
+
+/** 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;
+/**
+ * The text a group's own value reads as — a group header's name, and the
+ * label an export writes for it: as the grouped column's cells read it,
+ * except that a missing value reads `messages.blankGroupValue` ("(blank)"),
+ * since an empty label would leave the group looking unnamed rather than
+ * named "nothing".
+ */
+declare function formatGroupValue<Row>(value: unknown, column: ColumnDefinition<Row, unknown>, locale: FormatLocale, messages: Pick<GridMessages, "booleanTrue" | "booleanFalse" | "blankGroupValue">): string;
+
+/**
+ * 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`, and so do the counts the defaults print: "1,204 of 10,000 rows"
+ * under `"en"`, "1.204 of 10.000 rows" under `"de-DE"`.
+ */
+interface GridMessages {
+    /** The pager's accessible name. */
+    pagerLabel: string;
+    /** The pager button to the first page; drawn as an icon, so this is its accessible name. */
+    firstPage: string;
+    /** The pager button to the previous page; its accessible name. */
+    previousPage: string;
+    /** The pager button to the next page; its accessible name. */
+    nextPage: string;
+    /** The pager button to the last page; its accessible name. */
+    lastPage: 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;
+    /**
+     * A condition's operator, as a filter menu lists it. `family` is the
+     * column's (`filterOperatorFamily`), so a date can read `lt` as "Before"
+     * where a number reads "Less than".
+     */
+    filterOperatorLabel: (operator: FilterOperator, family: FilterOperatorFamily) => string;
+    /** A filter checklist's item for the column's blank cells. */
+    filterBlanks: string;
+    /**
+     * Shown in place of a filter checklist whose column holds more values
+     * than `filterMenu.valueLimit`, until something is searched.
+     */
+    filterSearchFirst: (total: number) => string;
+    /** Shown under a searched filter checklist `filterMenu.valueLimit` cut short: how many matches it left out. */
+    filterMoreValues: (count: number) => string;
+    /** `filter.open`, which opens a column's filter menu. */
+    openFilter: string;
+    /** `filter.clear`, and the filter menu's button doing the same: clears one column's filter. */
+    clearColumnFilter: string;
+    /** A column's filter menu's accessible name. */
+    filterMenuLabel: (columnName: string) => string;
+    /** What a column header is described as while its column is filtered. */
+    columnFiltered: string;
+    /** The filter menu's button applying what it holds. */
+    applyFilter: string;
+    /** The filter menu's button closing it without applying. */
+    cancelFilter: string;
+    /**
+     * Shown in a filter menu for a filter its editor cannot show — a
+     * predicate, a text query, a group across columns — which applying
+     * replaces.
+     */
+    customFilter: string;
+    /** Announced when a filter menu applies: how many rows the filter keeps, of how many. */
+    filterResults: (shown: number, total: number) => string;
+    /** The accessible name of one of a filter menu's conditions. `position` counts from one. */
+    filterConditionLabel: (position: number) => string;
+    /** The accessible name of a condition's operator picker. */
+    filterOperatorFieldLabel: string;
+    /** The accessible name of a condition's value box. */
+    filterValueLabel: string;
+    /** The accessible name of a `between` condition's first value box, its lower end. */
+    filterFromLabel: string;
+    /** The accessible name of a `between` condition's second value box, its upper end. */
+    filterToLabel: string;
+    /** The accessible name of the choice joining a filter menu's two conditions. */
+    filterCombinatorLabel: string;
+    /** Joins two conditions: a row has to meet both. */
+    filterAnd: string;
+    /** Joins two conditions: a row has to meet either. */
+    filterOr: string;
+    /**
+     * Shown under a filter menu's conditions when one's value is missing or
+     * doesn't read as its column's `family` (`filterOperatorFamily`) — "Enter
+     * a number" on a number column.
+     */
+    filterValueInvalid: (family: FilterOperatorFamily) => string;
+    /** The accessible name of a filter checklist's search box. */
+    filterSearchLabel: string;
+    /** The checkbox above a filter checklist checking every value its search shows. */
+    filterSelectAll: string;
+    /** The accessible name of a filter checklist's list of values. */
+    filterValuesLabel: string;
+    /**
+     * Shown above a filter checklist whose column is filtered by conditions,
+     * which checking values replaces.
+     */
+    filterByCondition: string;
+    /**
+     * The excel editor's button opening the conditions its column offers, and
+     * that menu's accessible name — "Number filters" on a number column, by
+     * its `family` (`filterOperatorFamily`).
+     */
+    filterOperatorMenu: (family: FilterOperatorFamily) => string;
+    /** The button taking the excel editor from a condition back to its checklist. */
+    filterBackToValues: string;
+    /** The toolbar's `"export"` dropdown, listing the export commands. */
+    exportMenu: string;
+    /** `export.csv` */
+    exportCsv: string;
+    /** `export.json` */
+    exportJson: string;
+    /** `export.xlsx`, shown once an xlsx writer is registered. */
+    exportXlsx: string;
+    /** `export.pdf`, shown once a PDF writer is registered. */
+    exportPdf: string;
+    /** `exportSelection.csv`: the selected rows only. */
+    exportSelectionCsv: string;
+    /** `exportSelection.json` */
+    exportSelectionJson: string;
+    /** `exportSelection.xlsx` */
+    exportSelectionXlsx: string;
+    /** Announced when an export's writer fails, so no file is saved. */
+    exportFailed: string;
+    /** `copy.cell` */
+    copyCell: string;
+    /** `copy.row` */
+    copyRow: string;
+    /** `copy.selection` */
+    copySelection: string;
+    /** Announced once a copy is on the clipboard. */
+    copied: (count: number, unit: "cells" | "rows" | "columns") => string;
+    /** Announced when the browser refuses the clipboard, so nothing was copied. */
+    copyFailed: string;
+    /** `print` */
+    print: string;
+}
+/**
+ * The grid's own English, its counts printed in `locale`'s digits —
+ * "1,204 of 10,000 rows" under `"en"`, "1.204 of 10.000 rows" under
+ * `"de-DE"`. Without a locale, the runtime's own; that one is
+ * `defaultMessages`.
+ */
+declare function createDefaultMessages(locale?: FormatLocale): GridMessages;
+/** The grid's own English, which `messages` replaces key by key. */
+declare const defaultMessages: GridMessages;
+/**
+ * `messages` over the defaults for `locale` — every key the grid needs,
+ * whichever the caller gave, the defaults counting in `locale`'s digits. The
+ * defaults themselves, same object for the same locale, 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, locale?: FormatLocale): GridMessages;
+
+/**
+ * A value an export stores as it is rather than as text — what a cell's
+ * `ExportCell.value` holds and a column's `exportValue` returns. Narrow on
+ * purpose: these are the kinds every format has a reading for (a spreadsheet
+ * number, date or boolean cell; a JSON scalar), so nothing a writer cannot
+ * represent reaches it.
+ */
+type ExportScalar = string | number | boolean | Date | null;
+/**
+ * One cell of an export, in both of its readings. `text` is what the grid
+ * shows — CSV, the clipboard and print write it, so a file reads as the
+ * screen does. `value` is the typed value a spreadsheet stores, so a number
+ * stays a number a formula can sum rather than text that looks like one.
+ */
+interface ExportCell {
+    readonly value: ExportScalar;
+    readonly text: string;
+}
+/**
+ * A column of an export, settled once so that no writer reads a column
+ * definition for itself. `type` and `format` pass through for a writer that
+ * keeps typed values, which derives its own number or date format from them.
+ */
+interface ExportColumn {
+    readonly id: string;
+    /** The column's name as text — `resolveColumnHeaderText`, never markup. */
+    readonly header: string;
+    /** The column's `type`, `"string"` when it has none. */
+    readonly type: ColumnType;
+    readonly format?: Intl.NumberFormatOptions | Intl.DateTimeFormatOptions | undefined;
+    /** How the column's cells align, after falling back to its type. */
+    readonly alignment: ColumnAlignment;
+    /** Width in px: as rendered for a visible column, as it would start for a hidden one. */
+    readonly width: number;
+}
+/** One row of data: a cell per `ExportTable.columns` entry, in that order. */
+interface ExportDataRow {
+    readonly kind: "data";
+    readonly rowId: string;
+    readonly cells: readonly ExportCell[];
+}
+/**
+ * A group header. `label` is the header's text, `"Region: West"`; `cells`
+ * holds the group's aggregates under their own columns when the grid shows
+ * them inline in the header, and is empty text elsewhere — a cell per
+ * column either way, so a writer can lay it out like any other row.
+ */
+interface ExportGroupRow {
+    readonly kind: "group";
+    /** Nesting depth, 0 for a top-level group. */
+    readonly level: number;
+    readonly groupId: string;
+    readonly label: string;
+    /** Data rows under this group, at every depth. */
+    readonly count: number;
+    readonly cells: readonly ExportCell[];
+}
+/**
+ * A group's aggregates as a row of their own, after everything in the group
+ * — present where the grid shows them that way (`groupAggregateDisplay:
+ * "row"`), and at the same `level` as its group.
+ */
+interface ExportGroupSummaryRow {
+    readonly kind: "groupSummary";
+    readonly level: number;
+    readonly cells: readonly ExportCell[];
+}
+/**
+ * A body row of an export, in the order the grid shows them. Discriminate on
+ * `kind`.
+ */
+type ExportRow = ExportDataRow | ExportGroupRow | ExportGroupSummaryRow;
+/**
+ * The grand total — every aggregate over the exported rows. Its own kind
+ * rather than an `ExportRow`, since it only ever stands in
+ * `ExportTable.footer`, never among the body rows.
+ */
+interface ExportTotalRow {
+    readonly kind: "total";
+    readonly cells: readonly ExportCell[];
+}
+/**
+ * What an export writes, whatever the format: the grid's view as data,
+ * built by `buildExportTable` from the controller's view and state and
+ * never from the page. Every serialiser and writer reads this one shape, so
+ * a file, the clipboard and a print cannot disagree.
+ */
+interface ExportTable {
+    readonly columns: readonly ExportColumn[];
+    /** Whether a header row of column names leads the output. */
+    readonly header: boolean;
+    readonly rows: readonly ExportRow[];
+    /** The grand total, or `null` when there are no aggregates to total. */
+    readonly footer: ExportTotalRow | null;
+}
+/**
+ * Narrows what an export holds. Every field defaults to what the user sees,
+ * with nothing hidden by paging or a collapsed group.
+ */
+interface ExportOptions {
+    /**
+     * Which rows: `"all"` (the default) every row the filter, search and sort
+     * leave, across every page; `"page"` the data rows on the current page;
+     * `"selection"` the selected rows among those `"all"` holds.
+     */
+    readonly scope?: "all" | "page" | "selection" | undefined;
+    /**
+     * Which columns: `"visible"` (the default) those shown, in their current
+     * order; `"all"` hidden ones too; or a list of column ids, in that order.
+     * A column with `exportable: false` is left out of every one.
+     */
+    readonly columns?: "visible" | "all" | readonly string[] | undefined;
+    /**
+     * Whether a grouped grid exports its group header rows, every group
+     * expanded whatever its state on screen. Defaults to `true`; `false`
+     * keeps the rows in grouped order without the headers.
+     */
+    readonly includeGroups?: boolean | undefined;
+    /** Whether group aggregates and the grand total are exported. Defaults to `true`. */
+    readonly includeAggregates?: boolean | undefined;
+    /** Whether a header row of column names leads the output. Defaults to `true`. */
+    readonly includeHeader?: boolean | undefined;
+}
+
+/**
+ * What an export is built from: the grid's view and state as a controller
+ * holds them, never the page — so rows virtualised, paged or scrolled out of
+ * sight still export. Typed as the few fields it reads, so a
+ * `GridCommandContext` is one as it stands.
+ */
+interface ExportSource<Row> {
+    readonly view: GridView<Row, unknown>;
+    readonly state: Pick<GridState<Row>, "groupBy" | "rowSelection" | "columnSizing">;
+    readonly options: {
+        readonly locale?: FormatLocale;
+        readonly aggregates?: AggregateState<Row> | undefined;
+        readonly groupAggregateDisplay?: GroupAggregateDisplay | undefined;
+        readonly columnSizeDefaults?: Partial<ColumnSizeDefaults> | undefined;
+    };
+    readonly messages: Pick<GridMessages, "booleanTrue" | "booleanFalse" | "blankGroupValue">;
+}
+/**
+ * The grid's view as an `ExportTable` — the one model every export format,
+ * the clipboard and print are written from, so none of them reads the page
+ * and none can disagree with another.
+ *
+ * By default it holds what the user sees, minus what only hides it: every
+ * row the filter, search and sort leave, across every page; the visible
+ * columns in their current order, less any with `exportable: false`; and,
+ * in a grouped grid, every group expanded whatever its state on screen,
+ * with its aggregates where the grid shows them. `options` narrows it.
+ *
+ * Each cell carries the text `formatCellValue` makes of it, so the export
+ * reads as the screen does, and a typed value — the column's `exportValue`,
+ * else the raw value when it is a string, number, boolean or `Date`.
+ *
+ * The groups are rebuilt from the exported rows rather than read off
+ * `displayRows`, which omits a collapsed group's rows; so group counts,
+ * subtotals and the grand total describe exactly the rows exported — the
+ * selection, under `scope: "selection"`, not the whole grid.
+ */
+declare function buildExportTable<Row>(source: ExportSource<Row>, options?: ExportOptions): ExportTable;
+
+/**
+ * What a copy is built from: an export's source, with the column and cell
+ * selection a selection copy reads as well. A `GridCommandContext` is one
+ * as it stands.
+ */
+interface CopySource<Row> extends ExportSource<Row> {
+    readonly state: Pick<GridState<Row>, "groupBy" | "rowSelection" | "columnSizing" | "columnSelection" | "cellSelection">;
+}
+/**
+ * What to copy: one cell, one row, or whatever the grid has selected — the
+ * selected rows, else the selected columns, else the selected cell.
+ */
+type CopyRequest = {
+    readonly kind: "cell";
+    readonly rowId: string;
+    readonly columnId: string;
+} | {
+    readonly kind: "row";
+    readonly rowId: string;
+} | {
+    readonly kind: "selection";
+};
+/**
+ * A copy in the two forms the clipboard carries, with what it holds for the
+ * announcement: `count` cells, rows or columns.
+ */
+interface CopyContent {
+    /** Tab-separated text, as `toTsv` writes it — what a spreadsheet splits into cells. */
+    readonly text: string;
+    /** The same as an HTML table, as `toHtmlTable` writes it — what a word processor keeps the columns of. */
+    readonly html: string;
+    readonly count: number;
+    readonly unit: "cells" | "rows" | "columns";
+}
+/**
+ * What `request` copies, as tab-separated text and an HTML table, or `null`
+ * when there is nothing to copy — a row the filter hides, a column hidden
+ * or marked `exportable: false`, or an empty selection.
+ *
+ * Built from the export model, never the page, so a copy holds exactly what
+ * an export would and reads as the grid shows it: each cell's formatted
+ * text, the shown columns in their order less any with `exportable: false`.
+ * The text has no byte order mark and no formula neutralising — what is
+ * copied is what is seen, and pasting it is the user's own act.
+ *
+ * A cell copies its text alone, and a row its cells without a header. A
+ * selection copies the selected rows, in the order the grid shows them and
+ * under a header row once there are two or more; else the selected columns
+ * over every row the filter leaves, under their header; else the selected
+ * cell.
+ */
+declare function copyContent<Row>(source: CopySource<Row>, request: CopyRequest): CopyContent | null;
+
+/** Which way the paper is turned. */
+type PrintOrientation = "portrait" | "landscape";
+/**
+ * How a grid prints: which rows and columns (every `ExportOptions` field),
+ * the text around the table, and the page it is laid out on. The grid's
+ * `print` option.
+ */
+interface PrintOptions extends ExportOptions {
+    /** A heading above the table, and the printed document's title. */
+    readonly title?: string | undefined;
+    /** A line under the title. */
+    readonly subtitle?: string | undefined;
+    /** A line after the table. */
+    readonly footer?: string | undefined;
+    /**
+     * When the print was made, under the title: `true` for now, or a `Date`
+     * to print instead. Off by default.
+     */
+    readonly timestamp?: boolean | Date | undefined;
+    /** The language the timestamp is written in. Defaults to the grid's. */
+    readonly locale?: FormatLocale;
+    /**
+     * Which way the paper is turned. Defaults to `"landscape"` for a table of
+     * more than six columns, which rarely fits a portrait page, else
+     * `"portrait"`.
+     */
+    readonly orientation?: PrintOrientation | undefined;
+    /**
+     * A page size CSS names — `"A4"` (the default), `"Letter"`, `"A3"`,
+     * `"Legal"`.
+     */
+    readonly paperSize?: "A4" | "Letter" | (string & {}) | undefined;
+    /** Whether each page is numbered, "3 / 12", where the browser can. Defaults to `true`. */
+    readonly pageNumbers?: boolean | undefined;
+    /**
+     * Whether a wide table is squeezed onto the page — a smaller font and
+     * fixed column widths that wrap their text — rather than run off its
+     * edge. Defaults to `false`.
+     */
+    readonly fitToWidth?: boolean | undefined;
+    /** CSS added after the print stylesheet, to restyle the printed table. */
+    readonly styles?: string | undefined;
+}
+/**
+ * The page a print is laid out on, every choice settled — what
+ * `@gridkitjs/dom`'s `printStyles` turns into the page's CSS.
+ */
+interface PrintPage {
+    readonly paperSize: string;
+    readonly orientation: PrintOrientation;
+    readonly pageNumbers: boolean;
+    readonly fitToWidth: boolean;
+}
+/** A print ready for a renderer to put on paper: what `buildPrintDocument` returns. */
+interface PrintDocument {
+    /**
+     * The document's title as text, `""` when untitled — what the browser
+     * puts in a page's header and names a PDF saved from the print dialog.
+     */
+    readonly title: string;
+    /** The `<body>`'s markup: the heading, the table and the footer, every piece of text escaped. */
+    readonly bodyHtml: string;
+    readonly page: PrintPage;
+}
+/**
+ * The table as a printable document: its heading — the title, subtitle and
+ * timestamp `options` set — then the table as `toHtmlTable` writes it, then
+ * the footer line, with the page it is laid out on. Every piece of text is
+ * escaped. It holds no styles: putting it on paper, with a stylesheet for
+ * the page, is the renderer's — `@gridkitjs/dom`'s `printStyles` and
+ * `printDocument` in a browser.
+ *
+ * The heading and footer carry semantic class names for a stylesheet:
+ * `gridkit-print-header` around `print-title`, `print-subtitle` and
+ * `print-timestamp`, and `gridkit-print-footer`.
+ */
+declare function buildPrintDocument(table: ExportTable, options?: PrintOptions): PrintDocument;
+/**
+ * What `exportPrintDocument` prints from: an `ExportSource` that may carry
+ * the grid's `label`. A `GridCommandContext` is one as it stands.
+ */
+interface PrintSource<Row> extends ExportSource<Row> {
+    readonly options: ExportSource<Row>["options"] & {
+        readonly label?: string | undefined;
+    };
+}
+/**
+ * The grid's view as a print document: the table `options` narrow, laid out
+ * as `buildPrintDocument` lays it out, with the timestamp in the grid's
+ * locale unless `options` name another. Given no `title`, it takes the
+ * grid's `label` — the name a screen reader already reads for it; `""`
+ * leaves it untitled.
+ */
+declare function exportPrintDocument<Row>(source: PrintSource<Row>, options?: PrintOptions): PrintDocument;
+
+/** How `toCsv` writes a file. Every field is optional. */
+interface CsvOptions {
+    /**
+     * The field separator: `","` by default, any string, or `"auto"` for the
+     * separator a spreadsheet expects in `locale` — `";"` where a decimal is
+     * written with a comma, as in most of Europe, since a comma there is part
+     * of a number; `","` elsewhere.
+     */
+    readonly delimiter?: string | undefined;
+    /** The locale `delimiter: "auto"` reads; the runtime's own when absent. */
+    readonly locale?: FormatLocale;
+    /** What ends each record. Defaults to `"\r\n"`, as RFC 4180 writes it. */
+    readonly eol?: string | undefined;
+    /**
+     * Whether the file starts with a UTF-8 byte order mark. Defaults to
+     * `true`: without one, Excel reads the file in the system's legacy code
+     * page and garbles every character outside ASCII.
+     */
+    readonly bom?: boolean | undefined;
+    /**
+     * Whether a field a spreadsheet would run as a formula is written as text
+     * instead. Defaults to `true`; see `toCsv`.
+     */
+    readonly neutralizeFormulas?: boolean | undefined;
+    /**
+     * Which reading of each cell is written: `"text"` (the default), as the
+     * grid shows it; or `"raw"`, the typed value — numbers plain, dates in ISO
+     * 8601, booleans as `true` and `false` — for a file a program reads.
+     */
+    readonly values?: "text" | "raw" | undefined;
+}
+/**
+ * The table as CSV, quoted per RFC 4180: a field is quoted when it holds the
+ * delimiter, a quote or a line break, and a quote inside one is doubled, so
+ * a line break inside a cell survives. A group row writes its label in the
+ * first column; summary rows and the footer write their aggregates under
+ * their columns.
+ *
+ * A CSV file opened in a spreadsheet runs any field that starts with `=`,
+ * `+`, `-` or `@` as a formula — and a tab or a carriage return can hide
+ * such a start — so a value a user typed into the data could make another
+ * user's spreadsheet fetch a URL or run a command. By default such a field
+ * gets a leading `'`, which the spreadsheet shows as text. A cell whose
+ * value is a number keeps its leading sign, since it is one.
+ *
+ * Returns a string, not a file: making a `Blob` of it, with the type
+ * `text/csv;charset=utf-8`, is the renderer's job.
+ */
+declare function toCsv(table: ExportTable, options?: CsvOptions): string;
+
+/** How `toJson` writes its text. Every field is optional. */
+interface JsonOptions {
+    /**
+     * What each record is keyed by: `"id"` (the default), the column's id,
+     * stable whatever the header says; or `"header"`, its header text, for a
+     * reader who sees the keys. A header repeated across columns is suffixed
+     * ` (2)`, ` (3)` and so on, so no column overwrites another.
+     */
+    readonly keys?: "id" | "header" | undefined;
+    /** Indentation, as `JSON.stringify` takes it; none by default. */
+    readonly space?: number | string | undefined;
+}
+/**
+ * The table's data rows as a JSON array of objects, one property per
+ * column holding the cell's typed value — a number stays a number, a `Date`
+ * becomes its ISO 8601 string. Group headers, summary rows and the footer
+ * are left out: JSON is read by programs, which group and total for
+ * themselves, and a row that is not data would only have to be filtered
+ * out again.
+ *
+ * Returns a string; making a `Blob` of it, with the type
+ * `application/json`, is the renderer's job.
+ */
+declare function toJson(table: ExportTable, options?: JsonOptions): string;
+
+/**
+ * How a grid exports unless a call says otherwise: which rows and columns
+ * (every `ExportOptions` field), what the file is called, and each built-in
+ * format's settings. The grid's `export` option.
+ */
+interface GridExportOptions extends ExportOptions {
+    /**
+     * The file's name, without its extension — the writer's is added unless
+     * the name already ends with it. A function is asked per export with the
+     * format, `"csv"` or `"xlsx"`. Defaults to `"export"`.
+     */
+    readonly fileName?: string | ((format: string) => string) | undefined;
+    /**
+     * How the CSV writer writes. Its `locale`, which `delimiter: "auto"`
+     * reads, defaults to the grid's.
+     */
+    readonly csv?: CsvOptions | undefined;
+    /** How the JSON writer writes. */
+    readonly json?: JsonOptions | undefined;
+}
+/** What a writer is given beside the table: the grid's language and the export's settings. */
+interface ExportWriteContext {
+    /** The grid's `locale`. */
+    readonly locale: FormatLocale;
+    /** The grid's messages, over the defaults. */
+    readonly messages: GridMessages;
+    /**
+     * The export's options, where a writer finds its own settings: the CSV
+     * writer reads `csv`, the JSON writer `json`. A writer of the app's own
+     * takes its settings when it is made instead, as a closure.
+     */
+    readonly options: GridExportOptions;
+}
+/**
+ * One export format: how to write an `ExportTable` as a file of it, and what
+ * the file is. CSV and JSON ship with the grid; any other — xlsx from
+ * `@gridkitjs/export-xlsx`, or one of the app's own — is registered through
+ * the grid's `exportWriters`.
+ *
+ * `write` returns the file's contents, not a file: text, bytes, or a promise
+ * of either for a writer that loads a library first. Making a `Blob` of it
+ * is the renderer's job.
+ */
+interface ExportWriter {
+    /** The id the grid knows it by — `"csv"`, `"xlsx"`; one per grid. */
+    readonly format: string;
+    /** Without the dot: `"csv"`. */
+    readonly fileExtension: string;
+    /** The file's media type, the `Blob`'s `type`. */
+    readonly mimeType: string;
+    readonly write: (table: ExportTable, context: ExportWriteContext) => string | Uint8Array | Promise<string | Uint8Array>;
+}
+/** An export ready to save: what `exportFile` hands a renderer to download. */
+interface ExportFile {
+    /** With its extension: `"export.csv"`. */
+    readonly fileName: string;
+    readonly mimeType: string;
+    readonly content: string | Uint8Array;
+}
+/** CSV through `toCsv`, its delimiter read for the grid's locale unless `csv.locale` says otherwise. */
+declare const csvWriter: ExportWriter;
+/** The data rows as JSON, through `toJson`. */
+declare const jsonWriter: ExportWriter;
+/**
+ * Every writer a grid can export with, by format: CSV and JSON, then
+ * `writers` — one with a built-in's format replacing it, as an app command
+ * replaces a built-in of the same id.
+ */
+declare function resolveExportWriters(writers: readonly ExportWriter[] | undefined): ReadonlyMap<string, ExportWriter>;
+
+/**
+ * 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, a renderer's
+ * API, or a column's filter menu — its sort entries and its "Clear filter".
+ */
+type GridCommandSource = "contextMenu" | "toolbar" | "api" | "filterMenu";
+/** 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: the column chooser, and
+ * a column's filter menu, which opens on a header target only.
+ */
+type GridPanelKind = "columnChooser" | "filter";
+/**
+ * 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;
+    /**
+     * Saves an export as a file — in a browser, a download. A promise is the
+     * file of a writer still writing; the host waits for it, and reports a
+     * rejected one rather than saving.
+     */
+    readonly saveFile: (file: ExportFile | Promise<ExportFile>) => void;
+    /**
+     * Puts a copy on the clipboard, as text and as HTML, and announces it —
+     * `count` and `unit` say what to announce — or that the browser refused.
+     */
+    readonly writeClipboard: (content: CopyContent) => void;
+    /**
+     * Puts a print document on paper — in a browser, through the print
+     * dialog. `options` are those it was built under, for what the host adds
+     * itself, such as `styles` over its print stylesheet.
+     */
+    readonly print: (document: PrintDocument, options: PrintOptions) => 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" | "filter.open" | "filter.clear" | "selection.selectAllRows" | "selection.clear" | "filter.clearAll" | "export.csv" | "export.json" | "export.xlsx" | "export.pdf" | "exportSelection.csv" | "exportSelection.json" | "exportSelection.xlsx" | "copy.cell" | "copy.row" | "copy.selection" | "print";
+/**
+ * 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" | "copy" | "print";
+/**
+ * The grid's own commands, one per action its menus and toolbar offer —
+ * sorting, grouping, hiding, fitting and choosing columns, selecting,
+ * clearing, exporting, copying and printing.
+ * 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; `"export"`, a
+ * dropdown of the export commands that show; and a custom entry.
+ */
+type ToolbarEntry<Row> = MenuEntry<Row> | "search" | "spacer" | "export" | 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>[];
+
+/** 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-fitting a column calls it once, with "end".
+     */
+    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 — from the toolbar's search box, the
+     * `filter.clearAll` command, `setFilter` or a restored state.
+     */
+    onFilterChange?: ((event: FilterChangeEvent<Row>) => void) | undefined;
+    /**
+     * Whether columns get a filter menu, opened from their header, unless a
+     * column says otherwise. Off by default, like `sortableColumns`; the
+     * filter itself applies either way, from `defaultFilter`, `setFilter` or a
+     * search box. A renderer draws the menu from what
+     * `resolveColumnFilterMenu` settles.
+     */
+    filterableColumns?: boolean | undefined;
+    /**
+     * How the filter menus look: which editor they open — `"simple"`
+     * conditions or an `"excel"` checklist — and the checklist's counts and
+     * value limit. A column's own `filterMenu` wins over it. Switching `ui`
+     * keeps every filter, since both editors edit the one `filter`.
+     */
+    filterMenu?: GridFilterMenuOptions | 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;
+    /**
+     * How the grid exports unless a call says otherwise: which rows and
+     * columns, the file's name, and the CSV and JSON settings. Left out, an
+     * export holds what the user sees, across every page, in a file named
+     * `export` with the format's extension.
+     */
+    export?: GridExportOptions | undefined;
+    /**
+     * Export formats beyond CSV and JSON — an xlsx writer, or one of the
+     * app's own — each registered by its `format`, replacing a built-in
+     * writer of the same format. `export.xlsx` and `export.pdf` show only
+     * once a writer for their format is here — see `resolveExportWriters`.
+     */
+    exportWriters?: readonly ExportWriter[] | undefined;
+    /**
+     * How the grid prints unless a call says otherwise: the rows and columns,
+     * the title and text around the table, and the page. Left out, a print
+     * holds what an export does, titled with `label`, on an A4 page.
+     */
+    print?: PrintOptions | 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;
+}
+
+/**
+ * Which editor a filter menu opens. Both edit the same `FilterState`, so
+ * switching between them keeps every filter applied.
+ *
+ * - `"simple"`: one or two conditions — an operator and a value each —
+ *   joined by and/or.
+ * - `"excel"`: a search box over a checklist of the column's values, with
+ *   the conditions a submenu away.
+ */
+type FilterMenuUi = "simple" | "excel";
+/** How a grid's filter menus look, unless a column says otherwise. */
+interface GridFilterMenuOptions {
+    /** Which editor a filter menu opens. Defaults to `"simple"`. */
+    readonly ui?: FilterMenuUi | undefined;
+    /** Whether the excel editor's checklist shows how many rows hold each value. Off by default. */
+    readonly showCounts?: boolean | undefined;
+    /**
+     * How many distinct values the excel editor's checklist lists before it
+     * asks for a search first. Defaults to `DEFAULT_FILTER_VALUE_LIMIT`.
+     */
+    readonly valueLimit?: number | undefined;
+}
+/** A column's own filter menu settings, over the grid's `filterMenu`. */
+interface ColumnFilterMenuOptions {
+    /** Which editor this column's filter menu opens, over the grid's `filterMenu.ui`. */
+    readonly ui?: FilterMenuUi | undefined;
+    /**
+     * The operators this column's conditions offer, in order, in place of its
+     * type's `defaultFilterOperators`. `in` is dropped — the checklist is its
+     * editor — and `[]` offers no condition, leaving the excel editor its
+     * checklist alone.
+     */
+    readonly operators?: readonly FilterOperator[] | undefined;
+}
+/** One column's filter menu with every setting settled — what a renderer draws. */
+interface ResolvedColumnFilterMenu {
+    readonly ui: FilterMenuUi;
+    /** The operators its conditions offer, in order. Never `in`. */
+    readonly operators: readonly FilterOperator[];
+    /** The family the column's `type` falls in, which its operators are labelled by. */
+    readonly family: FilterOperatorFamily;
+    readonly showCounts: boolean;
+    readonly valueLimit: number;
+}
+/**
+ * How many distinct values a checklist lists before asking for a search —
+ * Excel's own cap. The list is virtualized, so what this bounds is counting
+ * the values, not drawing them.
+ */
+declare const DEFAULT_FILTER_VALUE_LIMIT = 10000;
+/**
+ * The filter menu `column` opens, or `null` when it has none: a column is
+ * filterable when its own `filterable` says so, else when the grid's
+ * `filterableColumns` does — off unless one of them turns it on, as
+ * `sortable` is. The column's `filterMenu` settings win over the grid's
+ * one by one; what neither sets takes its default.
+ */
+declare function resolveColumnFilterMenu(options: Pick<GridOptions<unknown>, "filterableColumns" | "filterMenu">, column: Pick<ColumnDefinition<unknown, unknown>, "type" | "filterable" | "filterMenu">): ResolvedColumnFilterMenu | null;
+
+/**
+ * Values a cell shows as-is instead of being drilled into. Arrays and `Date`s
+ * are cell values rather than groups of columns, and `null` cannot be
+ * introspected, so all three end a path.
+ */
+type LeafValue = bigint | boolean | number | string | symbol | null | undefined | Date | readonly unknown[] | ((...args: never[]) => unknown);
+/** Keys of `T` holding a leaf value — the only ones a path may end on. */
+type LeafKey<T> = {
+    [K in keyof T & string]: NonNullable<T[K]> extends LeafValue ? K : never;
+}[keyof T & string];
+/**
+ * Every addressable field of `Row`, one level deep: `"Id"` for a flat field,
+ * `"Application.Id"` for a leaf inside a nested object. A nested object
+ * contributes only its leaf children, never itself and never anything deeper.
+ */
+type FieldPath<Row> = {
+    [K in keyof Row & string]: NonNullable<Row[K]> extends LeafValue ? K : `${K}.${LeafKey<NonNullable<Row[K]>>}`;
+}[keyof Row & string];
+/**
+ * The value type of a column's cells. This package is framework-agnostic so it
+ * defaults to `string`;
+ */
+type ColumnType = "dateTime" | "date" | "time" | "number" | "string" | "boolean" | "decimal" | "currency" | "percent";
+type ColumnAlignment = "left" | "center" | "right";
+/**
+ * What `cellTemplate` receives. An object rather than positional arguments so
+ * that a later addition — a sort state, whether the row is selected — is not a
+ * breaking change to every template already written.
+ */
+interface CellTemplateContext<Row> {
+    /**
+     * This cell's value, read off the column's field path. `unknown` because a
+     * dotted path's type cannot be recovered here; a template narrows it.
+     */
+    value: unknown;
+    /** The whole row, for a template that needs a sibling field. */
+    row: Row;
+    /** Position among the rows as rendered — the index within the current page once paging is on. */
+    rowIndex: number;
+    /** This row's absolute position in the whole filtered/sorted/grouped dataset, unaffected by which page is showing. */
+    datasetIndex: number;
+    /** This row's id, as `resolveRowId` settled it. */
+    rowId: string;
+    /** Whether this row is selected, so a template can style itself to match. */
+    selected: boolean;
+}
+/**
+ * What a column's `footerTemplate` receives. Mirrors `CellTemplateContext`'s
+ * shape where it applies — `value`, `rows` — minus everything scoped to one
+ * rendered row (`rowIndex`, `rowId`, `selected`), since a footer addresses
+ * every row an aggregate was computed over at once, not a single one.
+ */
+interface FooterTemplateContext<Row> {
+    /** This column's aggregate result, as `computeAggregates` produced it. */
+    value: unknown;
+    /** Every row the aggregate was computed over — the grand total's full dataset, or one group's full leaf descendants. */
+    rows: readonly Row[];
+}
+/**
+ * @typeParam Node - What a header or cell renders to. This package is
+ * framework-agnostic so it defaults to `string`; `@gridkitjs/react` binds it to
+ * `ReactNode` so a template can return JSX.
+ */
+interface ColumnDefinition<Row, Node = string> {
+    /**
+     * Path to this cell's value: a key of `Row`, or `"Parent.Child"` for a leaf
+     * one level inside a nested object. Any string still compiles — the union
+     * exists to drive autocomplete, not to lock the grid down.
+     */
+    field: FieldPath<Row> | (string & {});
+    /**
+     * Stable identity for state keyed by this column. Defaults to `field`, which
+     * is unique in the common case but need not be — two columns may render the
+     * 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 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;
+    /**
+     * Renders this column's own aggregate result in a group footer or the
+     * grand-total footer, in place of the raw computed value. Absent for a
+     * column with no aggregate: nothing is shown, the same way a column
+     * missing from `AggregateState` contributes no cell to either footer.
+     */
+    footerTemplate?: ((context: FooterTemplateContext<Row>) => Node) | undefined;
+    /**
+     * The value type of this column's cells. This package is framework-agnostic so it
+     * 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);
+     */
+    alignment?: ColumnAlignment;
+    /**
+     * Width in px this column starts at. A user resize overrides it for as long
+     * as that resize lives in the sizing state.
+     */
+    width?: number;
+    /** Lower bound a resize may not drag below. */
+    minWidth?: number;
+    /** Upper bound a resize may not drag above. */
+    maxWidth?: number;
+    /** Whether this column can be resized, overriding the grid-level default. */
+    resizable?: boolean;
+    /**
+     * Whether this column can be dragged to a new position, overriding the
+     * grid-level default. A column that cannot move can still be moved past.
+     */
+    reorderable?: boolean;
+    /** Whether this column can be sorted, overriding the grid-level default. */
+    sortable?: boolean;
+    /**
+     * Whether this column has a filter menu, overriding the grid-level
+     * `filterableColumns`. Like `sortable`, it gates the user's way in and
+     * nothing else: a filter on the column set in code still applies.
+     */
+    filterable?: boolean | undefined;
+    /**
+     * This column's own filter menu settings — its editor and the operators
+     * its conditions offer — over the grid's `filterMenu`.
+     */
+    filterMenu?: ColumnFilterMenuOptions | undefined;
+    /** Whether this column can be grouped by, overriding the grid-level default. */
+    groupable?: boolean;
+    /**
+     * Whether this column's header shows its group-toggle icon, overriding
+     * the grid-level default. Purely a rendering choice — it does not affect
+     * whether the column can be grouped by (`groupable`) or the
+     * `Alt+ArrowDown` shortcut, which keeps working with the icon hidden, the
+     * same way the resize handle stays `aria-hidden` while `Alt+ArrowLeft`/
+     * `ArrowRight` still resize.
+     */
+    groupToggleIcon?: boolean;
+    /**
+     * Whether this column's header may be dragged into the group-by bar to
+     * add it to the active grouping, overriding the grid-level default.
+     * Distinct from `groupable`: a column can be groupable via its header's
+     * click/`Alt+ArrowDown` toggle, via this drag, both, or neither.
+     */
+    groupByDraggable?: boolean;
+    /**
+     * Lets this column's header and/or cell text wrap onto multiple lines
+     * instead of the grid's default single line with an ellipsis. Off by
+     * default: wrapping changes row height, so it stays a column's own choice
+     * rather than something a minor release could turn on under an existing
+     * grid.
+     */
+    wrap?: ColumnWrapConfig;
+    /**
+     * Extra class names appended to this column's `th`. An escape hatch for a
+     * consumer's own CSS — nothing in this package reads them — for anything
+     * `wrap` and the rest of this type don't cover.
+     */
+    headerClassName?: string;
+    /**
+     * Extra class names appended to this column's `td`, on every row. Static
+     * per column: a per-row condition is already `cellTemplate`'s job (a
+     * template returning its own markup with a conditional class), so this
+     * 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;
+    /**
+     * Whether this column is written to an export, a clipboard copy or a
+     * print. Defaults to `true`. `false` keeps it out of every one of them —
+     * even when an export names it by id — for a column whose cells mean
+     * nothing off screen, such as one of action buttons.
+     */
+    exportable?: boolean | undefined;
+    /**
+     * The typed value an export stores for this column's cells, where the raw
+     * value at `field` is not the one to keep — an id to resolve into a name,
+     * a string date to turn into a `Date`. Only a format that keeps typed
+     * values (a spreadsheet, JSON) reads it; the text every format writes
+     * still comes from `formatCellValue`, so what is exported reads as what
+     * is shown.
+     */
+    exportValue?: ((value: unknown, row: Row) => ExportScalar) | undefined;
+}
+/** Which parts of a column opt out of the grid's default single-line text. */
+interface ColumnWrapConfig {
+    header?: boolean;
+    cells?: boolean;
+}
+/**
+ * Widths the user has changed, keyed by column id. Holding only what changed —
+ * rather than every width — means a `width` edited in the column definition
+ * still takes effect, and resetting is discarding the state.
+ */
+type ColumnSizingState = Readonly<Record<string, number>>;
+/** The active page, and how many rows/units make one up. */
+interface PaginationState {
+    readonly pageIndex: number;
+    readonly pageSize: number;
+}
+/** Reports a user page/page-size change whole — the one to persist from, mirroring ColumnSortEvent. */
+interface PaginationChangeEvent {
+    readonly pagination: PaginationState;
+    readonly pageCount: number;
+}
+/** Sizes used for a column that does not specify its own. */
+interface ColumnSizeDefaults {
+    width: number;
+    minWidth: number;
+    maxWidth: number;
+}
+/** The bounds a column's width is held between, resolved once from both. */
+interface ColumnConstraints {
+    minWidth: number;
+    maxWidth: number;
+}
+/**
+ * Grid-level defaults a column falls back to when it does not set its own.
+ * Sizes are grouped so the rest of the grid's defaults have somewhere to go.
+ */
+interface ColumnResolveOptions {
+    sizes?: Partial<ColumnSizeDefaults> | undefined;
+    /** Whether columns are resizable, unless a column says otherwise. */
+    resizable?: boolean | undefined;
+    /** Whether columns are reorderable, unless a column says otherwise. */
+    reorderable?: boolean | undefined;
+    /** 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
+ * binding renders identically without repeating the logic.
+ */
+interface ResolvedColumn<Row, Node = string> {
+    column: ColumnDefinition<Row, Node>;
+    id: string;
+    width: number;
+    /**
+     * Whether `width` came from the sizing state rather than the column
+     * definition — that is, whether the user set it. Auto-fit leaves these
+     * columns alone so that resizing one does not undo itself.
+     */
+    sized: boolean;
+    /**
+     * 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. */
+    resizable: boolean;
+    /** Whether this column can be dragged, after the grid-level default. */
+    reorderable: boolean;
+    /** Whether this column's header may be dragged into the group-by bar, after the grid-level default. */
+    groupByDraggable: boolean;
+    /** How this column's cells align, after falling back to its type. */
+    alignment: ColumnAlignment;
+}
+/**
+ * A resize in progress. It captures its constraints up front so that applying
+ * a pointer position is arithmetic on numbers alone — no column, no DOM.
+ */
+interface ColumnResizeSession {
+    readonly columnId: string;
+    readonly startWidth: number;
+    readonly startPosition: number;
+    readonly constraints: ColumnConstraints;
+}
+/**
+ * Reports a user resize. `phase` separates the two audiences: `"move"` fires
+ * continuously for live feedback, `"end"` once on release — the one to persist.
+ */
+interface ColumnResizeEvent {
+    readonly columnId: string;
+    readonly width: number;
+    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
+ * that are listed.
+ */
+type ColumnOrderState = readonly string[];
+/**
+ * Which side of a column a drop lands on, normalised away by
+ * `resolveDropBefore` so it reaches no state.
+ */
+type DropSide = "before" | "after";
+/**
+ * Reports a user reorder. Unlike a resize there is no `"move"` phase — the
+ * order does not change until the drop.
+ */
+interface ColumnOrderEvent {
+    readonly columnId: string;
+    readonly order: ColumnOrderState;
+}
+/** Which way a column sorts. */
+type SortDirection = "asc" | "desc";
+/** One column's place in a stacked sort, and which way it sorts. */
+interface ColumnSortEntry {
+    readonly columnId: string;
+    readonly direction: SortDirection;
+}
+/**
+ * The active sort, in priority order: index 0 sorts first, ties broken by
+ * index 1, and so on down the stack. Empty for an unsorted grid, mirroring
+ * `SelectionState`'s empty array for "nothing selected".
+ */
+type ColumnSortState = readonly ColumnSortEntry[];
+/**
+ * Reports a user sort change whole — the stack to persist from. No `phase`:
+ * unlike a resize, a sort has no in-progress state, only before and after.
+ */
+interface ColumnSortEvent {
+    readonly columnId: string;
+    readonly sort: ColumnSortState;
+}
+/** One level of a stacked group-by, outer to inner. Mirrors ColumnSortEntry. */
+interface GroupByEntry {
+    readonly columnId: string;
+    /** Order of this level's own group values (not row order within a group). Defaults to "asc". */
+    readonly direction?: SortDirection;
+}
+/**
+ * The active grouping, outer to inner: index 0 groups first, each
+ * subsequent index nests inside it. Empty for an ungrouped grid, mirroring
+ * ColumnSortState's empty array for "no sort".
+ */
+type GroupByState = readonly GroupByEntry[];
+/**
+ * Reports a user group-by change whole — the stack to persist from. Mirrors
+ * ColumnSortEvent's `{columnId, sort}` shape.
+ */
+interface GroupByEvent {
+    readonly columnId: string;
+    readonly groupBy: GroupByState;
+}
+/**
+ * Group keys collapsed by the user — holding only the exceptions, the same
+ * way ColumnSizingState holds only resized widths. A key absent from this
+ * set is expanded; there is no separate "collapsed by default" concept.
+ */
+type GroupExpansionState = readonly string[];
+/**
+ * Reports a user expansion change. `groupId` is the group toggled, or `null`
+ * for expandAllGroups/collapseAllGroups, which touch every group in one call
+ * rather than one at a time.
+ */
+interface GroupExpansionEvent {
+    readonly groupId: string | null;
+    readonly expansion: GroupExpansionState;
+}
+/**
+ * One group header in a grouped result. `path` is every ancestor value
+ * down to and including this group's own, outermost first — what a header
+ * template needs to render "West / Enterprise", not just "Enterprise".
+ *
+ * Not parameterized by `Row`: nothing here holds a `Row`-typed value today —
+ * `aggregates` holds computed `unknown` results, not rows themselves.
+ */
+interface ResolvedGroupRow {
+    readonly kind: "group";
+    /** Stable id for this node: this plan's join of `path`, used as the React key and the GroupExpansionState entry. Opaque — build it with `groupRowId`, never construct one by hand. */
+    readonly groupId: string;
+    /** Nesting depth, 0 for a top-level group. */
+    readonly level: number;
+    readonly columnId: string;
+    /** This level's own value — the last entry of `path`. */
+    readonly value: unknown;
+    readonly path: readonly unknown[];
+    readonly expanded: boolean;
+    /** Leaf row count under this group, regardless of collapse state. */
+    readonly count: number;
+    /** Position among the display rows as rendered — same invariant ResolvedRow.rowIndex keeps. */
+    readonly rowIndex: number;
+    /** This header's absolute position in the whole filtered/sorted/grouped dataset, matching ResolvedRow.datasetIndex. */
+    readonly datasetIndex: number;
+    /**
+     * This group's own aggregate results, computed over its full leaf-row
+     * descendants regardless of collapse state — see `withGroupAggregates`.
+     * Empty when no `AggregateState` is active.
+     */
+    readonly aggregates: AggregateResults;
+}
+/**
+ * A group's own aggregate results, rendered as a row of its own rather than
+ * inline in its header — see `groupAggregateDisplay: "row"`. Emitted by
+ * `withGroupAggregates` immediately after a group's last visible
+ * descendant (its last nested group or data row, or immediately after its
+ * own header when collapsed), at that same group's `level`, one per group
+ * with `AggregateState` active — mirroring `ResolvedGroupRow` closely
+ * enough that the two are meant to be read side by side.
+ */
+interface ResolvedGroupSummaryRow {
+    readonly kind: "group-summary";
+    /** The group this summary belongs to — shared with that group's own `ResolvedGroupRow.groupId`, not a new id of its own. */
+    readonly groupId: string;
+    /** Nesting depth, matching the group's own `level`. */
+    readonly level: number;
+    /** Position among the display rows as rendered — same invariant every other DisplayRow's `rowIndex` keeps. */
+    readonly rowIndex: number;
+    /** This row's absolute position in the whole filtered/sorted/grouped dataset, matching ResolvedRow.datasetIndex. */
+    readonly datasetIndex: number;
+    /** This group's own aggregate results — identical to its `ResolvedGroupRow.aggregates`, computed once and shared rather than recomputed. */
+    readonly aggregates: AggregateResults;
+}
+/**
+ * One entry of a grouped result: an ordinary data row (no `kind` field at
+ * all — ResolvedRow is unchanged, so every existing consumer of plain
+ * ResolvedRow[] keeps compiling), a group header, or — only when
+ * `groupAggregateDisplay: "row"` is active — that group's own summary row.
+ * Discriminate with `"kind" in entry`, then `entry.kind`.
+ */
+type DisplayRow<Row> = ResolvedRow<Row> | ResolvedGroupRow | ResolvedGroupSummaryRow;
+/** A reducer this package computes without a custom `AggregateFn`. */
+type BuiltInAggregate = "sum" | "avg" | "min" | "max" | "count" | "countDistinct";
+/**
+ * Called with every raw row in scope — always the full leaf set, never a
+ * partial reduction combined from child groups, so a non-associative
+ * aggregate (median, distinct count) is never computed from
+ * already-aggregated values. Mirrors `FilterPredicate`'s shape, minus the
+ * per-row `value` since an aggregate reduces across rows rather than
+ * testing one.
+ */
+type AggregateFn<Row> = (rows: readonly Row[]) => unknown;
+/** One aggregate to compute against a column — a built-in reducer, or custom logic via `fn`. */
+interface AggregateSpec<Row> {
+    readonly columnId: string;
+    readonly fn: BuiltInAggregate | AggregateFn<Row>;
+    /** Distinguishes two aggregates on the same column (e.g. both sum and avg of Amount). Defaults to columnId, mirroring ColumnDefinition.id defaulting to field. */
+    readonly id?: string;
+    /**
+     * Overrides this aggregate's own cell alignment, in the grand-total
+     * footer and a group's own summary row (`groupAggregateDisplay: "row"`)
+     * — inline rendering (`"inline"`) is text, not a cell, so this has no
+     * effect there. Falls back to the column's own `alignment` when omitted.
+     * When two specs share a column and disagree, the first one in
+     * `AggregateState` wins for that shared cell, since one `<td>` can only
+     * take one `text-align`.
+     */
+    readonly alignment?: ColumnAlignment;
+}
+/**
+ * The active aggregates to compute. Empty for a grid with none, mirroring
+ * `FilterState`'s empty array for "no filter". A fully controlled prop —
+ * unlike `sort`/`filter`/`groupBy`/`pagination`, there is no built-in UI
+ * affordance for a user to add or remove an aggregate interactively.
+ */
+type AggregateState<Row> = readonly AggregateSpec<Row>[];
+/** One computed aggregate result, keyed by `spec.id ?? spec.columnId`. */
+type AggregateResults = ReadonlyMap<string, unknown>;
+/**
+ * Where a group's own aggregate results render. `"inline"` (the default)
+ * keeps them as text in the group header itself, next to its leaf-row
+ * count. `"row"` instead emits a `ResolvedGroupSummaryRow` immediately
+ * after that group's last visible descendant, with each aggregate's value
+ * in the `<td>` for its own column — the same alignment a grand-total
+ * footer cell has to its column, just scoped to one group instead of the
+ * whole dataset.
+ */
+type GroupAggregateDisplay = "inline" | "row";
+interface FilterEntryBase<Row> {
+    readonly columnId?: FieldPath<Row> | (string & {});
+}
+/** Matches a column's stringified value against an SQL LIKE-style query. */
+interface TextFilterEntry<Row> extends FilterEntryBase<Row> {
+    /**
+     * A bare query is an exact match; `%text%` is contains; `text%` is
+     * starts-with; `%text` is ends-with. Always case-insensitive. Only the
+     * first and last characters are read as anchors — a `%` anywhere else is
+     * a literal character, not a wildcard.
+     */
+    readonly query: string;
+}
+/**
+ * Matches a column's actual (non-stringified) value by strict equality —
+ * only when the column's resolved `type` agrees: `number`/`decimal`/
+ * `currency`/`percent` for a `number` value, `boolean` for a `boolean`
+ * value, `date`/`dateTime`/`time` for a `Date` value (compared via
+ * `getTime()`). A `value` against a column of the wrong type never matches,
+ * rather than silently stringifying and falling through to a text
+ * comparison — the whole point of this variant existing separately from
+ * `TextFilterEntry` is that it doesn't do that.
+ */
+interface ValueFilterEntry<Row> extends FilterEntryBase<Row> {
+    readonly value: number | boolean | Date;
+}
+type FilterPredicate<Row> = (value: unknown, row: Row) => boolean;
+/**
+ * Matches via caller-supplied logic — a numeric range, a cross-field
+ * combination, anything `query`/`value` can't express. Called once per row,
+ * not per column: when `columnId` is given, `value` is that column's value,
+ * resolved for convenience; when it's omitted, `value` is `undefined` and
+ * the predicate is expected to read whatever it needs off `row` itself.
+ */
+interface PredicateFilterEntry<Row> extends FilterEntryBase<Row> {
+    readonly predicate: FilterPredicate<Row>;
+}
+/**
+ * A nested group of entries, combined with `combinator` instead of the
+ * implicit AND every top-level `FilterState` uses. `entries` is itself a
+ * `FilterState<Row>`, so groups nest to any depth — the only entry variant
+ * with no `columnId` of its own, since it isn't scoped to one column, only
+ * to the entries it composes.
+ */
+interface GroupFilterEntry<Row> {
+    readonly combinator: "and" | "or";
+    readonly entries: FilterState<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
+ * alongside.
+ *
+ * Ordered rather than a keyed record for that reason alone; a render layer
+ * that needs lookups builds a `Set` from it. Rows and columns share the type:
+ * they are both a list of ids, and the state they live in already names which.
+ */
+type SelectionState = readonly string[];
+/**
+ * How much of a member may be selected at once. `false` rather than an absent
+ * key so that turning selection off for one member reads the same as never
+ * having enabled it.
+ */
+type SelectionMode = false | "single" | "multiple";
+/**
+ * The modes a cell may take. A cell addresses one value, so it has no
+ * `"multiple"` — a range of cells is a different feature, with a rectangle
+ * rather than a list behind it.
+ */
+type CellSelectionMode = false | "single";
+/**
+ * Which parts of the grid the user may select, and how many of each.
+ *
+ * Off by default, unlike `HoverableConfig`: selection claims the click, which
+ * a grid that only displays data should not do.
+ */
+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
+ * the boundary so that nothing downstream handles a raw event.
+ */
+type SelectIntent = "replace" | "toggle" | "range";
+/** The address of one cell: which row, and which column within it. */
+interface SelectedCellRef {
+    readonly rowId: string;
+    readonly columnId: string;
+}
+/** The one selected cell, or `null` for none. */
+type CellSelectionState = SelectedCellRef | null;
+/**
+ * What changed between two selections. Ids rather than resolved members, so
+ * that the transform producing it stays free of the data it selects from.
+ */
+interface SelectionDiff {
+    readonly added: readonly string[];
+    readonly removed: readonly string[];
+}
+/**
+ * A row paired with the identity and position it renders under — the row
+ * counterpart to `ResolvedColumn`, and resolved once for the same reason: so
+ * no part of the grid works out a row's id for itself.
+ *
+ * It is also what the selection callbacks report, so a handler reads the row
+ * itself rather than an id it has to look up.
+ */
+interface ResolvedRow<Row> {
+    readonly rowId: string;
+    readonly row: Row;
+    /** Position among the rows as rendered, matching `CellTemplateContext`. */
+    readonly rowIndex: number;
+    /** This row's absolute position in the whole filtered/sorted/grouped dataset, matching `CellTemplateContext`. */
+    readonly datasetIndex: number;
+}
+/**
+ * A selected column. Carries the resolved column rather than the bare
+ * definition, so a handler reads the width and label the user actually
+ * clicked rather than what the definition asked for.
+ */
+interface SelectedColumn<Row, Node = string> {
+    readonly columnId: string;
+    readonly column: ResolvedColumn<Row, Node>;
+    /** Position among the columns as displayed, so after any reorder. */
+    readonly columnIndex: number;
+}
+/** A selected cell, resolved down to the value it shows. */
+interface SelectedCell<Row, Node = string> {
+    readonly rowId: string;
+    readonly columnId: string;
+    readonly row: Row;
+    readonly column: ResolvedColumn<Row, Node>;
+    readonly rowIndex: number;
+    readonly columnIndex: number;
+    /** 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>;
+    readonly selection: SelectionState;
+}
+/**
+ * Reports every row one interaction selected or deselected. Fires once for a
+ * range that `RowSelectEvent` reports one row at a time.
+ */
+interface RowsSelectEvent<Row> {
+    readonly rows: readonly ResolvedRow<Row>[];
+    readonly selection: SelectionState;
+}
+/**
+ * Reports a row selection change whole: what it gained, what it lost, and
+ * everything it now holds. The one to persist from.
+ */
+interface RowSelectionChangeEvent<Row> {
+    readonly added: readonly ResolvedRow<Row>[];
+    readonly removed: readonly ResolvedRow<Row>[];
+    /** Every selected row, not only what this interaction changed. */
+    readonly selected: readonly ResolvedRow<Row>[];
+    readonly selection: SelectionState;
+}
+/** Reports one column selected or deselected. */
+interface ColumnSelectEvent<Row, Node = string> {
+    readonly column: SelectedColumn<Row, Node>;
+    readonly selection: SelectionState;
+}
+/** Reports every column one interaction selected or deselected. */
+interface ColumnsSelectEvent<Row, Node = string> {
+    readonly columns: readonly SelectedColumn<Row, Node>[];
+    readonly selection: SelectionState;
+}
+/** Reports a column selection change whole. The one to persist from. */
+interface ColumnSelectionChangeEvent<Row, Node = string> {
+    readonly added: readonly SelectedColumn<Row, Node>[];
+    readonly removed: readonly SelectedColumn<Row, Node>[];
+    /** Every selected column, not only what this interaction changed. */
+    readonly selected: readonly SelectedColumn<Row, Node>[];
+    readonly selection: SelectionState;
+}
+/** Reports the cell selected or deselected. */
+interface CellSelectEvent<Row, Node = string> {
+    readonly cell: SelectedCell<Row, Node>;
+    readonly selection: CellSelectionState;
+}
+/**
+ * Reports a cell selection change whole. Both fields are nullable and one
+ * interaction can fill both — moving between cells deselects and selects at
+ * once.
+ */
+interface CellSelectionChangeEvent<Row, Node = string> {
+    readonly selected: SelectedCell<Row, Node> | null;
+    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;
+}
+
+/**
+ * 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. `"export"` is one too, of the export
+ *   commands, keyed `"export"`.
+ * - `"search"`, `"spacer"` and custom entries stay as they are.
+ * - Separators never lead, trail, double up or sit next to a spacer, which
+ *   already parts what is on either side of it.
+ *
+ * Resolve again whenever the grid changes, so each button's label, flags
+ * and `run` follow its state.
+ */
+declare function resolveToolbar<Row>(entries: readonly ToolbarEntry<Row>[], options: ToolbarResolveOptions<Row>): readonly ResolvedToolbarItem[];
+
+/** What `fitToolbarItems` fits: a toolbar's entries, by width, into its space. */
+interface ToolbarFitInput {
+    /** Each entry's width, in order — `0` for a spacer, whose width is only the space left over. */
+    readonly widths: readonly number[];
+    /** The width the entries share. */
+    readonly available: number;
+    /** The width of the "More" button the entries that do not fit go into. */
+    readonly moreWidth: number;
+    /** Whether each entry, in order, stays however little room there is. */
+    readonly pinned: readonly boolean[];
+}
+/**
+ * How many of a toolbar's entries fit, from the start: the first `count`
+ * stay in the toolbar, with every pinned entry after them, and the rest go
+ * into a "More" menu.
+ *
+ * Pinned entries take their room first, wherever they are. Room for "More"
+ * is kept only when something does not fit — when everything does, the
+ * result is every entry and no "More" is drawn. Entries are taken in order
+ * and the first that does not fit ends the count, so the toolbar keeps its
+ * order rather than filling gaps with later, narrower entries; one with no
+ * width, a spacer, fits wherever the entries before it did.
+ */
+declare function fitToolbarItems({ widths, available, moreWidth, pinned, }: ToolbarFitInput): number;
+/**
+ * Whether a toolbar entry stays in the toolbar however narrow it gets: the
+ * search box and custom entries, which have no menu item to become.
+ */
+declare function isPinnedToolbarItem(item: Pick<ResolvedToolbarItem, "type">): boolean;
+/** A toolbar split at the count `fitToolbarItems` gave — see `splitToolbarItems`. */
+interface ToolbarSplit {
+    /** What stays in the toolbar. */
+    readonly shown: readonly ResolvedToolbarItem[];
+    /** The "More" menu's entries, empty when everything fits. */
+    readonly overflow: readonly ResolvedMenuEntry[];
+}
+/**
+ * `items` split at the first `fit`: those before it, and every pinned item,
+ * stay in the toolbar; the rest become the "More" menu's entries — a button
+ * an item, checked where it was pressed, and a dropdown a submenu. Neither
+ * side keeps a separator at its ends, doubled, or beside a spacer.
+ */
+declare function splitToolbarItems(items: readonly ResolvedToolbarItem[], fit: number): ToolbarSplit;
+
+/**
+ * What a search box shows for `filter`: the global text entry's query — the
+ * one naming no column — without the `%` anchors that make it a "contains"
+ * match, or `""` when there is none. A `%` the user typed inside the text
+ * stays: only the first and last characters are anchors.
+ */
+declare function searchTextOf<Row>(filter: FilterState<Row>): string;
+/**
+ * `filter` with its global text entry set to search for `text` anywhere in
+ * any column — the query `%text%` — or removed for an empty `text`. Every
+ * entry naming a column stays as it was. `filter` itself, unchanged, when
+ * it already searches for `text`.
+ *
+ * `text` is written as typed, spaces and all: a search box reads its text
+ * back from the filter, and trimming here would take a space away from
+ * under the caret as the user types it.
+ */
+declare function setSearchText<Row>(filter: FilterState<Row>, text: string): FilterState<Row>;
+
+/**
+ * How a column of `type` aligns by default. Numeric types align right so that
+ * their digits line up by place value; everything else reads from the left.
+ */
+declare function alignmentForType(type: ColumnType): ColumnAlignment;
+/**
+ * Derives one column per field across `rows`, in the order each field is first
+ * seen — so a key that only appears in a later row still gets a column,
+ * appended at the end. Nested objects contribute their non-object properties
+ * as `"Parent.Child"`; anything deeper is skipped, as is the nested object
+ * itself.
+ *
+ * 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, 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.
+ */
+declare function getColumnId<Row>(column: ColumnDefinition<Row, unknown>): string;
+/**
+ * The key state about a row is stored under, and the key it renders with — the
+ * row's counterpart to `getColumnId`, and for the same reason: every such
+ * lookup goes through here so no two can disagree.
+ *
+ * Falls back to the position so a grid given no `getRowId` still works. That
+ * fallback ties a selection to where a row sits rather than to the row, so
+ * anything that sorts, filters or pages its data has to supply one — otherwise
+ * a re-sort leaves the same positions selected under different rows.
+ */
+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 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 column has a filter menu the header opens. Defaults to `false`. */
+    filterable?: boolean | undefined;
+    /** 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
+ * that column actually responds to — so the keys are discoverable, since
+ * none of them is a convention a user would try unprompted.
+ */
+declare function buildKeyShortcuts(capabilities: KeyShortcutCapabilities): string;
+/**
+ * Accesses a value at a dotted path, e.g. `foo.bar.baz`.
+ *
+ * @param obj The object to access
+ * @param path Path to the value, e.g. `"foo.bar"`
+ * @returns The value at `path`, or `undefined` if it doesn't exist
+ */
+declare function accessDotted(obj: unknown, path: string): unknown;
+
+/**
+ * The header's row index. One coordinate space covers the header and the body
+ * so that arrowing up out of the first row reaches the header without a case
+ * of its own, and every other move is plain arithmetic.
+ */
+declare const HEADER_ROW = -1;
+/** The cell the grid's single tab stop sits on. */
+interface GridFocus {
+    readonly rowIndex: number;
+    readonly columnIndex: number;
+}
+/** The modifier keys held with a navigation key press. */
+interface NavigationModifiers {
+    readonly ctrlKey: boolean;
+    readonly metaKey: boolean;
+    readonly altKey: boolean;
+    readonly shiftKey: boolean;
+}
+/**
+ * Holds a coordinate inside the grid, so that a focus surviving a column
+ * removal or a shorter page never leaves the grid with no tab stop at all —
+ * which is a grid a keyboard cannot reach.
+ */
+declare function clampFocus(focus: GridFocus, rowCount: number, columnCount: number): GridFocus;
+/**
+ * The focus a navigation key press moves to, or `null` when the key isn't
+ * this grid's to handle — left for the browser or another handler.
+ *
+ * `pageSize` is a pre-measured row count rather than a callback: this
+ * function takes plain data only, so a caller measures the viewport once and
+ * hands over the number.
+ *
+ * `isSkippableRow` names rows the vertical moves (`ArrowUp`/`ArrowDown`/
+ * `PageUp`/`PageDown`/`Ctrl+End`) never land a tab stop on — a group's own
+ * summary row (`groupAggregateDisplay: "row"`), which still occupies a real
+ * row slot for `rowCount`/`aria-rowindex` purposes but is presentational,
+ * not a stop of its own. Left/right and plain `Home`/`End` stay row-scoped
+ * and so never consult it. Defaults to skipping nothing, so every existing
+ * caller (and every horizontal move) is unaffected.
+ */
+declare function nextFocusForKey(key: string, modifiers: NavigationModifiers, focus: GridFocus, rowCount: number, columnCount: number, pageSize: number, isSkippableRow?: (rowIndex: number) => boolean): GridFocus | null;
+
+/**
+ * Puts `columns` in the order `order` gives. Ids it lists come first, in that
+ * order; columns it omits keep their position among the definitions and
+ * follow. Ids naming no column are ignored.
+ *
+ * Tolerating both gaps is what lets a stored order outlive the column list it
+ * 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`.
+ *
+ * Returns `orderedIds` itself when the move changes nothing, so callers can
+ * treat an unchanged reference as "no move happened".
+ */
+declare function moveColumnBefore(orderedIds: ColumnOrderState, movedId: string, beforeId: string | null): ColumnOrderState;
+/**
+ * Whether moving `movedId` in front of `beforeId` would rearrange anything, so
+ * that a drop indicator promises exactly the moves that happen.
+ *
+ * Defined against `moveColumnBefore` rather than restating its conditions, so
+ * the two cannot disagree about what a no-op is.
+ */
+declare function movesColumn(orderedIds: ColumnOrderState, movedId: string, beforeId: string | null): boolean;
+/**
+ * The id a drop on `side` of `targetId` lands in front of, which is `null`
+ * past the last column.
+ *
+ * "After C" and "before D" name the same gap, so collapsing both to one id
+ * keeps a drop target a single nullable string.
+ */
+declare function resolveDropBefore(orderedIds: ColumnOrderState, targetId: string, side: DropSide): string | null;
+/**
+ * The `beforeId` a keyboard nudge on `columnId` produces, for `onDrop` to
+ * apply the same way a pointer drop does — or `undefined` when the nudge is a
+ * no-op: `columnId` is not in `orderedIds`, or the nudge would move it left
+ * of the start.
+ *
+ * `null` is a real answer here, not "no-op": it means append to the end, the
+ * same convention `moveColumnBefore` uses.
+ */
+declare function resolveKeyboardDropTarget(orderedIds: ColumnOrderState, columnId: string, direction: -1 | 1): string | null | undefined;
+
+/**
+ * The selection with `id` added if absent and removed if present — a
+ * Ctrl-click, or Space on the focused member.
+ *
+ * The mode is enforced here rather than by each caller, so `"single"` cannot
+ * accumulate no matter which interaction reaches it. Returns `selection`
+ * itself when `mode` is `false`, keeping the unchanged-reference contract
+ * `moveColumnBefore` set: a caller treats an unchanged reference as "nothing
+ * happened" and neither renders nor reports.
+ */
+declare function toggleSelection(selection: SelectionState, id: string, mode: SelectionMode): SelectionState;
+/**
+ * The selection reduced to `id` alone — a plain click, which discards what
+ * came before rather than adding to it.
+ *
+ * Never deselects, so clicking the one selected row leaves it selected.
+ * Letting go of it is Ctrl-click's job, and `toggleSelection`'s.
+ */
+declare function selectOnly(selection: SelectionState, id: string, mode: SelectionMode): SelectionState;
+/**
+ * The selection replaced by every id from `anchorId` to `focusId` inclusive — a
+ * Shift-click. The two may be given in either order.
+ *
+ * Spans `orderedIds`, the order as displayed, rather than the selection's own:
+ * the range a user drew across the screen is the range they mean, whatever
+ * order they clicked its ends in. Degrades to `selectOnly` under `"single"`,
+ * where a range has nowhere to go.
+ */
+declare function selectRange(selection: SelectionState, orderedIds: readonly string[], anchorId: string, focusId: string, mode: SelectionMode): SelectionState;
+/**
+ * Every id in `orderedIds`, or `selection` untouched under any mode but
+ * `"multiple"` — there is no selecting all of one thing.
+ */
+declare function selectAll(selection: SelectionState, orderedIds: readonly string[], mode: SelectionMode): SelectionState;
+declare function clearSelection(selection: SelectionState): SelectionState;
+/**
+ * What one transition added and what it removed.
+ *
+ * Defined here rather than in an adapter so that every callback reporting a
+ * selection change reads one answer, and a select and a deselect fired for the
+ * same interaction cannot disagree about which it was.
+ */
+declare function diffSelection(previous: SelectionState, next: SelectionState): SelectionDiff;
+declare function isSameCell(a: CellSelectionState, b: CellSelectionState): boolean;
+/**
+ * The cell selection moved to `cell` — a plain click. Idempotent: clicking the
+ * selected cell again leaves it selected, matching `selectOnly`.
+ */
+declare function selectCell(selection: CellSelectionState, cell: SelectedCellRef, mode: CellSelectionMode): CellSelectionState;
+/**
+ * The cell selection moved to `cell`, or cleared when it is already there — a
+ * 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.
+ *
+ * `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
+ * each caller, so a row and a column cannot come to mean different things by
+ * the same click.
+ */
+declare function applySelectionIntent(selection: SelectionState, orderedIds: readonly string[], anchorId: string | null, id: string, intent: SelectIntent, mode: SelectionMode): SelectionState;
+
+/**
+ * Applied to any column that does not size itself. The minimum is a width a
+ * header stays legible at rather than a measured value — a column dragged
+ * narrower than this reads as a rendering fault.
+ */
+declare const DEFAULT_COLUMN_SIZES: ColumnSizeDefaults;
+/** How far one arrow key press moves a column edge. */
+declare const KEYBOARD_STEP = 10;
+/**
+ * The bounds `column` may be sized between. Resolved in one place so that a
+ * drag, a clamp and an auto-fit cannot disagree about a column's limits.
+ */
+declare function resolveColumnConstraints<Row>(column: ColumnDefinition<Row, unknown>, defaults?: Partial<ColumnSizeDefaults>): ColumnConstraints;
+/** Holds `width` within `constraints`. */
+declare function clampColumnWidth(width: number, constraints: ColumnConstraints): number;
+/**
+ * Pairs each column with everything needed to render it — the width it sits
+ * at, the label its header shows, whether it may be resized and how its cells
+ * align. Widths take the first of the sizing state, the column's own `width`,
+ * and the default, then clamp.
+ *
+ * The sizing state winning means a user's drag outlives a re-render; a column
+ * absent from it still tracks a `width` edited in the definition.
+ */
+declare function resolveColumnWidths<Row, Node>(columns: readonly ColumnDefinition<Row, Node>[], sizing: ColumnSizingState, options?: ColumnResolveOptions): readonly ResolvedColumn<Row, Node>[];
+declare function totalColumnWidth<Row, Node>(resolved: readonly ResolvedColumn<Row, Node>[]): number;
+/**
+ * Opens a resize. The session captures its constraints and starting point up
+ * front, so applying a pointer position later is arithmetic on numbers alone —
+ * which is what keeps the drag testable without a DOM.
+ *
+ * @param startPosition Where the pointer went down, on the axis being dragged.
+ */
+declare function beginColumnResize<Row>(column: ColumnDefinition<Row, unknown>, startWidth: number, startPosition: number, defaults?: Partial<ColumnSizeDefaults>): ColumnResizeSession;
+/**
+ * The width the dragged column takes with the pointer at `position`. The delta
+ * is signed, so a right-to-left adapter negates it and nothing else changes.
+ */
+declare function applyColumnResize(session: ColumnResizeSession, position: number): number;
+/**
+ * Fits columns to `availableWidth`: grows them to fill leftover space, or
+ * shrinks them to relieve an overflow, in both cases proportionally to each
+ * column's current width. Columns the user has sized are left alone in
+ * either direction, so dragging one column neither rubber-bands it back nor
+ * has it absorb a squeeze meant for the rest.
+ *
+ * Growing stops at each column's `maxWidth`; shrinking stops at its
+ * `minWidth`. If shrinking every adjustable column to its floor still does
+ * not reach `availableWidth`, the columns are returned untouched and the
+ * container scrolls rather than crushing them further.
+ */
+declare function fitColumnsToWidth<Row, Node>(resolved: readonly ResolvedColumn<Row, Node>[], availableWidth: number, defaults?: Partial<ColumnSizeDefaults>): readonly ResolvedColumn<Row, Node>[];
+/**
+ * The width a column needs to show `measuredWidth` of content.
+ *
+ * `padding` is an allowance on top of the measurement, since a column sized to
+ * exactly its content can still round down into an ellipsis.
+ */
+declare function sizeColumnToContent(measuredWidth: number, constraints: ColumnConstraints, padding?: number): number;
+/**
+ * `current` with `columnId` reverted to its width in `base` — or omitted
+ * entirely if `base` had none — for Escape to restore a resize in progress.
+ *
+ * A column with no stored width in `base` is correctly omitted by deleting
+ * the key rather than merging its `base` width back in, which would
+ * otherwise leave it pinned and hidden from auto-fit.
+ */
+declare function revertColumnSize(current: ColumnSizingState, base: ColumnSizingState, columnId: string): ColumnSizingState;
+
+/**
+ * Compares two cell values the way `type` implies — numerically for the
+ * numeric types, chronologically for the date/time types, lexically
+ * otherwise. Defaults to string comparison when `type` is absent, mirroring
+ * `ColumnDefinition.type`'s own default.
+ *
+ * `null`/`undefined` sort after every value on both sides. Used directly,
+ * that ordering is fixed; `sortRows` applies it directionally without
+ * disturbing it — see its own doc comment.
+ */
+declare function compareValues(a: unknown, b: unknown, type?: ColumnType): number;
+/** This column's direction in `sort`, or `null` outside it. */
+declare function sortDirectionFor(sort: ColumnSortState, columnId: string): SortDirection | null;
+/** This column's 1-based place in `sort`, or `null` outside it. */
+declare function sortPriorityFor(sort: ColumnSortState, columnId: string): number | null;
+/**
+ * The sort with `columnId` cycled to its next direction — none → asc → desc →
+ * none.
+ *
+ * `stack: false` (a plain click) means "sort by only this column": unless
+ * `columnId` is already the sole entry, in which case its own cycle just
+ * continues, it collapses `sort` down to `columnId` alone at `"asc"`,
+ * regardless of any direction it held as part of a larger stack.
+ *
+ * `stack: true` (a Shift-click) cycles or appends `columnId` in place without
+ * disturbing the rest of the stack; cycling it back to `"none"` removes it
+ * and closes the gap, leaving the others in their existing order.
+ */
+declare function toggleColumnSort(sort: ColumnSortState, columnId: string, options: {
+    readonly stack: boolean;
+}): ColumnSortState;
+/**
+ * `rows` ordered by `sort` — each entry read against `columns` for its
+ * `field` and `type` — with `rowIndex` and `datasetIndex` renumbered to
+ * match the new positions, the invariant the rest of the grid relies on for
+ * keyboard navigation and `aria-rowindex`.
+ *
+ * Stable (`Array.prototype.sort` has been stable since ES2019), so rows
+ * equal under every active key keep their relative order. A `null`/
+ * `undefined` value sorts last under either direction — resolved before
+ * `compareValues` is asked, and left out of the direction flip below, so
+ * that toggling a column reorders the values it holds rather than moving its
+ * gaps to the front.
+ *
+ * Returns `rows` itself, untouched, when `sort` is empty or names only
+ * 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 DataColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
+
+/**
+ * Whether `value`, stringified, matches `query`'s SQL LIKE-style pattern —
+ * case-insensitive always. A bare query is an exact match; `%text%` is
+ * contains; `text%` is starts-with; `%text` is ends-with. `null`/`undefined`
+ * stringify to `""`.
+ *
+ * A one-shot convenience: parses `query` fresh on every call. `filterRows`
+ * does not call this per cell — it compiles each `TextFilterEntry` once,
+ * outside its row loop.
+ */
+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`/`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;
+/**
+ * The filter with the `TextFilterEntry` for `columnId` (or the global
+ * entry, when `columnId` is omitted) set to `query` — replacing whatever
+ * entry already holds that key, of any variant, if present; appending a new
+ * `TextFilterEntry` if not. An empty `query` removes the entry instead of
+ * storing a filter that can never usefully match.
+ *
+ * Returns `filter` itself, unchanged, when the result would be a no-op: an
+ * empty `query` naming a key with no existing entry, or a `query` equal to
+ * an existing `TextFilterEntry`'s.
+ */
+declare function setColumnFilter<Row>(filter: FilterState<Row>, columnId: (FieldPath<Row> | (string & {})) | undefined, query: string): FilterState<Row>;
+/** `filter` reduced to empty. Returns `filter` itself when already empty. */
+declare function clearAllFilters<Row>(filter: FilterState<Row>): FilterState<Row>;
+/**
+ * `rows` reduced to those matching every entry in `filter` (AND at the top
+ * level — nest a `GroupFilterEntry` for OR). `rowIndex` and `datasetIndex`
+ * are renumbered to match the retained positions — the same invariant
+ * `sortRows` keeps,
+ * needed here independently since `filterRows` runs before `sortRows` in
+ * the composed pipeline (see `resolveShownRows`).
+ *
+ * Order-preserving: surviving rows keep their relative order, which is what
+ * makes running this before a sort produce the identical final order a
+ * sort-then-filter would — only the cost differs.
+ *
+ * Every entry is compiled once, before the row loop.
+ *
+ * Returns `rows` itself, untouched, when `filter` is empty or names only
+ * 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 DataColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
+
+/**
+ * This group's id, from its path. Every group-id producer/consumer in this
+ * package goes through this — never join `path` by hand elsewhere.
+ *
+ * `JSON.stringify` rather than a delimiter join: a delimiter would have to be
+ * escaped in every segment to stay collision-free against a value that
+ * legitimately contains it, and `JSON.stringify` already draws that
+ * boundary between array entries for free.
+ */
+declare function groupRowId(path: readonly unknown[]): string;
+/**
+ * `rows`, regrouped into `groupBy`'s stacked levels — a group header per
+ * distinct value at each level, ordered by `compareValues` per that level's
+ * own `direction`, followed depth-first by its nested groups and/or data
+ * rows. A collapsed group (its `groupId` present in `expansion`) contributes
+ * only its own header, nothing beneath it — but its `count` still reports
+ * the group's full leaf-row count either way.
+ *
+ * Filter and sort are expected to have already run (see `resolveShownRows`):
+ * this only reshapes their output, and never changes which rows appear or
+ * their relative order within a group.
+ *
+ * `rowIndex` and `datasetIndex` are renumbered across the whole flattened
+ * output, header rows included — the same invariant `sortRows`/`filterRows`
+ * keep for a `ResolvedRow`, extended to `ResolvedGroupRow` since `GridBody`
+ * addresses both kinds by the same flat position, and `aria-rowindex`
+ * counts both.
+ *
+ * Returns `rows` itself, untouched, when `groupBy` is empty or names only
+ * 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 DataColumn<Row, unknown>[]): readonly DisplayRow<Row>[];
+/**
+ * The expansion with `groupId` collapsed if it was expanded, or expanded if
+ * it was collapsed.
+ */
+declare function toggleGroupExpansion(expansion: GroupExpansionState, groupId: string): GroupExpansionState;
+/** `expansion` reduced to empty — every group expanded. Mirrors `clearAllFilters`. */
+declare function expandAllGroups(expansion: GroupExpansionState): GroupExpansionState;
+/**
+ * Every group id present in `rows` — for collapsing every group currently
+ * shown in one call. Operates on the already-grouped display, not the raw
+ * grouping, so a group hidden beneath an already-collapsed ancestor (and so
+ * 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;
+/**
+ * `groupBy` with `columnId` positioned in front of `beforeColumnId` — or at
+ * the end when that is `null` — inserting a fresh entry if `columnId` isn't
+ * already part of the stack, or lifting its existing entry out and back in
+ * if it is. The one function both a header dropped on the group-by bar and
+ * a chip dragged within it need: the former's `columnId` is usually new to
+ * the stack, the latter's never is, and this doesn't need to be told which.
+ *
+ * An existing entry keeps its own object (and so its own `direction`)
+ * rather than being rebuilt, so a level merely repositioned stays
+ * reference-equal at its new index — the same reason `moveColumnBefore`
+ * moves ids rather than rebuilding them.
+ *
+ * Returns `groupBy` itself, untouched, when the move changes nothing: a
+ * drop on the entry's own id, or back into the gap it already occupies, or
+ * naming a `beforeColumnId` absent from the stack. Inserting a column not
+ * yet in the stack is never a no-op.
+ */
+declare function moveGroupByBefore(groupBy: GroupByState, columnId: string, beforeColumnId: string | null): GroupByState;
+/**
+ * Whether moving `columnId` in front of `beforeColumnId` would change
+ * `groupBy` at all, so that a drop indicator promises exactly the move that
+ * happens. Defined against `moveGroupByBefore` rather than restating its
+ * conditions, the same relationship `movesColumn` keeps with
+ * `moveColumnBefore`.
+ */
+declare function movesGroupBy(groupBy: GroupByState, columnId: string, beforeColumnId: string | null): boolean;
+
+/**
+ * `rows`, filtered then sorted — the one function `DataGrid.tsx` (and any
+ * future framework binding) calls instead of composing `filterRows`/
+ * `sortRows` itself.
+ *
+ * Filter always runs first: an O(n) pass that shrinks what the O(n log n)
+ * sort has to touch whenever a filter is active, free when it isn't. This
+ * is a performance choice, not a correctness one — filtering is an
+ * 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 DataColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
+/**
+ * `ids` resolved back to the rows behind them, keyed by `rowsById`.
+ *
+ * An id with no row behind it is dropped rather than left `undefined`: a
+ * selection outlives a change to the data, so that filtering a row out and
+ * back leaves it selected, and only what still exists can be handed to a
+ * callback.
+ */
+declare function resolveRows<Row>(rowsById: ReadonlyMap<string, ResolvedRow<Row>>, ids: readonly string[]): readonly ResolvedRow<Row>[];
+/**
+ * `ids` resolved back to the columns behind them, paired with the position
+ * each holds in `columns` — a stale id is dropped, matching `resolveRows`.
+ */
+declare function resolveColumns<Row, Node>(columns: readonly ResolvedColumn<Row, Node>[], ids: readonly string[]): readonly SelectedColumn<Row, Node>[];
+/**
+ * `cell` resolved down to the row, column and value it addresses — `null`
+ * when there is no cell, or when either half of it names a row or column
+ * that no longer exists.
+ */
+declare function resolveCell<Row, Node>(rowsById: ReadonlyMap<string, ResolvedRow<Row>>, columns: readonly ResolvedColumn<Row, Node>[], cell: SelectedCellRef | null): SelectedCell<Row, Node> | null;
+
+interface PaginatedRows<Row> {
+    readonly rows: readonly DisplayRow<Row>[];
+    readonly pageCount: number;
+    /**
+     * `pagination.pageIndex` clamped into `[0, pageCount - 1]` (or `0` when
+     * `pageCount` is `0`) — read this back rather than trusting the input
+     * verbatim, the same way `sortRows`/`filterRows` tolerate a stale stored
+     * state.
+     */
+    readonly pageIndex: number;
+}
+/**
+ * `rows` sliced into pages of `pagination.pageSize` units — see `unitsOf`
+ * for what a unit is. `pageIndex` is clamped into range, `pageSize <= 0` is
+ * clamped to `1` (this codebase's general tolerance for stale/odd stored
+ * state, matching `sortRows`/`filterRows`), and the returned page's
+ * `rowIndex` is renumbered to be page-relative — 0-based from the top of the
+ * page, header rows included, mirroring `groupRows`'s own renumbering
+ * invariant. `datasetIndex` is left untouched: the stages ahead of this one
+ * set it to each row's position in the whole displayed result, which stays
+ * the same whichever page is showing.
+ */
+declare function paginateRows<Row>(rows: readonly DisplayRow<Row>[], pagination: PaginationState): PaginatedRows<Row>;
+
+type PaginationWindowEntry = number | "ellipsis";
+/**
+ * Which page numbers a numbered pager should show for `currentPage` of
+ * `pageCount` — the boundary + sibling windowing MUI's `usePagination` uses.
+ * Always includes the first/last `boundaryCount` pages and a run of
+ * `2 * siblingCount + 1` pages around `currentPage`, slid inwards rather than
+ * cut short near either end, with one slot between each boundary and that
+ * run holding either the single page it skips or an `"ellipsis"`.
+ *
+ * So once `pageCount` exceeds `2 * boundaryCount + 2 * siblingCount + 3`,
+ * every window is exactly that many entries long, wherever `currentPage`
+ * sits: a pager drawing one fixed-width slot per entry keeps its trailing
+ * controls in place as the user pages through. Below that, every page shows.
+ */
+declare function paginationWindow(currentPage: number, pageCount: number, options?: {
+    boundaryCount?: number | undefined;
+    siblingCount?: number | undefined;
+}): readonly PaginationWindowEntry[];
+
+/**
+ * `rows` reduced through every spec in `specs`, keyed by `spec.id ??
+ * spec.columnId`. A custom `fn` (a plain function, not a `BuiltInAggregate`
+ * name) is called once with the raw `rows` — no wrapping, no
+ * pre-processing, so it sees exactly the same leaf set a built-in reducer
+ * does.
+ *
+ * Two specs resolving to the same key: the later one wins, matching
+ * `setColumnFilter`'s own silent-replace precedent for a key collision
+ * rather than throwing.
+ *
+ * Returns a fresh empty `Map` for empty `rows` or empty `specs` — never a
+ * 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 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>;
+/**
+ * Whether `filter` filters `columnId` — whether `describeColumnFilter` reads
+ * it as anything but `"none"` — for a header to show its column as
+ * filtered. A global search filters every column alike, so it marks none.
+ */
+declare function isColumnFiltered<Row>(filter: FilterState<Row>, columnId: string): boolean;
+/**
+ * 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 condition row of a simple filter editor as the user types it: text,
+ * not yet a value, so a half-typed number or date stays in its input until
+ * the editor is applied and `conditionsFromRows` reads it.
+ */
+interface ConditionRowDraft {
+    readonly operator: FilterOperator;
+    /** The operand as typed — `between`'s lower end. */
+    readonly text: string;
+    /**
+     * `between`'s upper end, as typed. Kept under any other operator, unread,
+     * so switching back to `between` finds it still there.
+     */
+    readonly textTo: string;
+}
+/** What `conditionsFromRows` reads off an editor's rows. */
+interface ParsedConditionRows<Row> {
+    /** A condition for each row that reads as one, in row order. */
+    readonly conditions: readonly OperatorFilterEntry<Row>[];
+    /**
+     * The indexes of the rows that don't, for the editor to mark. Apply the
+     * conditions only once this is empty.
+     */
+    readonly invalid: readonly number[];
+}
+/**
+ * The rows a simple editor opens with over a column's filter `shape`, its
+ * operands written as the column's `type` reads them: two, holding the
+ * column's conditions when its filter is conditions, and each row they
+ * don't fill starting at the first of `operators`, empty. With no operator
+ * to start one at, only the rows the filter fills.
+ */
+declare function conditionRowsFrom<Row>(shape: ColumnFilterShape<Row>, operators: readonly FilterOperator[], type: ColumnType | undefined): readonly ConditionRowDraft[];
+/**
+ * The conditions a simple editor's rows stand for on `columnId`, each
+ * operand read as the column's `type` filters (`parseFilterOperand`) — for
+ * `filterEditorReducer`'s `setConditions`, with the combinator the editor
+ * shows.
+ *
+ * A row needs every operand its operator takes, or it is `invalid`; the
+ * blanks operators take none. A row after the first left empty is dropped
+ * rather than invalid, since the second condition is optional; an empty
+ * first row is invalid — clearing the filter is the editor's clear action,
+ * not an apply with nothing typed.
+ */
+declare function conditionsFromRows<Row>(rows: readonly ConditionRowDraft[], columnId: string, type: ColumnType | undefined): ParsedConditionRows<Row>;
+
+/**
+ * What a cached list is labelled by: `columnValueOptions`' query without
+ * `search` and `limit`, which a draft applies over the whole list.
+ */
+type ColumnValueCacheQuery = Pick<ColumnValueQuery, "locale" | "messages">;
+/** `columnValueOptions`, remembered per column. */
+interface ColumnValueOptionsCache<Row> {
+    /**
+     * `columnId`'s whole value list — `columnValueOptions` with no `search`
+     * or `limit` — or the very list it returned last time, when nothing the
+     * list is counted from or labelled by has changed since.
+     */
+    readonly get: (rows: readonly Row[], dataColumns: readonly DataColumn<Row, unknown>[], filter: FilterState<Row>, columnId: string, query?: ColumnValueCacheQuery) => ColumnValueOptions;
+}
+/**
+ * A memo of each column's checklist values, for a renderer to hold one of
+ * per grid: reopening a column's checklist hands back the list it was given
+ * last time — the same object — rather than counting `rows` again, until
+ * something the list depends on changes.
+ *
+ * That is the `rows` and `dataColumns`, the `locale` and `messages` it is
+ * labelled in, and the filter's entries not about the column — all compared
+ * by identity, the entries one by one. Identity holds across an apply:
+ * `draftToFilter` keeps every entry it doesn't replace as it was, so
+ * filtering one column leaves the lists of the others to recount and its
+ * own cached, since a column's list never depends on its own entries.
+ *
+ * Each column keeps its latest list. New rows, columns, locale or messages
+ * drop every list, so the cache never holds on to rows the grid has let go
+ * of — pass the grid's own, which keep their identity between renders.
+ */
+declare function createColumnValueOptionsCache<Row>(): ColumnValueOptionsCache<Row>;
+
+/** One row of a checklist: a value the column holds, or its blank cells. */
+type FilterChecklistItem = {
+    /**
+     * Tells the item apart from every other in the list: a value's key is the
+     * one `draft.checked` holds it under, and the blanks have their own.
+     */
+    readonly key: string;
+    /** The value as its cells print it, or the blanks' label. */
+    readonly label: string;
+    /** How many rows hold it, among those the other columns' filters keep. */
+    readonly count: number;
+    readonly checked: boolean;
+} & ({
+    /** Toggled with `filterEditorReducer`'s `toggleValue`. */
+    readonly kind: "value";
+    readonly value: Exclude<FilterScalar, null>;
+} | {
+    /** Toggled with `filterEditorReducer`'s `setIncludeBlanks`. */
+    readonly kind: "blanks";
+});
+interface FilterChecklistOptions {
+    /** How many values the list shows at most: the column's resolved `valueLimit`. */
+    readonly valueLimit: number;
+    /** The blanks item's label: the grid's `filterBlanks` message. */
+    readonly blanksLabel: string;
+}
+/** What a checklist editor draws below its search box and select-all. */
+interface FilterChecklist {
+    /**
+     * The rows to draw, in order: the values the search shows, cut to
+     * `valueLimit`, then the blanks while nothing is searched and some cells
+     * are blank. Empty while `needsSearch`.
+     */
+    readonly items: readonly FilterChecklistItem[];
+    /**
+     * Whether the list waits for a search: the column holds more values than
+     * `valueLimit` and nothing is searched yet — `filterSearchFirst(total)`.
+     */
+    readonly needsSearch: boolean;
+    /**
+     * How many of the values the search matches `valueLimit` left out of
+     * `items` — `filterMoreValues(hiddenCount)`. `0` while `needsSearch`, so
+     * the two notes never show together.
+     */
+    readonly hiddenCount: number;
+    /** How many values the search matches — every value while nothing is searched. Blanks aside. */
+    readonly total: number;
+}
+/**
+ * The list a checklist editor draws for `draft`: the window of values its
+ * search shows, as items carrying what each row says and whether it is
+ * checked.
+ *
+ * A column can hold far more values than a list is worth scrolling, so the
+ * list shows at most `valueLimit` of them. Past that, it shows nothing until
+ * something is searched (`needsSearch`) — every value is still in the draft,
+ * and select-all still covers them all — and a search matching more shows
+ * the first `valueLimit` of its matches in sort order, with the rest counted
+ * in `hiddenCount`.
+ *
+ * The blanks item comes last, as in Excel's, and only while nothing is
+ * searched: exactly when select-all counts the blanks, so the checkbox acts
+ * on what the list shows.
+ */
+declare function filterChecklist<Row>(draft: FilterEditorDraft<Row>, { valueLimit, blanksLabel }: FilterChecklistOptions): FilterChecklist;
+
+/**
+ * One entry per row: its measured height once known, `undefined` until then.
+ * A row never yet rendered (or rendered but not yet observed) falls back to
+ * `visibleRange`'s own `estimatedHeight` argument.
+ */
+type RowHeights = readonly (number | undefined)[];
+interface VisibleRange {
+    readonly startIndex: number;
+    readonly endIndex: number;
+    /** Total height of every row before `startIndex` — the leading spacer's height. */
+    readonly offsetBefore: number;
+    /** Total height of every row after `endIndex` — the trailing spacer's height. */
+    readonly offsetAfter: number;
+}
+/**
+ * Which rows of a dynamic-height, virtualized list fall within
+ * `[scrollTop, scrollTop + viewportHeight)`, padded by `overscan` rows on
+ * each side and clamped to the array's own bounds.
+ *
+ * Walks a cumulative-offset prefix sum built from `heights` (measured height
+ * where known, `estimatedHeight` otherwise) rather than assuming a uniform
+ * row height — this codebase's rows are not uniform (`.is-wrapped` cells,
+ * group header/summary rows), so a fixed-height virtualizer would either
+ * break wrapping or force it out of scope.
+ *
+ * `O(n)` in `heights.length`. Deliberately not a Fenwick tree or a
+ * binary-searchable prefix-sum structure — that optimization belongs in the
+ * 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;
+
+/** How `toTsv` writes its text. */
+interface TsvOptions {
+    /**
+     * Which reading of each cell is written: `"text"` (the default), as the
+     * grid shows it; or `"raw"`, the typed value written plainly.
+     */
+    readonly values?: "text" | "raw" | undefined;
+}
+/**
+ * The table as tab-separated text, records ending `"\n"` — the plain-text
+ * form a spreadsheet splits into cells when it is pasted, which is what the
+ * clipboard carries. TSV has no quoting a paste target agrees on, so a tab
+ * or line break inside a cell becomes a space instead. Unlike `toCsv` it
+ * writes no byte order mark and leaves formulas alone: what is copied is
+ * exactly what the grid shows, and pasting it is the user's own act.
+ */
+declare function toTsv(table: ExportTable, options?: TsvOptions): string;
+
+/** How `toHtmlTable` writes its markup. */
+interface HtmlTableOptions {
+    /** Text for a `<caption>` above the table; none by default. */
+    readonly caption?: string | undefined;
+}
+/**
+ * The table as an HTML `<table>` string: a `<thead>` of column names when
+ * the table has a header, every row in `<tbody>`, and the grand total in
+ * `<tfoot>`. Every piece of text is escaped. It carries the semantic class
+ * names a stylesheet targets — `gridkit-export-table` on the table,
+ * `export-group` with a `data-level` on group headers,
+ * `export-group-summary` on summary rows — and nothing else of style but
+ * each column's alignment, so it reads the same pasted into a document as
+ * it does printed.
+ */
+declare function toHtmlTable(table: ExportTable, options?: HtmlTableOptions): string;
+
+/**
+ * What `exportFile` exports from: an `ExportSource` whose messages are the
+ * grid's whole set, since a writer may print any of them. A
+ * `GridCommandContext` is one as it stands.
+ */
+interface ExportFileSource<Row> extends ExportSource<Row> {
+    readonly messages: GridMessages;
+}
+/**
+ * The grid's view exported as a file of `format`: the table `options`
+ * narrow, written by that format's writer among `writers` (see
+ * `resolveExportWriters`) — or by `format` itself, when it is a writer —
+ * and named. A writer that returns a promise gives a promise of the file.
+ *
+ * A format no writer is registered for is reported and gives `null`, so a
+ * renderer saves nothing rather than failing.
+ */
+declare function exportFile<Row>(source: ExportFileSource<Row>, format: string | ExportWriter, options: GridExportOptions, writers: ReadonlyMap<string, ExportWriter>): ExportFile | Promise<ExportFile> | null;
+
+/**
+ * Turns on the per-column filter popup in its Excel-style form — a search
+ * box, a checklist of the column's values with their counts, and an operator
+ * submenu — in one spread: `<DataGrid {...excelFilter} />`.
+ *
+ * A preset is a plain value of `GridOptions`, not a component or a hook, so
+ * any renderer can take it the way it takes its other options (a Vue spread,
+ * an Angular binding) and a later option overrides it: spreading it before
+ * `filterMenu={{ ui: "simple" }}` brings the simple editor back. `filterMenu`
+ * is replaced whole, not merged, so repeat `showCounts` if it should stay.
+ */
+declare const excelFilter: {
+    readonly filterableColumns: true;
+    readonly filterMenu: {
+        readonly ui: "excel";
+        readonly showCounts: true;
+    };
+};
+
+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 ColumnFilterMenuOptions, 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 ColumnValueCacheQuery, type ColumnValueOption, type ColumnValueOptions, type ColumnValueOptionsCache, type ColumnValueQuery, type ColumnVisibilityEvent, type ColumnVisibilityState, type ColumnWrapConfig, type ColumnsSelectEvent, type ConditionRowDraft, type ContextMenuOpenChangeEvent, type CopyContent, type CopyRequest, type CopySource, type CsvOptions, DEFAULT_COLUMN_SIZES, DEFAULT_FILTER_VALUE_LIMIT, type DataColumn, type DisplayRow, type DropSide, type ExportCell, type ExportColumn, type ExportDataRow, type ExportFile, type ExportFileSource, type ExportGroupRow, type ExportGroupSummaryRow, type ExportOptions, type ExportRow, type ExportScalar, type ExportSource, type ExportTable, type ExportTotalRow, type ExportWriteContext, type ExportWriter, type FieldPath, type FilterChangeEvent, type FilterChecklist, type FilterChecklistItem, type FilterChecklistOptions, type FilterEditorAction, type FilterEditorDraft, type FilterEntry, type FilterMenuUi, type FilterOperator, type FilterOperatorFamily, 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 GridExportOptions, type GridFilterMenuOptions, 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, type HtmlTableOptions, type JsonOptions, 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 ParsedConditionRows, type PredicateFilterEntry, type PrintDocument, type PrintOptions, type PrintOrientation, type PrintPage, type PrintSource, type ResizeMode, type ResolvedColumn, type ResolvedColumnFilterMenu, 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 TsvOptions, type ValueFilterEntry, type VisibleRange, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, applyColumnVisibility, applySelectionIntent, beginColumnResize, buildExportTable, buildKeyShortcuts, buildPrintDocument, builtInCommands, clampColumnWidth, clampFocus, clearAllFilters, clearSelection, collapseAllGroups, columnValueOptions, compareValues, computeAggregates, conditionRowsFrom, conditionsFromRows, contextMenuEntries, copyContent, createColumnValueOptionsCache, createCommandContext, createDefaultMessages, createGridController, createGridViewResolver, csvWriter, defaultContextMenu, defaultFilterOperators, defaultMessages, defaultToolbar, defineColumnsFromRows, describeColumnFilter, diffSelection, draftToFilter, excelFilter, expandAllGroups, exportFile, exportPrintDocument, filterChecklist, filterEditorReducer, filterOperandArity, filterOperatorFamily, filterQueryFor, filterRows, fitColumnsToWidth, fitToolbarItems, formatAggregateValue, formatCellValue, formatFilterOperand, formatGroupValue, getColumnId, groupRowId, groupRows, hasContextMenu, initialFilterEditorDraft, intentOf, isColumnFiltered, isColumnVisible, isPinnedToolbarItem, isSameCell, jsonWriter, matchesQuery, moveColumnBefore, moveGroupByBefore, movesColumn, movesGroupBy, nextFocusForKey, nextMenuIndex, paginateRows, paginationWindow, parseFilterOperand, resolveCell, resolveColumnChooser, resolveColumnConstraints, resolveColumnFilterMenu, resolveColumnHeaderText, resolveColumnLabel, resolveColumnWidths, resolveColumns, resolveCommands, resolveDataColumns, resolveDropBefore, resolveExportWriters, 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, toCsv, toHtmlTable, toJson, toTsv, toggleCellSelection, toggleColumnSort, toggleGroupExpansion, toggleSelection, toolbarEntries, totalColumnWidth, typeaheadIndex, visibleFilterOptions, visibleRange, withGroupAggregates };