@jielga/tmdatagrid 2.0.0-beta.8 → 2.0.0

package/dist/index.d.ts

@@ -1,17 +1,9 @@
-import { Cell, Column, ColumnPinningState, ExpandedState, Header, Row, RowData, RowSelectionState, Table, TableFeatures, TableOptions, TableState, aggregationFns } from "@tanstack/react-table";
+import { BoxProps, MantineSize, MenuProps } from "@mantine/core";
 import { CSSProperties, ComponentType, MouseEvent, MutableRefObject, ReactNode } from "react";
+import { AccessorFn, AccessorFnColumnDef, AccessorKeyColumnDef, Cell, Column, ColumnFiltersState, ColumnHelper, ColumnPinningState, DeepKeys, DeepValue, DisplayColumnDef, ExpandedState, GroupColumnDef, Header, IdentifiedColumnDef, Row, RowData, RowSelectionState, Table, TableFeatures, TableOptions, TableState, aggregationFns } from "@tanstack/react-table";
 import { Store } from "@tanstack/store";
-import { MantineSize, MenuProps } from "@mantine/core";
 import { AnyFieldApi, AnyFormApi, StandardSchemaV1 } from "@tanstack/react-form";
 import { RankingInfo } from "@tanstack/match-sorter-utils";
-//#region .types-tmp/components/TMDataGridColumnsPanel.d.ts
-/**
- * The "Manage columns" surface. Reachable from every column header menu and
- * from the grid's burger menu, so it lives on its own and is rendered by
- * `TMDataGrid.ColumnsButton`.
- */
-declare function TMDataGridColumnsPanel(): import("react").JSX.Element;
-//#endregion
 //#region .types-tmp/core/sizes.d.ts
 type TMDataGridSize = MantineSize;
 declare const DEFAULT_TMDATAGRID_SIZE: TMDataGridSize;
@@ -41,28 +33,6 @@ type TMDataGridContextValue = TMDataGridApi<TMDataGridRowData> & {
   controlSize: TMDataGridSize;
 };
 declare function useTMDataGridContext(): TMDataGridContextValue;
-/**
- * What a control inside a *body* cell should put in its `tabIndex`.
- *
- * `-1` once cell selection is on, and this is what makes the promise of one tab
- * stop true. Without it the browser walks Tab into the checkbox of every
- * mounted row - a grid showing twenty rows would be twenty tab stops, and
- * scrolling would change how many. Enter or F2 steps into the cell instead,
- * which reaches a `-1` control perfectly well.
- *
- * Header controls are not covered: the header row is not part of cell
- * navigation, so its sort buttons and menus stay in the tab order, where they
- * are the only way to reach them.
- *
- * A custom cell renderer with a control in it wants the same:
- *
- * ```tsx
- * cell: ({ row }) => (
- *   <Button tabIndex={useCellControlTabIndex()} onClick={...}>Open</Button>
- * )
- * ```
- */
-declare function useCellControlTabIndex(): 0 | -1;
 //#endregion
 //#region .types-tmp/core/columnOptions.d.ts
 /**
@@ -79,17 +49,21 @@ type TMDataGridOption = {
   /** Dropdown group heading. Ungrouped options render first. */
   group?: string;
 };
-type TMDataGridOptionsArgs = {
-  table: TMDataGridTable<TMDataGridRowData>;
-  column: Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
+/**
+ * What an options function is called with. `TData` is the row type of the
+ * column helper the column was declared with.
+ */
+type TMDataGridOptionsArgs<TData extends RowData = TMDataGridRowData> = {
+  table: TMDataGridTable<TData>;
+  column: Column<TMDataGridFeatures, TData, unknown>;
   /** The row an editor is standing on. Absent when the filter panel asks. */
-  row?: Row<TMDataGridFeatures, TMDataGridRowData>;
+  row?: Row<TMDataGridFeatures, TData>;
   /**
    * Source to use when the column declares none. The filter panel passes
    * `"faceted"` so a select column with no `meta.options` still offers the
    * values that exist, rather than an empty dropdown.
    */
-  fallback?: TMDataGridOptionsSource;
+  fallback?: TMDataGridOptionsSource<TData>;
 };
 /**
  * Where a column's options come from - `meta.options`. One declaration feeds
@@ -101,7 +75,7 @@ type TMDataGridOptionsArgs = {
  * | `"faceted"` | low-cardinality data columns: the distinct values present, via `getFacetedUniqueValues` |
  * | function | large or contextual sets - `row` is set when an editor asks, so options can depend on the record (city given country) |
  */
-type TMDataGridOptionsSource = ReadonlyArray<TMDataGridOption | string> | "faceted" | ((args: TMDataGridOptionsArgs) => ReadonlyArray<TMDataGridOption | string>);
+type TMDataGridOptionsSource<TData extends RowData = TMDataGridRowData> = ReadonlyArray<TMDataGridOption | string> | "faceted" | ((args: TMDataGridOptionsArgs<TData>) => ReadonlyArray<TMDataGridOption | string>);
 /**
  * A column's options as a normalised list, whatever form `meta.options` took.
  * Empty for a column that declares none.
@@ -127,64 +101,6 @@ type ComboboxData = Array<ComboboxItem | {
  */
 declare function optionsToComboboxData(options: ReadonlyArray<TMDataGridOption>): ComboboxData;
 //#endregion
-//#region .types-tmp/core/filterOperators.d.ts
-/**
- * The value shape stored in `columnFilters` for every TMDataGrid column.
- *
- * TanStack resolves `filterFn` statically per column, so the operator travels
- * inside the filter *value* instead. That keeps the filter model plain,
- * serialisable JSON, so a server-side `manualFiltering` table can forward
- * `columnFilters` to the API unchanged.
- *
- * `value` is a string array under `isAnyOf` / `isNoneOf` (the set the cell is
- * tested against), a `[min, max]` pair under `between` (an empty string means
- * that end is open), and a single string everywhere else - dates travel as
- * ISO `YYYY-MM-DD` strings, booleans as `"true"` / `"false"`. Still plain
- * JSON.
- */
-type TMDataGridFilterValue = {
-  operator: TMDataGridFilterOperator;
-  value: string | ReadonlyArray<string>;
-};
-type TMDataGridColumnType = "string" | "number" | "boolean" | "date" | "select" | "multiSelect";
-type TMDataGridFilterOperator = "contains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "between" | "before" | "after" | "onOrBefore" | "onOrAfter" | "isAnyOf" | "isNoneOf" | "isEmpty" | "isNotEmpty";
-declare const FILTER_OPERATOR_LABELS: Record<TMDataGridFilterOperator, string>;
-declare function getOperatorsForType(type: TMDataGridColumnType): readonly TMDataGridFilterOperator[];
-declare function getDefaultOperator(type: TMDataGridColumnType): TMDataGridFilterOperator;
-declare function operatorNeedsValue(operator: TMDataGridFilterOperator): boolean;
-/** Whether the operator's value is a string array - `isAnyOf` / `isNoneOf`. */
-declare function operatorTakesArrayValue(operator: TMDataGridFilterOperator): boolean;
-/** Whether the operator's value is a `[min, max]` pair - `between`. */
-declare function operatorTakesRangeValue(operator: TMDataGridFilterOperator): boolean;
-/** The untouched value a fresh filter starts with - the operator's shape, empty. */
-declare function emptyValueForOperator(operator: TMDataGridFilterOperator): string | ReadonlyArray<string>;
-/**
- * A filter only narrows the row set once it has something to compare against.
- * Half-typed filters stay in state (so the panel keeps rendering their row) but
- * are treated as inactive for the funnel indicator and for row matching.
- */
-declare function isFilterActive(value: unknown): boolean;
-/**
- * One-line description of a single filter, as shown on a filter pill.
- *
- * The type's default operator is left implicit - "First name: Sofia" reads the
- * way a person would say it - while any other operator is spelled out, since
- * that is the part a reader cannot guess.
- */
-declare function formatFilterLabel({ label, type, filter, operatorLabels }: {
-  label: string;
-  type: TMDataGridColumnType;
-  filter: TMDataGridFilterValue;
-  /** Localized operator names - `labels.operators`. Defaults to English. */
-  operatorLabels?: Record<TMDataGridFilterOperator, string>;
-}): string;
-/**
- * The single filter function every TMDataGrid column uses. It dispatches on the
- * operator carried by the filter value, which is what lets one column offer
- * "contains" / "does not equal" / "is empty" without redefining the column.
- */
-declare function tmDataGridFilterFn<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown): boolean;
-//#endregion
 //#region .types-tmp/core/editEngine.d.ts
 /**
  * What counts as a commit - one axis, each mode a thin policy over the same
@@ -276,8 +192,10 @@ type TMDataGridTableValidateArgs<TData extends RowData = TMDataGridRowData> = {
 /**
  * `editing.tableValidators` - rules that need the other rows: no duplicate
  * keys, no overlapping ranges, allocations summing to a total. Run at every
- * commit, after the row's own validators, and again per parked row during
- * `saveDrafts` - so a draft invalidated by a later edit blocks the save.
+ * commit, after the row's own validators, and again per committed row during
+ * `saveDrafts`, the only rules that run there - a committed row a later edit
+ * invalidated is reopened with the error, and the save reports it in
+ * `reopened`.
  *
  * Return nothing to pass, a message, or Form's `{ form, fields }` shape;
  * pathed issues land on the committing row's cells, pathless ones on the row.
@@ -353,27 +271,40 @@ type TMDataGridEditState = {
     columnId: string | null;
   } | null;
   /**
-   * Rows with a live form, committed or not - every row the grid is holding
-   * work for. A row is *open* (undecided form state) when it is in here and
-   * not in {@link committedRowIds}.
+   * Every row the grid is holding work for: open rows, whose form is still
+   * undecided, and committed rows, whose values wait in the draft store. In
+   * the order the rows first entered; a reopen keeps a row's place. A row is
+   * *open* when it is in here and not in {@link committedRowIds}, or, for an
+   * entry row, not flagged `committed` in {@link newRows}.
    */
   openRowIds: ReadonlyArray<string>;
   rows: Record<string, TMDataGridEditRowProjection>;
   /**
-   * The draft store's edit slice: existing rows whose form passed its submit
-   * and is parked, waiting for `saveDrafts`. A subset of `openRowIds` - the
-   * values stay in the row's form, this records which side of the line the
-   * row is on. `begin` on one of these takes it back out, into form state.
+   * The draft store's edit slice: existing rows that passed their commit and
+   * wait for `saveDrafts`. A committed row is data, not a form: its values
+   * are in {@link committedValues}, and `begin` on one of these builds a
+   * fresh form from them and takes the row back out.
    *
-   * Only `editing.draft` parks. Without it a commit goes straight to the
-   * consumer and the form is dropped, so this stays empty.
+   * Only `editing.draft` commits into the store. Without it a commit goes
+   * straight to the consumer, so this stays empty.
    */
   committedRowIds: ReadonlyArray<string>;
+  /**
+   * The draft store's values, per row - what a committed row *is* to the
+   * table. Snapshotted when a row commits (existing and entry rows alike)
+   * and kept across a reopen until the row commits again or is dropped, so
+   * a row keeps its place in the sort while a second cell is being typed
+   * into. The hook feeds these into the table's `data` in place of the
+   * consumer's records, which is how sorting, filtering, grouping and
+   * aggregates see a draft.
+   */
+  committedValues: Readonly<Record<string, TMDataGridRowData>>;
   /**
    * Rows being created, not yet in `data`. `committed` is the draft store's
    * add slice: the entry row passed its submit and renders as a value row
-   * until `begin` re-opens it. Without `editing.draft` a commit adds through
-   * `onRowAdd` and the entry is dropped, so it never turns `true`.
+   * from {@link committedValues} until `begin` re-opens it. Without
+   * `editing.draft` a commit adds through `onRowAdd` and the entry is
+   * dropped, so it never turns `true`.
    */
   newRows: ReadonlyArray<{
     tempId: string;
@@ -381,9 +312,29 @@ type TMDataGridEditState = {
   }>;
   /** The draft store's delete slice: rows marked deleted, awaiting the save. */
   deletedRowIds: ReadonlyArray<string>;
+  /**
+   * `true` while `saveDrafts` is in flight - from the call until the
+   * consumer's callbacks (`onSaveDrafts`, or the per-row `onCommit` /
+   * `onRowAdd` / `onRowDelete` loop) have settled. Concurrent `saveDrafts`
+   * calls join the same run, so it flips once per run. It stays `false` for
+   * a save that finds nothing to send.
+   */
+  isSaving: boolean;
 };
-type ErasedRow = Row<TMDataGridFeatures, TMDataGridRowData>;
-type ErasedColumn = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
+/**
+ * Whether the grid holds anything a navigation would lose: an open row with
+ * a moved value, an entry row, the draft store (edits, new rows, deletion
+ * marks), or a save still in flight.
+ *
+ * A pure selector over the edit state, so `useSelector(edit.store,
+ * hasPendingEdits)` re-renders only when the answer flips, and a navigation
+ * blocker can read `hasPendingEdits(edit.state)` at the moment it is asked.
+ * `isSaving` counts because the default per-row loop takes the deletion
+ * marks out of the store before its `onRowDelete` calls settle.
+ */
+declare function hasPendingEdits(state: TMDataGridEditState): boolean;
+type ErasedRow$1 = Row<TMDataGridFeatures, TMDataGridRowData>;
+type ErasedColumn$1 = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
 /**
  * What a cell editor is handed - deliberately both vocabularies at once. The
  * form side is TanStack Form's real `field` API (`field.state.value`,
@@ -401,8 +352,8 @@ type TMDataGridEditorArgs = {
   /** The whole row form, for the rare editor that reads sibling fields. */
   form: TMDataGridRowEditForm;
   cell: Cell<TMDataGridFeatures, TMDataGridRowData, unknown>;
-  row: ErasedRow;
-  column: ErasedColumn;
+  row: ErasedRow$1;
+  column: ErasedColumn$1;
   table: TMDataGridTable<TMDataGridRowData>;
   /** What Enter would do - commit the edit. For the editor's own UI. */
   commit: () => Promise<boolean>;
@@ -427,8 +378,8 @@ type TMDataGridEditValueMapArgs = {
   value: unknown;
   /** What the field held before this write - for length-aware masks. */
   previous: unknown;
-  row: ErasedRow;
-  column: ErasedColumn;
+  row: ErasedRow$1;
+  column: ErasedColumn$1;
   table: TMDataGridTable<TMDataGridRowData>;
 };
 /**
@@ -458,13 +409,14 @@ type TMDataGridEditValueMap = (args: TMDataGridEditValueMapArgs) => unknown;
  * `meta.type` and `meta.options` stay outside this namespace on purpose: one
  * declaration of each feeds the cell editor and the filter panel alike.
  */
-type TMDataGridColumnEditOptions = {
+type TMDataGridColumnEditOptions<TData extends RowData = TMDataGridRowData> = {
   /**
    * Whether this column's cells take edits, once `editMode` is on. `false`
    * switches the column off outright; a predicate decides per row. Defaults
    * to editable for any column that maps to a field - see {@link field}.
+   * `row` is typed by the column helper the column was declared with.
    */
-  enabled?: boolean | ((row: Row<TMDataGridFeatures, TMDataGridRowData>) => boolean);
+  enabled?: boolean | ((row: Row<TMDataGridFeatures, TData>) => boolean);
   /**
    * The data path this column edits, when it is not the `accessorKey` - the
    * only way a column built on `accessorFn` becomes editable. Dot paths reach
@@ -512,10 +464,6 @@ type TMDataGridSaveDraftsArgs<TData extends RowData> = {
   created: Array<TMDataGridRowAddArgs<TData>>;
   /** Ids marked deleted while the drafts accumulated. */
   deleted: Array<string>;
-  /** @deprecated Renamed to {@link updated}. Removed in a later beta. */
-  rows: Array<TMDataGridEditCommitArgs<TData>>;
-  /** @deprecated Renamed to {@link created}. Removed in a later beta. */
-  added: Array<TMDataGridRowAddArgs<TData>>;
 };
 /**
  * Which entries of one bucket saved. `true`, or an id the map does not name,
@@ -532,7 +480,7 @@ type TMDataGridSaveOutcomes = boolean | Record<string, boolean>;
  * with nothing beyond the state itself - a failed edit keeps `data-draft`,
  * a failed deletion keeps `data-deleted` - so the display is the consumer's.
  */
-type TMDataGridSaveDraftsResult = {
+type TMDataGridSaveDraftsResponse = {
   /** Keyed by `rowId`. */
   updated?: TMDataGridSaveOutcomes;
   /** Keyed by `tempId`. */
@@ -540,11 +488,6 @@ type TMDataGridSaveDraftsResult = {
   /** Keyed by `rowId`. */
   deleted?: TMDataGridSaveOutcomes;
 };
-/**
- * @deprecated Renamed to {@link TMDataGridSaveDraftsArgs} - the payload is
- * the draft store being saved, not a commit. Removed in a later beta.
- */
-type TMDataGridEditCommitDraftsArgs<TData extends RowData> = TMDataGridSaveDraftsArgs<TData>;
 /**
  * The data path a column edits, or `null` for a column that has none.
  *
@@ -576,6 +519,8 @@ type TMDataGridAddRowsOptions = {
 };
 /** What `edit.addRows` reports back. Every added row is in exactly one list. */
 type TMDataGridAddRowsResult = {
+  /** `true` when every added row committed - `open` is empty. */
+  ok: boolean;
   /** Temp ids that committed - parked as drafts, or added outright. */
   committed: Array<string>;
   /**
@@ -584,34 +529,109 @@ type TMDataGridAddRowsResult = {
    */
   open: Array<string>;
 };
+/**
+ * What `edit.commitAll` reports back. Every row that was open at the call is
+ * in exactly one list; ids are row ids, and temp ids for entry rows.
+ */
+type TMDataGridCommitAllResult = {
+  /** `true` when every open row committed - `open` is empty. */
+  ok: boolean;
+  /**
+   * Rows whose `commit` resolved `true` - into the draft store under
+   * `editing.draft`, out to the consumer without it, or closed with nothing
+   * to save.
+   */
+  committed: Array<string>;
+  /**
+   * Rows still open, carrying their errors: validation failed, or without
+   * `editing.draft` the consumer's `onCommit` / `onRowAdd` threw.
+   */
+  open: Array<string>;
+};
+/**
+ * What `edit.saveDrafts` reports back. Ids are row ids, and temp ids for new
+ * rows; edits, new rows and deletions are mixed in each list. Every id the
+ * save took from the draft store is in exactly one list. Rows open at the
+ * call are not part of the save and are in none.
+ */
+type TMDataGridSaveDraftsResult = {
+  /** `true` when nothing was kept or reopened. */
+  ok: boolean;
+  /** Left the draft store - the consumer accepted it. */
+  saved: Array<string>;
+  /**
+   * Still in the draft store, still committed, and sent again by the next
+   * save: an id `onSaveDrafts` reported as failed, every id it was sent
+   * when it threw, or, without `onSaveDrafts`, a deletion whose
+   * `onRowDelete` threw.
+   */
+  kept: Array<string>;
+  /**
+   * Out of the draft store and open again, carrying an error: a table rule
+   * now rejects the row, or, without `onSaveDrafts`, the row's own
+   * `onCommit` / `onRowAdd` threw.
+   */
+  reopened: Array<string>;
+};
+/** One row of {@link TMDataGridEditApi.getRows}. */
+type TMDataGridEditRowSnapshot<TData extends RowData = TMDataGridRowData> = {
+  /** The row's id - `addRow`'s temp id for an entry row. */
+  rowId: string;
+  /** The row as shown: its draft where a form holds one, else `data`'s value. */
+  value: TData;
+  /** An entry row, not yet in `data`. */
+  isNew: boolean;
+  /** Marked deleted, awaiting `saveDrafts`. */
+  deleted: boolean;
+};
 /**
  * The engine plus its store - `api.edit`.
  *
- * "One row, one form": `getForm` hands out the same `FormApi` the inline
- * editors write through, so a consumer can render it in a drawer or a detail
- * panel and share values, dirty state and errors with the cells.
+ * "One row, one form" while a row is open: `getForm` hands out the same
+ * `FormApi` the inline editors write through, so a consumer can render it in
+ * a drawer or a detail panel and share values, dirty state and errors with
+ * the cells. A committed row has no form - it is data in the draft store -
+ * so `getForm` returns `undefined` for it until `begin` reopens it.
  */
 type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
   /** The projection store - subscribe with `useSelector(edit.store, …)`. */
   store: Store<TMDataGridEditState>;
   /** Current snapshot, for reads outside React. */
   readonly state: TMDataGridEditState;
-  /** rowId → live form. The source of truth for everything mid-edit. */
+  /**
+   * rowId → the open row's live form, the source of truth for everything
+   * mid-edit. `undefined` for a row that is not open, a committed row
+   * included; `begin` reopens one.
+   */
   getForm: (rowId: string) => TMDataGridRowEditForm | undefined;
+  /**
+   * The row as shown: its draft values where the grid holds any - an open
+   * form's, or the committed values in the draft store - else what `data`
+   * says. `undefined` when no such row exists. A deletion mark does not
+   * change the answer; check `state.deletedRowIds` for that.
+   */
+  getRowValues: (rowId: string) => TData | undefined;
+  /**
+   * Every row as shown, nothing filtered out: data rows overlaid with their
+   * drafts, entry rows appended, deletion-marked rows included and flagged.
+   * Built from the core row model, so it is unfiltered, unsorted and never
+   * contains group rows. Filter on `deleted` / `isNew` for the set you want.
+   */
+  getRows: () => ReadonlyArray<TMDataGridEditRowSnapshot<TData>>;
   /**
    * Whether this cell may open an editor: the column maps to a field, nothing
    * switched it off, and the row takes edits at all.
    */
-  canEditCell: (row: ErasedRow, column: ErasedColumn) => boolean;
+  canEditCell: (row: ErasedRow$1, column: ErasedColumn$1) => boolean;
   /** Whether the row takes edits at all - the edit lane's pencil gate. */
-  canEditRow: (row: ErasedRow) => boolean;
+  canEditRow: (row: ErasedRow$1) => boolean;
   /**
    * Whether the column takes edits at all, with no row in hand: it maps to a
    * field, `editing.columns` lists it if that option is set, and
    * `meta.edit.enabled` is not `false`. A per-row `enabled` predicate is the
    * row's half of the question - `canEditCell` asks both.
    */
-  isColumnEditable: (column: ErasedColumn) => boolean;
+  isColumnEditable: (column: ErasedColumn$1) => boolean;
   /**
    * Opens an editor. In row mode the whole row opens either way and `columnId`
    * only says which cell takes the caret; `null` (the lane's pencil) leaves it
@@ -640,24 +660,33 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
    * Submits every open row, as if each had been OK'd: a row that validates
    * commits (into the draft store with `editing.draft` on, straight to the
    * consumer without it), a row that fails stays open with its errors.
-   * `true` when every row committed. Under `editing.draft` it sends nothing
-   * to the consumer by itself - that is `saveDrafts`.
+   * Under `editing.draft` it sends nothing to the consumer by itself - that
+   * is `saveDrafts`.
+   *
+   * Resolves which rows went which way: `committed` and `open` hold every
+   * row that was open at the call, each in exactly one list, and `ok` is
+   * `true` when `open` is empty. See {@link TMDataGridCommitAllResult}.
    */
-  commitAll: () => Promise<boolean>;
+  commitAll: () => Promise<TMDataGridCommitAllResult>;
   /**
    * Flushes the draft store: every committed edit, added row and deletion
    * mark reaches the consumer, through `onSaveDrafts` in one call when it is
    * set, or row by row through `onCommit` / `onRowAdd` / `onRowDelete`.
    *
    * Rows still open are left alone - they keep their form state and stay
-   * open. `true` when everything landed; a rejected save keeps every draft.
-   */
-  saveDrafts: () => Promise<boolean>;
-  /**
-   * @deprecated Split into {@link commitAll} and {@link saveDrafts}, which is
-   * exactly what this now does. Removed in a later beta.
-   */
-  submitAll: () => Promise<boolean>;
+   * open, and are in no list of the result.
+   *
+   * Resolves what happened to each id it sent: `saved` left the draft store,
+   * `kept` is still in it, committed, for the next save - an id
+   * `onSaveDrafts` reported as failed, every id when it threw, or a
+   * deletion whose per-row `onRowDelete` threw - and
+   * `reopened` is open again with an error, because a table rule now
+   * rejects it or its per-row `onCommit` / `onRowAdd` threw. `ok` is `true`
+   * when nothing was kept or reopened, and an empty store resolves `ok` with
+   * empty lists. A call while a save is in flight joins it and resolves the
+   * same result. See {@link TMDataGridSaveDraftsResult}.
+   */
+  saveDrafts: () => Promise<TMDataGridSaveDraftsResult>;
   /** Writes the type's empty value into a cell and commits it - Delete. */
   clearCell: (rowId: string, columnId: string) => Promise<boolean>;
   /**
@@ -695,24 +724,43 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
    */
   addRow: (values?: Partial<TData>) => string;
   /**
-   * Opens entry rows for a list of records at once - one state write for the
+   * Opens entry rows for a list of records at once - one publish for the
    * batch, where a loop over `addRow` is one per row. Each row is seeded over
    * `newRowDefaults` exactly as `addRow` does.
    *
-   * `commit: true` submits each row as it lands, which is what an import
-   * wants: rows that validate commit (parked in the draft store under
-   * `editing.draft`, added through `onRowAdd` without it - once per row),
-   * and rows that fail stay open in the entry block carrying their errors,
-   * for the user to fix. The result says which went which way.
+   * `commit: true` submits the rows too, which is what an import wants: rows
+   * that validate commit, and rows that fail stay open in the entry block
+   * carrying their errors, for the user to fix. The result says which went
+   * which way - `committed` and `open` hold every added row, each in exactly
+   * one list, and `ok` is `true` when `open` is empty. Under
+   * `editing.draft` the rows validate together and land in the draft store
+   * in the same publish as the add - the grid renders once,
+   * whatever the count. Without it each valid row goes out through
+   * `onRowAdd`, one at a time and in order.
    */
   addRows: (rows: ReadonlyArray<Partial<TData>>, options?: TMDataGridAddRowsOptions) => Promise<TMDataGridAddRowsResult>;
   /**
    * Deletes a row: `onRowDelete` straight away, or under `editing.draft` a
-   * toggle of the id in `deletedRowIds` - the row renders struck through
-   * until `saveDrafts` reports it. On an uncommitted entry row it just
-   * discards the entry.
+   * mark in `deletedRowIds` - the row renders struck through until
+   * `saveDrafts` reports it. Idempotent: deleting a marked row again leaves
+   * it marked, and {@link restoreRow} is the undo. On an entry row,
+   * committed or not, it just discards the entry; an id the grid does not
+   * know is a no-op.
    */
   deleteRow: (rowId: string) => void;
+  /**
+   * {@link deleteRow} for several rows in one call - one notification for
+   * the batch, for a bulk action over a selection. Because `deleteRow` is
+   * idempotent and ignores unknown ids, the list may be passed exactly as
+   * the selection stands - already-marked rows stay marked, duplicates and
+   * stale ids do nothing.
+   */
+  deleteRows: (rowIds: ReadonlyArray<string>) => void;
+  /**
+   * Removes a row's deletion mark - the lane's Restore. A no-op on a row
+   * that is not marked, and outside `editing.draft`, where no marks exist.
+   */
+  restoreRow: (rowId: string) => void;
   /** Whether delete chrome makes sense - the lane's trash gate. */
   canDeleteRows: () => boolean;
 };
@@ -735,13 +783,15 @@ declare function normalizeFieldValidate(validate: TMDataGridFieldValidate | unde
 type TMDataGridLabels = {
   /** Filter operator names, as shown in the operator dropdown and on pills. */
   operators: Record<TMDataGridFilterOperator, string>;
-  /** "Manage columns" - the burger button and the header menu item. */
-  manageColumns: string;
   /** "Filters" - the funnel button and the filter panel's title. */
   filters: string;
   searchPlaceholder: string;
   searchLabel: string;
   clearSearch: string;
+  /** Tooltip and `aria-label` of `TMDataGrid.Menu`'s burger trigger. */
+  menuButton: string;
+  /** "Manage columns" - the header menu's submenu. */
+  manageColumns: string;
   columnsSearchPlaceholder: string;
   columnsNoMatch: (search: string) => string;
   columnsShowHideAll: string;
@@ -772,6 +822,8 @@ type TMDataGridLabels = {
   clearAllFilters: string;
   closeFilters: string;
   removeFilter: string;
+  /** Names the operator button in a column's header filter control. */
+  filterOperatorFor: (column: string) => string;
   activeFilters: string;
   clearFilter: (column: string) => string;
   sortAsc: string;
@@ -797,6 +849,11 @@ type TMDataGridLabels = {
     to: number;
     total: number;
   }) => string;
+  /** `pageCount` is `-1` when a manual grid declares an unknown total. */
+  pageNumber: (args: {
+    page: number;
+    pageCount: number;
+  }) => string;
   groupedAllRows: (total: number) => string;
   pagingSuspendedHint: string;
   previousPage: string;
@@ -846,8 +903,22 @@ type TMDataGridLabels = {
   rowStateDeleted: string;
   cellCount: (count: number) => string;
   copy: string;
-  exportCsv: string;
+  exportCells: string;
   includeHeaders: string;
+  exportAll: string;
+  exportSelected: (count: number) => string;
+  /** Title of the column picker `columns="custom"` opens; `format` is the file extension in upper case, "CSV". */
+  exportPickerTitle: (format: string) => string;
+  /** The line under the title; `selected` is the selected row count, or `null` for an export of all rows. */
+  exportPickerHint: (selected: number | null) => string;
+  exportPickerConfirm: string;
+  exportPickerCancel: string;
+  /** The select-all row over the picker's list. */
+  exportPickerSelectAll: string;
+  /** The "3 of 12" count beside it. */
+  exportPickerCount: (checked: number, total: number) => string;
+  /** Marks a column the grid hides at the moment. */
+  exportPickerHidden: string;
   selectColumnLabel: string;
   selectAllRows: string;
   selectRow: string;
@@ -902,7 +973,30 @@ type TMDataGridFilterControlArgs = {
   options: ReadonlyArray<TMDataGridOption>;
   size: TMDataGridSize;
   labels: TMDataGridLabels;
+  /**
+   * How much room the control has, and whether it names itself. The same
+   * vocabulary as `TMDataGrid.FilterPanel`'s own `layout` prop, plus the one
+   * value only a header cell can be in.
+   *
+   * | Layout | Where | Field |
+   * | --- | --- | --- |
+   * | `"row"` | A filter row laid out side by side | Labelled, fixed width |
+   * | `"stacked"` | A filter row in a narrow host - the sidebar | Labelled, full width |
+   * | `"header"` | One header cell, under `filters.inHeader` | `aria-label`, full width |
+   *
+   * Every built-in control honours it. A custom control that ignores it still
+   * works - it will simply look the same everywhere.
+   */
+  layout: TMDataGridFilterControlLayout;
 };
+/** How much room a filter control has. See `layout`. */
+type TMDataGridFilterControlLayout = "row" | "stacked" | "header";
+/**
+ * The two a filter *panel* can be in - {@link TMDataGridFilterControlLayout}
+ * without the header cell, which is not a panel. `TMDataGrid.FilterPanel`'s
+ * `layout` prop.
+ */
+type TMDataGridFilterPanelLayout = Exclude<TMDataGridFilterControlLayout, "header">;
 /**
  * `meta.filter.control` - replaces the built-in value control for this column.
  * Rendered as JSX, never invoked as a bare function, so hooks are legal
@@ -923,10 +1017,19 @@ type TMDataGridFilterControlComponent = ComponentType<TMDataGridFilterControlArg
  * declaration of each feeds the filter panel and the cell editor alike.
  */
 type TMDataGridColumnFilterOptions = {
+  /**
+   * The operators this column offers, a subset of the type's own. For a
+   * column backed by an endpoint that answers only some of them - `contains`
+   * and `equals`, say - so the panel and the header funnel never offer an
+   * operator the query cannot express. Kept in the type's order; one the type
+   * does not offer is ignored, and a list that leaves nothing falls back to
+   * the type's full set.
+   */
+  operators?: readonly TMDataGridFilterOperator[];
   /**
    * The operator a fresh filter on this column starts with, instead of the
    * type's default - a salary column can open on `"between"`. Must be one of
-   * the type's own operators.
+   * the operators the column offers.
    */
   defaultOperator?: TMDataGridFilterOperator;
   /**
@@ -936,6 +1039,83 @@ type TMDataGridColumnFilterOptions = {
   control?: TMDataGridFilterControlComponent;
 };
 //#endregion
+//#region .types-tmp/core/filterSurface.d.ts
+/**
+ * Where the grid puts its filter controls.
+ *
+ * | Surface | Where it renders |
+ * | --- | --- |
+ * | `"popup"` | Floating over the first body rows, under the header |
+ * | `"sidebar"` | Beside the table, inside the grid frame |
+ * | `"none"` | Nowhere - the grid renders no panel of its own |
+ *
+ * Header filters are not one of these: they are a second row of controls in
+ * the header, always visible, and they coexist with any of the three. See
+ * {@link TMDataGridFiltersOptions.inHeader}.
+ */
+type TMDataGridFilterSurface = "popup" | "sidebar" | "none";
+/** Which side of the table the sidebar surface renders on. */
+type TMDataGridFilterSidebarSide = "left" | "right";
+/**
+ * `filters` on `useTMDataGrid` - everything about where the filter controls
+ * are, as opposed to what they do.
+ *
+ * Named for the option key, the way `editing` has `TMDataGridEditingOptions`.
+ * Not to be confused with `TMDataGridColumnFilterOptions`, which is one
+ * column's `meta.filter`.
+ *
+ * ```tsx
+ * useTMDataGrid({ data, columns, filters: { surface: "sidebar" } });
+ * ```
+ */
+type TMDataGridFiltersOptions = {
+  /**
+   * Which surface `TMDataGrid.Table` renders and `TMDataGrid.FilterButton`
+   * toggles. Defaults to `"popup"`.
+   *
+   * Under `"none"` the table renders no panel and the filter button renders
+   * nothing. That is what a grid running header filters alone wants, and it is
+   * also what frees a hand-placed `<TMDataGrid.FilterPanel />` to be the only
+   * panel on the page - mounted, it is always visible, so drive it off
+   * `ui.state.filterPanelOpen` if it belongs behind a control of your own.
+   */
+  surface?: TMDataGridFilterSurface;
+  /** Which side the `"sidebar"` surface sits on. Defaults to `"right"`. */
+  sidebarSide?: TMDataGridFilterSidebarSide;
+  /** Width of the `"sidebar"` surface, any CSS length. Defaults to `"280px"`. */
+  sidebarWidth?: string;
+  /**
+   * Whether the popup or the sidebar starts open. Read once, at mount, like
+   * `initialState`.
+   *
+   * Defaults to `true` under `"sidebar"` and `false` everywhere else: a
+   * sidebar is a layout choice, so asking for one and getting an empty strip
+   * until the funnel is clicked is not what it reads like, while a popup that
+   * greets you open is in the way.
+   *
+   * Under `"none"` it is simply the starting value of
+   * `ui.state.filterPanelOpen`, which a control of your own can read.
+   */
+  defaultOpen?: boolean;
+  /**
+   * A second header row holding one value control per filterable column,
+   * always visible. Off by default.
+   *
+   * Independent of `surface` - a grid may have header filters and a popup at
+   * once. What it does change is the column chrome: the header's funnel
+   * indicator and the column menu's "Filter" item both come off, because
+   * their only job was to reveal a control that is now already on screen.
+   *
+   * A header cell has room for a value and an operator button, not for the
+   * panel's column / operator / value triple. Everything else about a filter
+   * is unchanged - the same operators, the same `meta.filter.control`, the
+   * same `columnFilters` state.
+   */
+  inHeader?: boolean;
+};
+/** {@link TMDataGridFiltersOptions} with every default filled in. */
+type TMDataGridFiltersSettings = Required<TMDataGridFiltersOptions>;
+//#endregion
 //#region .types-tmp/core/quickSearch.d.ts
 /** How the quick search matches - see `quickSearchMode` on the hook options. */
 type TMDataGridQuickSearchMode = "fuzzy" | "contains";
@@ -1135,11 +1315,11 @@ type TMDataGridFeatureFlags = {
    */
   editDraft: boolean;
   /**
-   * Whether a parked entry row stays pinned in the sticky entry block until
-   * the draft store is saved - `editing.newRowsSticky`, which needs
-   * `editing.draft`. Off by default: a parked row joins the scrolling flow
-   * instead, so entering many rows cannot fill the viewport with sticky
-   * chrome.
+   * Whether a committed entry row stays pinned in the sticky entry block
+   * until the draft store is saved - `editing.newRowsSticky`, which needs
+   * `editing.draft`. Off by default: a committed row joins the body rows
+   * instead, sorted and filtered with them, so entering many rows cannot
+   * fill the viewport with sticky chrome.
    */
   editNewRowsSticky: boolean;
   /** The generated row-number gutter - `enableRowNumbers`. Off by default. */
@@ -1214,41 +1394,6 @@ type TMDataGridCellPosition = {
   rowId: string;
   columnId: string;
 };
-/** Where the focused cell sits in the rows and columns on screen. */
-type TMDataGridCellCoords = {
-  rowIndex: number;
-  columnIndex: number;
-};
-type ResolveCellMoveArgs = {
-  /** `KeyboardEvent.key`. */
-  key: string;
-  /** Ctrl or Cmd - Home and End jump to the corner rather than the row end. */
-  ctrlKey: boolean;
-  from: TMDataGridCellCoords;
-  rowCount: number;
-  columnCount: number;
-  /**
-   * How far PageUp and PageDown travel: one viewport of rows. Passed in rather
-   * than assumed, since only the body knows how tall it is.
-   */
-  pageRows: number;
-};
-/**
- * The next cell for a navigation key, or `null` when the key is not one.
- *
- * Moves clamp at the edges instead of wrapping. Wrapping suits a menu, where
- * the items are a short ring; a grid is a coordinate space, and a Right at the
- * last column that lands on the first column of the next row loses the one
- * thing arrow keys are for - knowing where you will end up without looking.
- *
- * A clamped move returns the position it started from rather than `null`. The
- * caller still needs to know the key was handled: an arrow at the last row must
- * not fall through to the scroll container, which would scroll the body out
- * from under a focus that did not move.
- */
-declare function resolveCellMove({ key, ctrlKey, from, rowCount, columnCount, pageRows }: ResolveCellMoveArgs): TMDataGridCellCoords | null;
-/** Whether two positions address the same cell. `null` equals only `null`. */
-declare function isSameCell(a: TMDataGridCellPosition | null, b: TMDataGridCellPosition | null): boolean;
 //#endregion
 //#region .types-tmp/core/cellRange.d.ts
 /**
@@ -1291,200 +1436,396 @@ type ResolveRangeBoundsArgs = {
  * is cleared.
  */
 declare function resolveRangeBounds({ range, rowIndexOf, columnIndexOf }: ResolveRangeBoundsArgs): TMDataGridRangeBounds | null;
-/** Whether a cell is inside the rectangle. */
-declare function isWithinBounds(bounds: TMDataGridRangeBounds | null, rowIndex: number, columnIndex: number): boolean;
-/** How many cells the rectangle covers. `0` for no range at all. */
-declare function boundsCellCount(bounds: TMDataGridRangeBounds | null): number;
-/**
- * Which edges of the rectangle a cell lies on, for the outline.
- *
- * The border is drawn per cell rather than as one box over the top, because the
- * body is a scrolling CSS grid with sticky columns in it: an overlay would have
- * to be positioned against a moving target and would still be wrong the moment
- * a pinned lane slid over it. Four booleans per cell need no positioning at all.
- */
-declare function boundsEdges(bounds: TMDataGridRangeBounds | null, rowIndex: number, columnIndex: number): {
-  top: boolean;
-  bottom: boolean;
-  left: boolean;
-  right: boolean;
-} | null;
 //#endregion
-//#region .types-tmp/useTMDataGrid.d.ts
+//#region .types-tmp/core/export.d.ts
+type ErasedRow = Row<TMDataGridFeatures, TMDataGridRowData>;
+type ErasedColumn = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
 /**
- * Per-column configuration the grid's own components read.
+ * What an export writes: the exported columns in render order, their labels,
+ * and one array of raw values per row.
  *
- * The filter and edit stages each get a namespace, `filter` and `edit`,
- * mirroring the feature's runtime API. What the column *is* stays flat:
- * `label`, `type`, `options`, `align`, `flex`, `autoSize`, `enableOrdering`.
- * `type` and `options` are read by both stages, so one declaration of each
- * feeds the filter panel and the cell editor, which is why they sit outside
- * both namespaces.
+ * Raw values rather than text, so a format decides how a number, a date or an
+ * array is written - JSON keeps a number a number, and a spreadsheet format
+ * can write a typed cell.
  */
-type TMDataGridColumnMeta = {
-  /** Name shown in menus and the column manager. Falls back to a string header. */
-  label?: string;
-  /**
-   * Drives which filter operators are offered and, once editing is on, which
-   * editor the cell opens. Defaults to `"string"`.
-   */
-  type?: TMDataGridColumnType;
-  /**
-   * The choices of a `select` / `multiSelect` column - one declaration feeding
-   * the filter panel's value control and the cell editor alike. A static
-   * array, `"faceted"` (the distinct values present in the data), or a
-   * function of the table, column and, for editors, the row. See
-   * {@link TMDataGridOptionsSource}.
-   */
-  options?: TMDataGridOptionsSource;
-  /** Share of the leftover width this column claims. Defaults to `1`. */
-  flex?: number;
-  align?: "left" | "right" | "center";
-  /**
-   * Size the column to its widest mounted content once, after the first rows
-   * render - unless a persisted or user-set width already covers it. The same
-   * measurement as double-clicking the resize divider; see `autosizeColumn`.
-   */
-  autoSize?: boolean;
-  /**
-   * `false` keeps the column where it is: no header dragging, no move items.
-   * Column ordering is the one feature TanStack defines no column option for,
-   * so its switch lives here rather than on the column definition.
-   */
-  enableOrdering?: boolean;
-  /**
-   * How this column filters: the operator a fresh filter starts with, and the
-   * value control the filter panel renders for it.
-   *
-   * ```tsx
-   * meta: {
-   *   type: "number",
-   *   filter: { defaultOperator: "between", control: DgRangeSliderFilter },
-   * }
-   * ```
-   *
-   * See {@link TMDataGridColumnFilterOptions}.
-   */
-  filter?: TMDataGridColumnFilterOptions;
-  /**
-   * How this column is edited: whether it takes edits, which field they write
-   * to, which editor opens, what validates the field and what maps the value
-   * on its way in.
-   *
-   * ```tsx
-   * meta: {
-   *   type: "string",
-   *   edit: { validate: z.string().min(2, "Too short") },
-   * }
-   * ```
-   *
-   * See {@link TMDataGridColumnEditOptions}.
-   */
-  edit?: TMDataGridColumnEditOptions;
+type TMDataGridExportData = {
+  columnIds: Array<string>;
+  /** `getColumnLabel` per column: `meta.label`, a string header, or the id. */
+  headers: Array<string>;
+  rows: Array<Array<unknown>>;
 };
-/** Grid-wide configuration passed through `options.meta`. */
-type TMDataGridTableMeta = {
-  loading?: boolean;
-  noResultsLabel?: string;
-  /** Row height used by the virtualizer. Defaults to `52`. */
-  rowHeight?: number;
+type TMDataGridExportWriteOptions = {
+  /** Whether the format writes the column labels as its first row. */
+  includeHeaders: boolean;
+};
+/**
+ * A file format an export can be written in.
+ *
+ * The grid ships `csvExcelFormat`, `csvFormat`, `tsvFormat` and `jsonFormat`;
+ * an addon package or your own code adds one by implementing this shape.
+ * `write` may be async and may answer a `Blob`, which is what a binary format
+ * such as xlsx needs.
+ */
+type TMDataGridExportFormat = {
+  /** Identifies the format, for a menu or a test. */
+  id: string;
+  /** File extension without the dot, appended to the file name. */
+  extension: string;
+  /** The `Blob` type the download is served under. */
+  mimeType: string;
   /**
-   * Unfiltered row total. Only needed for server-driven grids, where the client
-   * never holds the full data set - `TMDataGrid.SummaryCount` uses it as denominator.
+   * The decimal mark this format writes, when it writes text. Ctrl+C follows
+   * it, so what is copied matches what is exported. Unset means the Nordic
+   * default, a comma.
    */
-  totalRowCount?: number;
+  decimalComma?: boolean;
+  write: (data: TMDataGridExportData, options: TMDataGridExportWriteOptions) => string | Blob | Promise<string | Blob>;
 };
 /**
- * Every feature the TMDataGrid chrome can drive. Defined at module scope so the
- * reference stays stable across renders (see the TanStack table-state skill).
+ * Which columns an export takes: the visible ones, every exportable column
+ * hidden or not, or a list of column ids. The generated lanes and columns
+ * with `meta.enableExport: false` are never taken, whatever is asked for.
  */
-declare const tmDataGridFeatures: {
-  columnFilteringFeature: import("@tanstack/table-core").TableFeature;
-  globalFilteringFeature: import("@tanstack/table-core").TableFeature;
-  rowSortingFeature: import("@tanstack/table-core").TableFeature;
-  rowPaginationFeature: import("@tanstack/table-core").TableFeature;
-  rowSelectionFeature: import("@tanstack/table-core").TableFeature;
-  columnPinningFeature: import("@tanstack/table-core").TableFeature;
-  columnVisibilityFeature: import("@tanstack/table-core").TableFeature;
-  columnOrderingFeature: import("@tanstack/table-core").TableFeature;
-  columnSizingFeature: import("@tanstack/table-core").TableFeature;
-  columnResizingFeature: import("@tanstack/table-core").TableFeature;
-  columnFacetingFeature: import("@tanstack/table-core").TableFeature;
-  columnGroupingFeature: import("@tanstack/table-core").TableFeature;
-  rowExpandingFeature: import("@tanstack/table-core").TableFeature;
-  rowPinningFeature: import("@tanstack/table-core").TableFeature;
-  filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
-  groupedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
-  sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
-  expandedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
-  paginatedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
-  facetedRowModel: (table: Table<any, any>, columnId: string) => () => import("@tanstack/table-core").RowModel<any, any>;
-  facetedMinMaxValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => undefined | [number, number];
-  facetedUniqueValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => Map<any, number>;
-  filterFns: {
-    arrIncludes: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean;
-    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: [number, number]) => boolean) & {
-      resolveFilterValue: (val: [any, any]) => readonly [number, number];
-      autoRemove: (val: any) => boolean;
-    };
-    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    tmDataGrid: typeof tmDataGridFilterFn;
-    tmDataGridFuzzy: typeof fuzzyGlobalFilterFn;
-  };
-  sortFns: {
-    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-  };
-  aggregationFns: {
-    sum: typeof import("@tanstack/table-core").aggregationFn_sum;
-    min: typeof import("@tanstack/table-core").aggregationFn_min;
-    max: typeof import("@tanstack/table-core").aggregationFn_max;
-    extent: typeof import("@tanstack/table-core").aggregationFn_extent;
-    mean: typeof import("@tanstack/table-core").aggregationFn_mean;
-    median: typeof import("@tanstack/table-core").aggregationFn_median;
-    unique: typeof import("@tanstack/table-core").aggregationFn_unique;
-    uniqueCount: typeof import("@tanstack/table-core").aggregationFn_uniqueCount;
-    count: typeof import("@tanstack/table-core").aggregationFn_count;
-  };
-  tableMeta: TMDataGridTableMeta;
-  columnMeta: TMDataGridColumnMeta;
+type TMDataGridExportColumns = "visible" | "all" | ReadonlyArray<string>;
+/** How the grid exports: the format, the file name and whether headers go in. */
+type TMDataGridExportOptions = {
+  /** Defaults to `csvExcelFormat()`. */
+  format?: TMDataGridExportFormat;
+  /** Without extension. Defaults to `"export"`. */
+  fileName?: string;
+  /** Column labels as the first row. Defaults to `true`. */
+  includeHeaders?: boolean;
+  /** Defaults to `"visible"`. See {@link TMDataGridExportColumns}. */
+  columns?: TMDataGridExportColumns;
 };
-type TMDataGridFeatures = typeof tmDataGridFeatures;
-type TMDataGridTable<TData extends RowData> = Table<TMDataGridFeatures, TData>;
-declare function createTMDataGridColumnHelper<TData extends RowData>(): import("@tanstack/table-core").ColumnHelper<{
+/**
+ * What the column picker was opened for: which rows, and the options of the
+ * item that opened it. Held in `ui.state.exportPicker` while it is open.
+ */
+type TMDataGridExportPickerRequest = {
+  rows: "all" | "selected";
+  options: TMDataGridExportOptions;
+};
+/** `TMDataGridExportOptions` with every default filled in. */
+type TMDataGridExportSettings = Required<TMDataGridExportOptions>;
+/**
+ * The value written for a cell, in place of `row.getValue(column.id)`. See
+ * `meta.exportValue`.
+ */
+type TMDataGridExportValueGetter = (args: {
+  value: unknown;
+  row: ErasedRow;
+  column: ErasedColumn;
+}) => unknown;
+/**
+ * Which rows an export takes: every filtered and sorted row across all pages,
+ * the selected ones among those, or a list of your own.
+ */
+type TMDataGridExportRows<TData extends RowData> = "all" | "selected" | ReadonlyArray<Row<TMDataGridFeatures, TData>>;
+/**
+ * One value as text.
+ *
+ * Deliberately not the rendered cell: what a cell renders is React, and often a
+ * badge, a link or an icon rather than the value. The value is what a
+ * spreadsheet wants, and it is the one thing every column is guaranteed to
+ * have. `meta.exportValue` is where a column substitutes something else.
+ */
+declare function formatExportValue(value: unknown, { decimalComma }: {
+  decimalComma: boolean;
+}): string;
+/**
+ * Keeps a spreadsheet from running a cell as a formula.
+ *
+ * Excel and Sheets evaluate a cell that starts with `=`, `+`, `-` or `@`, so a
+ * value one user typed into the grid would run in another user's spreadsheet
+ * when the file is opened. The defence is the standard one: a leading
+ * apostrophe, which every spreadsheet reads as "text follows".
+ *
+ * Text that parses as a number is left alone - `-5` and `+4670123456` are
+ * numbers to the spreadsheet too, and an apostrophe would turn them into text.
+ * A phone number written with spaces (`+46 70 123 45 67`) does not parse and
+ * is prefixed; `escapeFormulas: false` on the format is the way out for a grid
+ * whose data is trusted.
+ */
+declare function guardFormula(text: string): string;
+type TMDataGridCsvFormatOptions = {
+  /** Between fields. `csvExcelFormat` defaults to `";"`, `csvFormat` to `","`. */
+  separator?: string;
+  /** Write numbers as `1,5` rather than `1.5`. `csvExcelFormat` defaults to `true`, `csvFormat` to `false`. */
+  decimalComma?: boolean;
+  /** Prefix text that a spreadsheet would run as a formula. Defaults to `true`. See {@link guardFormula}. */
+  escapeFormulas?: boolean;
+};
+/**
+ * A CSV that opens straight into columns in Excel.
+ *
+ * Three things make that true, and all three are needed:
+ *
+ * | Part | Why |
+ * | ---- | --- |
+ * | `sep=;` first line | Excel's own directive - it stops guessing and uses this |
+ * | UTF-8 BOM | without it Excel reads the file as ANSI, and å ä ö arrive broken |
+ * | CRLF line endings | what Excel writes, and what its importer is happiest with |
+ *
+ * The defaults are the Nordic ones, because they are the ones that need
+ * choosing: an Excel running a Swedish, Norwegian, Danish or Finnish locale
+ * reads `;` as its list separator and `,` as its decimal mark, and a file
+ * written the other way opens as one column of text.
+ *
+ * The `sep=` line is Excel's alone; Sheets and Numbers show it as a first row.
+ * `csvFormat` is the one for them.
+ */
+declare function csvExcelFormat({ separator, decimalComma, escapeFormulas }?: TMDataGridCsvFormatOptions): TMDataGridExportFormat;
+/**
+ * Plain CSV as RFC 4180 has it: commas, a dot as the decimal mark, CRLF, and a
+ * UTF-8 BOM so that Excel too reads it as UTF-8. No `sep=` line, so Google
+ * Sheets, Numbers and every tool that reads CSV take it as is.
+ */
+declare function csvFormat({ separator, decimalComma, escapeFormulas }?: TMDataGridCsvFormatOptions): TMDataGridExportFormat;
+type TMDataGridTsvFormatOptions = Omit<TMDataGridCsvFormatOptions, "separator">;
+/**
+ * Tab-separated text, the clipboard shape as a file: tabs between fields, CRLF
+ * between rows, a UTF-8 BOM. Every spreadsheet opens it into columns without
+ * a separator to guess.
+ */
+declare function tsvFormat({ decimalComma, escapeFormulas }?: TMDataGridTsvFormatOptions): TMDataGridExportFormat;
+type TMDataGridJsonFormatOptions = {
+  /** Indentation passed to `JSON.stringify`. Defaults to `2`. */
+  space?: number;
+};
+/**
+ * An array with one object per row, keyed by the column labels, values as the
+ * data holds them. Two columns with the same label collapse into one key, the
+ * later column winning. `includeHeaders` has no meaning here and is ignored.
+ */
+declare function jsonFormat({ space }?: TMDataGridJsonFormatOptions): TMDataGridExportFormat;
+declare const DEFAULT_EXPORT_OPTIONS: TMDataGridExportSettings;
+/**
+ * The defaults with each override folded over them in turn. Field by field,
+ * so an override that spells a field as `undefined` leaves the earlier value
+ * rather than blanking it.
+ */
+declare function resolveExportOptions(...overrides: Array<TMDataGridExportOptions | undefined>): TMDataGridExportSettings;
+/**
+ * Every column an export could take, in render order: the data columns minus
+ * the generated lanes and `meta.enableExport: false`, hidden ones included.
+ * What the column picker lists; `column.getIsVisible()` says which of them a
+ * `"visible"` export would take.
+ */
+declare function getExportableColumns<TData extends RowData>(table: TMDataGridTable<TData>): Array<Column<TMDataGridFeatures, TData, unknown>>;
+/**
+ * How many rows `rows: "selected"` would export: the ticked rows of the
+ * current view. Not the size of the selection map, which keeps rows the
+ * filters have since hidden. Free while nothing is selected.
+ */
+declare function countSelectedExportRows<TData extends RowData>(table: TMDataGridTable<TData>): number;
+type BuildExportDataArgs<TData extends RowData> = {
+  table: TMDataGridTable<TData>;
+  /** Defaults to `"all"`. */
+  rows?: TMDataGridExportRows<TData>;
+  /** Defaults to `"visible"`. Ignored under `bounds`. */
+  columns?: TMDataGridExportColumns;
+  /**
+   * A rectangle over `rows` and the visible columns, both by index - the
+   * cell-range path. `rows` is then the list the indices refer to, usually
+   * the displayed rows.
+   */
+  bounds?: TMDataGridRangeBounds;
+};
+/**
+ * What an export writes, before any format touches it.
+ *
+ * Columns are `"visible"` (the data columns on screen, in render order),
+ * `"all"` (every exportable column, hidden or not) or a list of ids; the
+ * generated lanes and any column with `meta.enableExport: false` are left out
+ * whichever is asked for. Rows are `"all"` (every filtered and sorted row
+ * across every page, group rows flattened to their records), `"selected"`
+ * (those of them the user has ticked, in the same order - the selection map
+ * is walked through the row list rather than the other way round, because
+ * TanStack's selected row models ignore filtering and sorting), or a list of
+ * your own.
+ */
+declare function buildExportData<TData extends RowData>({ table, rows, columns: which, bounds }: BuildExportDataArgs<TData>): TMDataGridExportData;
+/**
+ * Writes `data` in the format and downloads it. Awaits the format, since a
+ * binary format builds its file asynchronously.
+ */
+declare function writeExportFile(data: TMDataGridExportData, { format, fileName, includeHeaders }: TMDataGridExportSettings): Promise<void>;
+type ExportGridArgs<TData extends RowData> = {
+  table: TMDataGridTable<TData>;
+  /** Defaults to `"all"`. See {@link TMDataGridExportRows}. */
+  rows?: TMDataGridExportRows<TData>;
+  /** Merged over `DEFAULT_EXPORT_OPTIONS`. */
+  options?: TMDataGridExportOptions;
+};
+/**
+ * Downloads the grid as a file: {@link buildExportData} through the format's
+ * `write` and a download.
+ *
+ * Inside the grid, `useTMDataGridExport` and the `TMDataGrid.Menu.Export*`
+ * items call this with the grid's own `exportOptions`; this is the entry point
+ * for code that holds the table and nothing else.
+ *
+ * Nothing is downloaded when no column is exportable. A grid with no rows
+ * still downloads its header row, since an empty file is the honest answer to
+ * an empty view.
+ *
+ * Async because a format may be. Safari refuses a download that starts after
+ * the click gesture has ended, which a format that takes long enough to build
+ * can run into; the text formats resolve synchronously and never do.
+ */
+declare function exportGrid<TData extends RowData>({ table, rows, options }: ExportGridArgs<TData>): Promise<void>;
+type TMDataGridClipboardTextOptions = {
+  /** Defaults to `true`, the Nordic mark. */
+  decimalComma?: boolean;
+  /** Defaults to `true`. See {@link guardFormula}. */
+  escapeFormulas?: boolean;
+};
+/**
+ * The clipboard format spreadsheets read: tab between cells, CRLF between rows,
+ * values only.
+ *
+ * Tabs rather than commas because that is what Excel, Sheets and Numbers all
+ * put on the clipboard themselves - paste it and the cells land in cells. A
+ * comma-separated string pastes into a single column, which is the thing this
+ * exists to avoid. No header row: Excel's own copy carries none either, and a
+ * header pasted into the middle of a sheet is a row of text where numbers
+ * were expected.
+ *
+ * Also accepts an already-formatted string matrix, written as is.
+ */
+declare function toClipboardText(data: TMDataGridExportData | Array<Array<string>>, { decimalComma, escapeFormulas }?: TMDataGridClipboardTextOptions): string;
+/**
+ * Puts text on the clipboard, reporting whether it landed.
+ *
+ * The async clipboard API only resolves for a document that has the focus and a
+ * user gesture behind it - both true when this runs off Ctrl+C or a menu item.
+ * It is still allowed to reject (a permissions policy, a page that lost focus
+ * mid-copy), so the result is a boolean the caller can act on.
+ */
+declare function writeClipboardText(text: string): Promise<boolean>;
+/**
+ * Downloads a file, through the one mechanism a library can use: an anchor
+ * with an object URL behind it, clicked. Revoked on the next frame -
+ * immediately would race the browser's own read of it.
+ */
+declare function downloadFile({ fileName, content, mimeType }: {
+  fileName: string;
+  content: string | Blob;
+  mimeType: string;
+}): void;
+//#endregion
+//#region .types-tmp/useTMDataGrid.d.ts
+/**
+ * Per-column configuration the grid's own components read.
+ *
+ * The filter and edit stages each get a namespace, `filter` and `edit`,
+ * mirroring the feature's runtime API. What the column *is* stays flat:
+ * `label`, `type`, `options`, `align`, `flex`, `autoSize`, `enableOrdering`.
+ * `type` and `options` are read by both stages, so one declaration of each
+ * feeds the filter panel and the cell editor, which is why they sit outside
+ * both namespaces.
+ *
+ * `TData` types the row that `options` and `edit.enabled` callbacks receive.
+ * `createTMDataGridColumnHelper<TData>()` fills it in.
+ */
+type TMDataGridColumnMeta<TData extends RowData = TMDataGridRowData> = {
+  /** Name shown in menus and the column manager. Falls back to a string header. */
+  label?: string;
+  /**
+   * Drives which filter operators are offered and, once editing is on, which
+   * editor the cell opens. Defaults to `"string"`.
+   */
+  type?: TMDataGridColumnType;
+  /**
+   * The choices of a `select` / `multiSelect` column - one declaration feeding
+   * the filter panel's value control and the cell editor alike. A static
+   * array, `"faceted"` (the distinct values present in the data), or a
+   * function of the table, column and, for editors, the row. See
+   * {@link TMDataGridOptionsSource}.
+   */
+  options?: TMDataGridOptionsSource<TData>;
+  /** Share of the leftover width this column claims. Defaults to `1`. */
+  flex?: number;
+  align?: "left" | "right" | "center";
+  /**
+   * Size the column to its widest mounted content once, after the first rows
+   * render - unless a persisted or user-set width already covers it. The same
+   * measurement as double-clicking the resize divider; see `autosizeColumn`.
+   */
+  autoSize?: boolean;
+  /**
+   * `false` keeps the column where it is: no header dragging, no move items.
+   * Column ordering is the one feature TanStack defines no column option for,
+   * so its switch lives here rather than on the column definition.
+   */
+  enableOrdering?: boolean;
+  /**
+   * How this column filters: which operators it offers, the operator a fresh
+   * filter starts with, and the value control the filter panel renders for it.
+   *
+   * ```tsx
+   * meta: {
+   *   type: "number",
+   *   filter: { defaultOperator: "between", control: DgRangeSliderFilter },
+   * }
+   * ```
+   *
+   * See {@link TMDataGridColumnFilterOptions}.
+   */
+  filter?: TMDataGridColumnFilterOptions;
+  /**
+   * How this column is edited: whether it takes edits, which field they write
+   * to, which editor opens, what validates the field and what maps the value
+   * on its way in.
+   *
+   * ```tsx
+   * meta: {
+   *   type: "string",
+   *   edit: { validate: z.string().min(2, "Too short") },
+   * }
+   * ```
+   *
+   * See {@link TMDataGridColumnEditOptions}.
+   */
+  edit?: TMDataGridColumnEditOptions<TData>;
+  /**
+   * `false` leaves the column out of every export and out of Ctrl+C - for a
+   * column of buttons, or one whose value means nothing outside the grid.
+   * Defaults to `true`.
+   */
+  enableExport?: boolean;
+  /**
+   * The value an export writes for this column, in place of
+   * `row.getValue(column.id)`. The export otherwise writes the value, never
+   * what the cell renders, so this is where a status code becomes its label
+   * or a nested object becomes one field.
+   *
+   * ```tsx
+   * meta: {
+   *   exportValue: ({ value }) => STATUS_LABELS[value as Status],
+   * }
+   * ```
+   */
+  exportValue?: TMDataGridExportValueGetter;
+};
+/** Grid-wide configuration passed through `options.meta`. */
+type TMDataGridTableMeta = {
+  loading?: boolean;
+  noResultsLabel?: string;
+  /** Row height used by the virtualizer. Defaults to `52`. */
+  rowHeight?: number;
+  /**
+   * Unfiltered row total. Only needed for server-driven grids, where the client
+   * never holds the full data set - `TMDataGrid.SummaryCount` uses it as denominator.
+   */
+  totalRowCount?: number;
+};
+/**
+ * Every feature the TMDataGrid chrome can drive. Defined at module scope so the
+ * reference stays stable across renders (see the TanStack table-state skill).
+ */
+declare const tmDataGridFeatures: {
   columnFilteringFeature: import("@tanstack/table-core").TableFeature;
   globalFilteringFeature: import("@tanstack/table-core").TableFeature;
   rowSortingFeature: import("@tanstack/table-core").TableFeature;
@@ -1497,6 +1838,7 @@ declare function createTMDataGridColumnHelper<TData extends RowData>(): import("
   columnResizingFeature: import("@tanstack/table-core").TableFeature;
   columnFacetingFeature: import("@tanstack/table-core").TableFeature;
   columnGroupingFeature: import("@tanstack/table-core").TableFeature;
+  rowAggregationFeature: import("@tanstack/table-core").TableFeature;
   rowExpandingFeature: import("@tanstack/table-core").TableFeature;
   rowPinningFeature: import("@tanstack/table-core").TableFeature;
   filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
@@ -1508,66 +1850,69 @@ declare function createTMDataGridColumnHelper<TData extends RowData>(): import("
   facetedMinMaxValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => undefined | [number, number];
   facetedUniqueValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => Map<any, number>;
   filterFns: {
-    arrIncludes: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean;
-    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: [number, number]) => boolean) & {
-      resolveFilterValue: (val: [any, any]) => readonly [number, number];
-      autoRemove: (val: any) => boolean;
-    };
-    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
+    arrIncludes: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrIncludesAll: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrHas: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrIncludesSome: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    between: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    betweenInclusive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    empty: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    endsWith: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equals: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equalsString: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equalsStringSensitive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    inDateRange: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    inNumberRange: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    includesString: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    includesStringSensitive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    notEmpty: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    startsWith: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    weakEquals: import("@tanstack/table-core").CreatedFilterFn<any, any>;
     tmDataGrid: typeof tmDataGridFilterFn;
     tmDataGridFuzzy: typeof fuzzyGlobalFilterFn;
   };
   sortFns: {
-    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => number;
-    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => number;
-    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
+    alphanumeric: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    basic: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    text: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/table-core").CreatedSortFn<any, any>;
   };
   aggregationFns: {
-    sum: typeof import("@tanstack/table-core").aggregationFn_sum;
-    min: typeof import("@tanstack/table-core").aggregationFn_min;
-    max: typeof import("@tanstack/table-core").aggregationFn_max;
-    extent: typeof import("@tanstack/table-core").aggregationFn_extent;
-    mean: typeof import("@tanstack/table-core").aggregationFn_mean;
-    median: typeof import("@tanstack/table-core").aggregationFn_median;
-    unique: typeof import("@tanstack/table-core").aggregationFn_unique;
-    uniqueCount: typeof import("@tanstack/table-core").aggregationFn_uniqueCount;
-    count: typeof import("@tanstack/table-core").aggregationFn_count;
+    sum: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    min: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    max: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    extent: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, [(number | Date) | undefined, (number | Date) | undefined]>;
+    mean: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+    median: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+    unique: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown[]>;
+    uniqueCount: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    count: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    first: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown>;
+    last: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown>;
   };
   tableMeta: TMDataGridTableMeta;
-  columnMeta: TMDataGridColumnMeta;
-}, TData>;
+  columnMeta: TMDataGridColumnMeta<TMDataGridRowData>;
+};
+type TMDataGridFeatures = typeof tmDataGridFeatures;
+type TMDataGridTable<TData extends RowData> = Table<TMDataGridFeatures, TData>;
+/** A column definition with `meta` typed against the row type. */
+type WithRowTypedMeta<TDef, TData extends RowData> = TDef extends unknown ? Omit<TDef, "meta"> & {
+  meta?: TMDataGridColumnMeta<TData>;
+} : never;
+/**
+ * TanStack's column helper with `meta` typed against `TData`, so the
+ * `meta.options` and `meta.edit.enabled` callbacks receive
+ * `Row<TMDataGridFeatures, TData>`.
+ */
+type TMDataGridColumnHelper<TData extends RowData> = {
+  accessor: <TAccessor extends AccessorFn<TData> | DeepKeys<TData>, TValue extends TAccessor extends AccessorFn<TData, infer TReturn> ? TReturn : TAccessor extends DeepKeys<TData> ? DeepValue<TData, TAccessor> : never>(accessor: TAccessor, column: WithRowTypedMeta<TAccessor extends AccessorFn<TData> ? DisplayColumnDef<TMDataGridFeatures, TData, TValue> : IdentifiedColumnDef<TMDataGridFeatures, TData, TValue>, TData>) => TAccessor extends AccessorFn<TData> ? AccessorFnColumnDef<TMDataGridFeatures, TData, TValue> : AccessorKeyColumnDef<TMDataGridFeatures, TData, TValue>;
+  columns: ColumnHelper<TMDataGridFeatures, TData>["columns"];
+  display: (column: WithRowTypedMeta<DisplayColumnDef<TMDataGridFeatures, TData>, TData>) => DisplayColumnDef<TMDataGridFeatures, TData, unknown>;
+  group: (column: WithRowTypedMeta<GroupColumnDef<TMDataGridFeatures, TData, unknown>, TData>) => GroupColumnDef<TMDataGridFeatures, TData, unknown>;
+};
+declare function createTMDataGridColumnHelper<TData extends RowData>(): TMDataGridColumnHelper<TData>;
 /** What the `renderDetails` render prop is handed for an expanded row. */
 type TMDataGridDetailsArgs<TData extends RowData> = {
   row: Row<TMDataGridFeatures, TData>;
@@ -1582,9 +1927,20 @@ type TMDataGridDetailsRenderer<TData extends RowData> = (args: TMDataGridDetails
  */
 type TMDataGridUiState = {
   filterPanelOpen: boolean;
-  columnsPanelOpen: boolean;
-  /** Column whose filter row should be focused when the panel opens. */
+  /**
+   * Column whose *panel* row should take the focus. Cleared once the row has
+   * taken it, so pointing at the same column twice focuses twice.
+   */
   filterPanelColumnId: string | null;
+  /**
+   * Column whose *header filter* control should take the focus, under
+   * `filters.inHeader`. Cleared once taken, like the one above.
+   *
+   * Its own slot rather than a second reader of `filterPanelColumnId`: a grid
+   * can have header filters and a panel at once, and two controls racing to
+   * answer one id means whichever mounted last wins the caret.
+   */
+  headerFilterColumnId: string | null;
   /**
    * Column being dragged by its header, if any. Held here rather than read from
    * `dataTransfer`, which browsers keep unreadable until the drop.
@@ -1623,12 +1979,32 @@ type TMDataGridUiState = {
    * describe different places.
    */
   cellRange: TMDataGridCellRange | null;
+  /**
+   * The export column picker, while it is open: which rows it exports and the
+   * options of the item that opened it. `null` while closed. Held here rather
+   * than in the menu item, which unmounts with the dropdown the moment it is
+   * clicked.
+   */
+  exportPicker: TMDataGridExportPickerRequest | null;
 };
 type TMDataGridUiActions = {
   openFilterPanel: (columnId?: string | null) => void;
   closeFilterPanel: () => void;
-  setColumnsPanelOpen: (open: boolean) => void;
-  toggleColumnsPanel: () => void;
+  /** Opens the export column picker for `request`. See `TMDataGrid.Menu.Export`'s `columns="custom"`. */
+  openExportPicker: (request: TMDataGridExportPickerRequest) => void;
+  closeExportPicker: () => void;
+  /**
+   * Points at a column's row in the filter panel without opening anything.
+   * `openFilterPanel` does this as well as opening; this is the half a panel
+   * that is already showing needs.
+   */
+  focusPanelFilter: (columnId: string | null) => void;
+  /**
+   * Points at a column's header filter control - what `openColumnFilter` does
+   * under `filters.inHeader`, where there is no panel to open. The header row
+   * scrolls the column into view and focuses it.
+   */
+  focusHeaderFilter: (columnId: string | null) => void;
   startColumnDrag: (columnId: string) => void;
   endColumnDrag: () => void;
   /**
@@ -1668,13 +2044,28 @@ type TMDataGridApi<TData extends RowData> = {
   ui: TMDataGridUiStore;
   /**
    * The edit engine - open forms, dirty/error projections, and the verbs
-   * (`begin`, `commit`, `cancel`, `submitAll`). `edit.getForm(rowId)` hands
-   * out the same TanStack Form the inline editors write through, so a drawer
-   * or detail panel can share a row's draft. Inert until `editing` is set.
+   * (`begin`, `commit`, `cancel`, `saveDrafts`). `edit.getForm(rowId)` hands
+   * out the same TanStack Form the inline editors write through while a row
+   * is open, so a drawer or detail panel can share a row's draft; a
+   * committed row has no form until `begin` reopens it. Inert until
+   * `editing` is set.
    */
   edit: TMDataGridEditApi<TData>;
   /** Table-level feature switches, re-read from options on every render. */
   features: TMDataGridFeatureFlags;
+  /**
+   * Where the filter controls live, the `filters` option with its defaults
+   * filled in. On the api rather than in a component's props because the
+   * pills, the column menu and `openColumnFilter` all have to agree with the
+   * table about which surface is on.
+   */
+  filters: TMDataGridFiltersSettings;
+  /**
+   * How the grid exports, the `exportOptions` option with its defaults filled
+   * in. Read by `useTMDataGridExport`, the `TMDataGrid.Menu.Export*` items and
+   * the cell-range menu, so every export of the grid agrees on the format.
+   */
+  exportOptions: TMDataGridExportSettings;
   /** Every string the chrome renders, `labels` merged over the English defaults. */
   labels: TMDataGridLabels;
   /** The detail renderer, when row details are on. See `renderDetails`. */
@@ -1859,21 +2250,16 @@ type TMDataGridEditingOptions<TData extends RowData> = TMDataGridEditingCallback
    *
    * Rows still open are not in the payload and stay open. Returning
    * nothing saves the whole store and throwing saves none of it;
-   * return a {@link TMDataGridSaveDraftsResult} to save part of it.
+   * return a {@link TMDataGridSaveDraftsResponse} to save part of it.
    */
-  onSaveDrafts?: (args: TMDataGridSaveDraftsArgs<TData>) => void | TMDataGridSaveDraftsResult | Promise<void | TMDataGridSaveDraftsResult>;
+  onSaveDrafts?: (args: TMDataGridSaveDraftsArgs<TData>) => void | TMDataGridSaveDraftsResponse | Promise<void | TMDataGridSaveDraftsResponse>;
   /**
-   * @deprecated Renamed to {@link onSaveDrafts} - it fires when the
-   * draft store is saved, not when a row commits into it. Still
-   * honoured; removed in a later beta.
-   */
-  onCommitDrafts?: (args: TMDataGridSaveDraftsArgs<TData>) => void | TMDataGridSaveDraftsResult | Promise<void | TMDataGridSaveDraftsResult>;
-  /**
-   * Keep parked entry rows pinned in the sticky entry block until
-   * the draft store is saved. Off by default: a parked row joins the
-   * scrolling flow above the body rows instead - the block a row is
-   * *typed* into is always sticky, but parked rows scroll, so
-   * entering many cannot fill the viewport with sticky chrome.
+   * Keep committed entry rows pinned in the sticky entry block until
+   * the draft store is saved, out of the body's sort. Off by default:
+   * a committed row joins the body rows instead, sorted and filtered
+   * with them - the block a row is *typed* into is always sticky, but
+   * committed rows scroll, so entering many cannot fill the viewport
+   * with sticky chrome.
    */
   newRowsSticky?: boolean;
 } | {
@@ -1881,8 +2267,6 @@ type TMDataGridEditingOptions<TData extends RowData> = TMDataGridEditingCallback
   draft?: false;
   /** Only `draft: true` has a store to save - see the other branch. */
   onSaveDrafts?: never;
-  /** @deprecated See {@link onSaveDrafts}. */
-  onCommitDrafts?: never;
   /** Parked entry rows exist only under `draft: true` - see there. */
   newRowsSticky?: never;
 });
@@ -1939,12 +2323,55 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
    * no extra flag.
    */
   enablePagination?: boolean;
+  /**
+   * Sends the grid back to the first page whenever the query changes - a
+   * column filter, the quick search, the sort or the grouping. On by
+   * default. TanStack's own `autoResetPageIndex` is switched off by the
+   * grid: it fires on any change to the `data` array, which under
+   * `editing.draft` is every commit.
+   *
+   * Server-side, `pageIndex` is a position in a result set the grid does not
+   * own: narrowing the query leaves it pointing past the last page, and the
+   * next request comes back empty. The reset is applied in the same event as
+   * the change, so one request goes out, for the first page of the new query.
+   */
+  resetPageOnQueryChange?: boolean;
   /**
    * The row-number gutter: a generated lane, outermost left, numbering the
    * rows of the current view - sorted, filtered, continuing across pages,
    * with group rows unnumbered. Off by default.
    */
   enableRowNumbers?: boolean;
+  /**
+   * Where the grid puts its filter controls - a popup over the rows, a sidebar
+   * beside them, controls in the header row, or nowhere at all so you place
+   * `TMDataGrid.FilterPanel` yourself.
+   *
+   * ```tsx
+   * useTMDataGrid({ data, columns, filters: { surface: "sidebar", inHeader: true } });
+   * ```
+   *
+   * Defaults to `{ surface: "popup" }` - the floating panel the grid has
+   * always shown. See {@link TMDataGridFiltersOptions}.
+   *
+   * Read field by field, so a literal is fine here - unlike `labels` or
+   * `persist`, this one does not have to be referentially stable.
+   */
+  filters?: TMDataGridFiltersOptions;
+  /**
+   * How the grid exports: the file format, the file name and whether the
+   * column labels go in as the first row. Defaults to `csvExcelFormat()`,
+   * `"export"` and `true`. See {@link TMDataGridExportOptions}.
+   *
+   * ```tsx
+   * useTMDataGrid({ data, columns, exportOptions: { format: csvFormat(), fileName: "employees" } });
+   * ```
+   *
+   * Read field by field like `filters`, so a literal is fine. A `format`
+   * built inline is rebuilt every render, which costs nothing but a small
+   * object; keep it at module scope when that bothers you.
+   */
+  exportOptions?: TMDataGridExportOptions;
   /**
    * How the quick search (`TMDataGrid.Search`) matches. `"fuzzy"` - the
    * default - forgives typos and skipped characters, and while it is the
@@ -2133,22 +2560,273 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
   overscan?: number;
 };
 /**
- * Builds a TMDataGrid table plus its chrome store.
- *
- * Every `TableOptions` field passes straight through, so a server-driven grid
- * only needs `manualPagination` / `manualFiltering` / `manualSorting`,
- * `rowCount` and the matching `onXChange` callbacks - the chrome reads
- * `getRowCount()` / `getPageCount()` / `getPaginatedRowModel()`, all of which
- * already respect manual mode. `manualPagination` also switches the pagination
- * flag on, so `<TMDataGrid.Footer />` renders its pager without further
- * options.
+ * Builds a TMDataGrid table plus its chrome store.
+ *
+ * Every `TableOptions` field passes straight through, so a server-driven grid
+ * only needs `manualPagination` / `manualFiltering` / `manualSorting`,
+ * `rowCount` and the matching `onXChange` callbacks - the chrome reads
+ * `getRowCount()` / `getPageCount()` / `getPaginatedRowModel()`, all of which
+ * already respect manual mode. `manualPagination` also switches the pagination
+ * flag on, so `<TMDataGrid.Footer />` renders its pager without further
+ * options.
+ */
+declare function useTMDataGrid<TData extends RowData>({ persist, labels: labelsOverride, enableColumnOrdering, enablePagination, resetPageOnQueryChange, enableRowNumbers, selectionMode, showSelectedBackground, defaultHighlightedRowId, onHighlightedRowChange, cellSelection, onFocusedCellChange, filters: filterOptions, exportOptions: exportOptionsOverride, editing, renderDetails, renderDetailsEstHeight, overscan, ...options }: UseTMDataGridOptions<TData>): TMDataGridApi<TData>;
+/**
+ * Sends the user to a column's filter control, seeding an empty filter when
+ * the column has none yet - what "Filter" in the column menu and a click on a
+ * filter pill both do.
+ *
+ * Which control that is follows the grid's `filters` option. Under
+ * `inHeader` it is the column's header control, which is already on screen, so
+ * the call focuses it and leaves the popup or sidebar closed. Otherwise it is
+ * the panel's row for that column, and the call opens the surface on it.
+ */
+declare function openColumnFilter<TData extends RowData>(api: TMDataGridApi<TData>, columnId: string): void;
+//#endregion
+//#region .types-tmp/core/filterOperators.d.ts
+/**
+ * The value shape stored in `columnFilters` for every TMDataGrid column.
+ *
+ * TanStack resolves `filterFn` statically per column, so the operator travels
+ * inside the filter *value* instead. That keeps the filter model plain,
+ * serialisable JSON, so a server-side `manualFiltering` table can forward
+ * `columnFilters` to the API unchanged.
+ *
+ * `value` is a string array under `isAnyOf` / `isNoneOf` (the set the cell is
+ * tested against), a `[min, max]` pair under `between` (an empty string means
+ * that end is open), and a single string everywhere else - dates travel as
+ * ISO `YYYY-MM-DD` strings, booleans as `"true"` / `"false"`. Still plain
+ * JSON.
+ */
+type TMDataGridFilterValue = {
+  operator: TMDataGridFilterOperator;
+  value: string | ReadonlyArray<string>;
+};
+type TMDataGridColumnType = "string" | "number" | "boolean" | "date" | "select" | "multiSelect";
+type TMDataGridFilterOperator = "contains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "between" | "before" | "after" | "onOrBefore" | "onOrAfter" | "isAnyOf" | "isNoneOf" | "isEmpty" | "isNotEmpty";
+declare const FILTER_OPERATOR_LABELS: Record<TMDataGridFilterOperator, string>;
+declare function getOperatorsForType(type: TMDataGridColumnType): readonly TMDataGridFilterOperator[];
+declare function operatorNeedsValue(operator: TMDataGridFilterOperator): boolean;
+/** Whether the operator's value is a string array - `isAnyOf` / `isNoneOf`. */
+declare function operatorTakesArrayValue(operator: TMDataGridFilterOperator): boolean;
+/** Whether the operator's value is a `[min, max]` pair - `between`. */
+declare function operatorTakesRangeValue(operator: TMDataGridFilterOperator): boolean;
+/** The untouched value a fresh filter starts with - the operator's shape, empty. */
+declare function emptyValueForOperator(operator: TMDataGridFilterOperator): string | ReadonlyArray<string>;
+/**
+ * The three value shapes an operator can take. A set is not a range, even
+ * though both are arrays.
+ */
+type TMDataGridFilterValueShape = "scalar" | "set" | "range";
+/**
+ * Which shape an operator's value takes. A typed value survives an operator or
+ * column change only within its shape, which is the rule both the panel and
+ * the header controls use when the operator changes.
+ */
+declare function filterValueShape(operator: TMDataGridFilterOperator): TMDataGridFilterValueShape;
+/**
+ * A filter only narrows the row set once it has something to compare against.
+ * Half-typed filters stay in state (so the panel keeps rendering their row) but
+ * are treated as inactive for the funnel indicator and for row matching.
+ */
+declare function isFilterActive(value: unknown): boolean;
+/** One column's filter, typed - what `columnFilters` holds per entry. */
+type TMDataGridColumnFilter = {
+  id: string;
+  value: TMDataGridFilterValue;
+};
+/**
+ * The column filters that are actually narrowing the grid, typed.
+ *
+ * `ColumnFiltersState` types `value` as `unknown`, so the first line of a
+ * server-side mapping layer is otherwise a cast back to the shape the grid
+ * itself wrote, wrapped in the same "drop the half-typed ones" filter every
+ * consumer writes:
+ *
+ * ```ts
+ * const predicates = activeColumnFilters(table).map((filter) =>
+ *   toPredicate(filter.id, filter.value),
+ * );
+ * ```
+ *
+ * Takes the table, or a `columnFilters` array where the consumer owns the
+ * slice. Reading it from the table reads the current value and does not
+ * subscribe; inside a component, subscribe to `columnFilters` the way the
+ * grid's own chrome does.
+ */
+declare function activeColumnFilters<TData extends RowData>(source: TMDataGridTable<TData> | ColumnFiltersState): Array<TMDataGridColumnFilter>;
+/**
+ * One-line description of a single filter, as shown on a filter pill.
+ *
+ * The type's default operator is left implicit - "First name: Sofia" reads the
+ * way a person would say it - while any other operator is spelled out, since
+ * that is the part a reader cannot guess.
+ */
+declare function formatFilterLabel({ label, type, filter, operatorLabels }: {
+  label: string;
+  type: TMDataGridColumnType;
+  filter: TMDataGridFilterValue;
+  /** Localized operator names - `labels.operators`. Defaults to English. */
+  operatorLabels?: Record<TMDataGridFilterOperator, string>;
+}): string;
+/**
+ * The single filter function every TMDataGrid column uses. It dispatches on the
+ * operator carried by the filter value, which is what lets one column offer
+ * "contains" / "does not equal" / "is empty" without redefining the column.
+ */
+declare function tmDataGridFilterFn<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown): boolean;
+//#endregion
+//#region .types-tmp/core/columnUtils.d.ts
+/**
+ * Structural shape of the column bits the chrome reads. Kept minimal so these
+ * helpers work with any `Column`/`Header` instance without dragging generics
+ * through every call site.
+ */
+type ColumnLike = {
+  id: string;
+  columnDef: {
+    header?: unknown;
+    meta?: TMDataGridColumnMeta;
+  };
+  /** Set on a leaf that sits inside a header group. */
+  parent?: unknown;
+};
+/** Menu- and panel-facing column name. */
+declare function getColumnLabel(column: ColumnLike): string;
+declare function getColumnType(column: ColumnLike): TMDataGridColumnType;
+/**
+ * The operators this column offers: the type's list, narrowed to
+ * `meta.filter.operators` when the column declares one. The type's order is
+ * kept so the menu reads the same on every column; an operator the type does
+ * not offer is dropped, and an allowlist that leaves nothing falls back to the
+ * type's full list rather than an empty menu.
+ */
+declare function getColumnOperators(column: ColumnLike): readonly TMDataGridFilterOperator[];
+/**
+ * The operator a fresh filter on this column starts with -
+ * `meta.filter.defaultOperator`, else the type's default where the column
+ * offers it, else the first operator it does offer.
+ */
+declare function getColumnDefaultOperator(column: ColumnLike): TMDataGridFilterOperator;
+/**
+ * A generated lane holding one fixed-width thing - the checkbox, the details
+ * chevron, the row number.
+ *
+ * They are laid out differently from every other column: cell padding is sized
+ * for text and grows with the scale, which at `xl` squeezed a 16px checkbox out
+ * of its track, so these lanes centre their content in an unpadded cell.
+ * Their headers carry no column menu, and none of them is ever exported -
+ * they hold chrome, not values.
+ *
+ * The tree column is deliberately not one of them: it holds a label as well as a
+ * chevron, and wants the padding.
+ */
+declare function isControlColumn(columnId: string): boolean;
+/**
+ * Whether the grid generated this column rather than the consumer declaring it
+ * - the four control lanes plus the tree column.
+ *
+ * These hold the grid's own chrome, and they keep the edges of the row: the
+ * generated left lanes before every consumer column, the edit lane after all of
+ * them. `isControlColumn` answers a narrower question about layout, and leaves
+ * the tree column out because it is padded like a data column.
+ */
+declare function isGeneratedColumn(columnId: string): boolean;
+/** `"auto"` shows the search box from `COLUMN_SEARCH_MIN` columns. */
+type TMDataGridColumnSearchable = boolean | "auto";
+//#endregion
+//#region .types-tmp/components/TMDataGridMenu.d.ts
+type TMDataGridMenuProps = Omit<MenuProps, "children"> & {
+  /** The dropdown's content: Mantine `Menu.Item`s and the `TMDataGrid.Menu.*` items. */
+  children: ReactNode;
+  /** Replaces the burger icon on the trigger. */
+  icon?: ReactNode;
+  /** Tooltip and `aria-label` of the trigger. Default `labels.menuButton`. */
+  label?: string;
+};
+type TMDataGridMenuColumnsProps = {
+  /**
+   * Renders a `Menu.Search` above the toggles: `"auto"` (the default) from
+   * six hideable columns, `true` always, `false` never. Use `false` inside a
+   * `Menu.Sub`.
+   */
+  searchable?: TMDataGridColumnSearchable;
+};
+/**
+ * The whole column chooser as menu items: a search box, one checkbox item per
+ * hideable column, show/hide all, and Reset layout. Renders nothing when no
+ * column can be hidden.
+ *
+ * `searchable` is only for a block at the top level of a dropdown.
+ * `Menu.Search` registers on the root menu context (`hasSearch`), which
+ * switches off type-ahead and the arrow-key handling of every dropdown of that
+ * menu, so a search inside a `Menu.Sub` breaks the parent menu's keyboard
+ * behaviour.
+ */
+declare function TMDataGridMenuColumns({ searchable }: TMDataGridMenuColumnsProps): import("react").JSX.Element | null;
+/**
+ * One checkbox item per hideable column, narrowed to `search` when one is
+ * given. Renders nothing when no column can be hidden.
+ */
+declare function TMDataGridMenuColumnToggles({ search }: {
+  search?: string;
+}): import("react").JSX.Element | null;
+/**
+ * Shows or hides every listed column at once. Renders nothing when no column
+ * can be hidden.
+ */
+declare function TMDataGridMenuShowHideAll(): import("react").JSX.Element | null;
+/**
+ * Resets the whole layout, not only visibility: order, widths, pinning and
+ * grouping go back too. Not `table.resetColumnVisibility()`, which resets to
+ * `initialState` - and under persistence the mount built that *from* the
+ * persisted payload.
+ */
+declare function TMDataGridMenuResetLayout(): import("react").JSX.Element;
+/** Per-item overrides of the grid's `exportOptions`, and the item's text. */
+type TMDataGridMenuExportProps = Omit<TMDataGridExportOptions, "columns"> & {
+  /**
+   * Which columns the item writes: `"visible"`, `"all"`, a list of ids, or
+   * `"custom"` - a picker listing every exportable column with the visible
+   * ones ticked, and the download on its Export button. Defaults to the grid's
+   * `exportOptions.columns`.
+   */
+  columns?: TMDataGridExportColumns | "custom";
+  /**
+   * The item's text. Defaults to `labels.exportAll`, or for the selected-rows
+   * item `labels.exportSelected(count)`. Two items offering two formats need
+   * two texts, which is what this is for.
+   */
+  label?: ReactNode;
+};
+/**
+ * Downloads every filtered and sorted row, all pages, in the grid's export
+ * format. Props override `exportOptions` for this item alone, which is how one
+ * menu offers two formats.
+ */
+declare function TMDataGridMenuExport(props: TMDataGridMenuExportProps): import("react").JSX.Element;
+/**
+ * Downloads the selected rows, in grid order. Disabled while nothing is
+ * selected; renders nothing when row selection is off, since then there is
+ * never anything for it to do.
  */
-declare function useTMDataGrid<TData extends RowData>({ persist, labels: labelsOverride, enableColumnOrdering, enablePagination, enableRowNumbers, selectionMode, showSelectedBackground, defaultHighlightedRowId, onHighlightedRowChange, cellSelection, onFocusedCellChange, editing, renderDetails, renderDetailsEstHeight, overscan, ...options }: UseTMDataGridOptions<TData>): TMDataGridApi<TData>;
+declare function TMDataGridMenuExportSelected(props: TMDataGridMenuExportProps): import("react").JSX.Element | null;
+//#endregion
+//#region .types-tmp/components/TMDataGridColumnsPanel.d.ts
 /**
- * Opens the filter panel for a column, seeding an empty filter row when the
- * column has none yet - mirrors "Filter" in the column header menu.
+ * The "Manage columns" surface as plain controls, for a host that is not a
+ * menu - a Popover, a Drawer, an inline layout. `TMDataGrid.Menu.Columns` is
+ * the same chooser as menu items.
  */
-declare function openColumnFilter<TData extends RowData>(api: TMDataGridApi<TData>, columnId: string): void;
+/** Mantine's style props (`w={320}`, `p="sm"`) are set on the panel block. */
+type TMDataGridColumnsPanelProps = BoxProps & {
+  /**
+   * The search box over the list: `"auto"` (the default) from six hideable
+   * columns, `true` always, `false` never.
+   */
+  searchable?: TMDataGridColumnSearchable;
+};
+declare function TMDataGridColumnsPanel({ className, searchable, ...others }?: TMDataGridColumnsPanelProps): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/TMDataGridDraftActions.d.ts
 /** What the edit chrome is showing. */
@@ -2174,20 +2852,25 @@ type TMDataGridDraftActionsState = {
    * in display order, so it need not be `openRowIds[0]`.
    */
   openRowIds: ReadonlyArray<string>;
-  /**
-   * @deprecated Was "everything uncommitted", which Save no longer sends.
-   * Reads as `draftCount + openCount`; use whichever you meant.
-   */
-  pendingCount: number;
-  /** Whether a submit is in flight. */
+  /** Whether a submit is in flight - any open row is submitting. */
   isSubmitting: boolean;
+  /** `true` while `saveDrafts` is in flight. */
+  isSaving: boolean;
 };
 /** What the edit chrome can do. */
 type TMDataGridDraftActionsActions = {
-  /** Saves the draft store. Open rows are left alone. */
-  save: () => Promise<boolean>;
-  /** Submits every open row, committing the ones that validate. */
-  commitAll: () => Promise<boolean>;
+  /**
+   * Saves the draft store - `edit.saveDrafts()`. Open rows are left alone.
+   * Resolves which ids were saved, kept in the draft store for the next
+   * save, or reopened with an error; see {@link TMDataGridSaveDraftsResult}.
+   */
+  save: () => Promise<TMDataGridSaveDraftsResult>;
+  /**
+   * Submits every open row, committing the ones that validate -
+   * `edit.commitAll()`. Resolves which rows committed and which are still
+   * open; see {@link TMDataGridCommitAllResult}.
+   */
+  commitAll: () => Promise<TMDataGridCommitAllResult>;
   /** Drops everything - open form state and the draft store alike. */
   discard: () => void;
   /**
@@ -2266,16 +2949,40 @@ type TMDataGridDraftActionsProps = {
 declare function TMDataGridDraftActions({ renderActions }?: TMDataGridDraftActionsProps): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
 //#endregion
 //#region .types-tmp/components/TMDataGridFilterPanel.d.ts
+/** Mantine's style props (`p="md"`, `w={320}`) are set on the panel block. */
+type TMDataGridFilterPanelProps = BoxProps & {
+  /**
+   * How one filter row is laid out.
+   *
+   * `"row"` - the default - puts column, operator and value side by side,
+   * which wants about 550px. `"stacked"` puts them one under the other, each
+   * filling the width, for a host too narrow for that: the sidebar surface
+   * uses it, and so should a panel you place in a drawer or a narrow column.
+   *
+   * Passed through to every value control as its `layout`, so a
+   * `meta.filter.control` can size itself to the same decision.
+   */
+  layout?: TMDataGridFilterPanelLayout;
+};
 /**
  * The MUI-style filter surface: one row per active column filter, each row a
- * column / operator / value triple. It only ever reads and writes the table's
- * `columnFilters` state, so a `manualFiltering` grid gets the same panel for
- * free - the state is forwarded to the server instead of a row model.
+ * column / operator / value triple, over an "Add filter" / "Clear all" footer.
+ *
+ * A plain block of controls, the way `TMDataGrid.ColumnsPanel` is - it renders
+ * whenever it is mounted and knows nothing about floating. The chrome that
+ * makes a floating surface (a title, a close button, click-away, Escape)
+ * belongs to the popup and the sidebar, so this can equally be dropped into a
+ * drawer, a page column or a form. See the `filters.surface` option.
+ *
+ * It only ever reads and writes the table's `columnFilters` state, so a
+ * `manualFiltering` grid gets the same panel for free - the state is forwarded
+ * to the server instead of a row model.
  */
-declare function TMDataGridFilterPanel(): import("react").JSX.Element | null;
+declare function TMDataGridFilterPanel({ layout, className, ...others }?: TMDataGridFilterPanelProps): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/TMDataGridFilterPills.d.ts
-type TMDataGridFilterPillsProps<TData extends RowData> = {
+/** Mantine's style props (`mb="sm"`, `hiddenFrom="sm"`) are set on the wrapper. */
+type TMDataGridFilterPillsProps<TData extends RowData> = BoxProps & {
   /** The object returned by `useTMDataGrid`. */
   api: TMDataGridApi<TData>;
   /** Mantine size of the pills. Defaults to `"sm"`. */
@@ -2287,7 +2994,6 @@ type TMDataGridFilterPillsProps<TData extends RowData> = {
    * filter panel on that column.
    */
   onPillClick?: (columnId: string) => void;
-  className?: string;
 };
 /**
  * One pill per active filter (`First name: Sofia ✕`), with the ✕ clearing that
@@ -2309,9 +3015,9 @@ type TMDataGridFilterPillsProps<TData extends RowData> = {
  * Half-typed filters are left out: a filter that is not narrowing the rows yet
  * has nothing to report, which is the same rule the funnel indicator uses.
  */
-declare function TMDataGridFilterPills<TData extends RowData>({ api, size, showClearAll, onPillClick, className }: TMDataGridFilterPillsProps<TData>): import("react").JSX.Element | null;
+declare function TMDataGridFilterPills<TData extends RowData>({ api, size, showClearAll, onPillClick, className, ...others }: TMDataGridFilterPillsProps<TData>): import("react").JSX.Element | null;
 //#endregion
-//#region .types-tmp/components/TMDataGridFooter.d.ts
+//#region .types-tmp/core/pagination.d.ts
 /** What the pager is showing. The read half of {@link TMDataGridPaginationApi}. */
 type TMDataGridPaginationState = {
   pageIndex: number;
@@ -2351,6 +3057,17 @@ type TMDataGridPaginationApi = {
   state: TMDataGridPaginationState;
   actions: TMDataGridPaginationActions;
 };
+/**
+ * Reads {@link TMDataGridPaginationApi} off a table. The Footer feeds it to the
+ * `renderPagination` slot; a pager living outside the Footer can call it with
+ * the table from `useTMDataGrid` directly.
+ *
+ * `Controls` are not here: they are components bound to the grid context, and
+ * this function takes only a table.
+ */
+declare function getTMDataGridPaginationApi<TData extends RowData>(table: TMDataGridTable<TData>, isPaging?: boolean): TMDataGridPaginationApi;
+//#endregion
+//#region .types-tmp/components/TMDataGridFooter.d.ts
 /**
  * The pre-bound pieces of the built-in pager.
  *
@@ -2363,6 +3080,12 @@ type TMDataGridPaginationControls = {
   PageSize: () => ReactNode;
   /** The "1–25 of 300" range label. */
   Range: () => ReactNode;
+  /**
+   * The "Page 3 of 200" label - what a server-paged grid usually shows in
+   * place of a row range. Not in the default footer; put it in a
+   * `renderPagination` layout.
+   */
+  PageNumber: () => ReactNode;
   /** The previous/next buttons. */
   Pager: () => ReactNode;
 };
@@ -2370,16 +3093,8 @@ type TMDataGridPaginationControls = {
 type TMDataGridPaginationSlotArgs = TMDataGridPaginationApi & {
   Controls: TMDataGridPaginationControls;
 };
-/**
- * Reads {@link TMDataGridPaginationApi} off a table. The Footer feeds it to the
- * `renderPagination` slot; a pager living outside the Footer can call it with
- * the table from `useTMDataGrid` directly.
- *
- * `Controls` are not here: they are components bound to the grid context, and
- * this function takes only a table.
- */
-declare function getTMDataGridPaginationApi<TData extends RowData>(table: TMDataGridTable<TData>, isPaging?: boolean): TMDataGridPaginationApi;
-type TMDataGridFooterProps = {
+/** Mantine's style props (`mt="sm"`, `px="md"`) are set on the footer bar. */
+type TMDataGridFooterProps = BoxProps & {
   pageSizeOptions?: ReadonlyArray<number>;
   /**
    * Replaces the built-in pager, and is handed the pieces of it.
@@ -2389,7 +3104,7 @@ type TMDataGridFooterProps = {
    *   renderPagination={({ state, actions, Controls }) => (
    *     <Group>
    *       <Controls.PageSize />
-   *       <MyJumpToPage page={state.pageIndex} onJump={actions.setPageIndex} />
+   *       <Controls.PageNumber />
    *       <Controls.Pager />
    *     </Group>
    *   )}
@@ -2408,7 +3123,7 @@ type TMDataGridFooterProps = {
  * Row totals come from `table.getRowCount()`, which prefers `options.rowCount`
  * - so a server-paged grid shows the server's total without changes here.
  */
-declare function TMDataGridFooter({ pageSizeOptions, renderPagination }: TMDataGridFooterProps): import("react").JSX.Element | null;
+declare function TMDataGridFooter({ pageSizeOptions, renderPagination, className, ...others }: TMDataGridFooterProps): import("react").JSX.Element | null;
 //#endregion
 //#region .types-tmp/components/TMDataGridSearch.d.ts
 type TMDataGridSearchProps = {
@@ -2467,173 +3182,7 @@ type TMDataGridColumnMenuItemsArgs = {
  */
 type TMDataGridColumnMenuItemsRenderer = (args: TMDataGridColumnMenuItemsArgs) => Array<ReactNode>;
 //#endregion
-//#region .types-tmp/core/cellExport.d.ts
-/** The selected block, flattened to text. One inner array per row. */
-type TMDataGridCellMatrix = Array<Array<string>>;
-/**
- * How values are written out.
- *
- * The defaults are the Nordic ones, because they are the ones that need
- * choosing: an Excel running a Swedish, Norwegian, Danish or Finnish locale
- * reads `;` as its list separator and `,` as its decimal mark, and a file
- * written the other way opens as one column of text. Both are settable for a
- * grid whose users run something else.
- */
-type TMDataGridCellExportOptions = {
-  /** CSV field separator. Defaults to `";"`. */
-  separator?: string;
-  /** Write numbers as `1,5` rather than `1.5`. Defaults to `true`. */
-  decimalComma?: boolean;
-  /** Column labels as the first row. Defaults to `true`. */
-  includeHeaders?: boolean;
-  /** Without extension. Defaults to `"export"`. */
-  fileName?: string;
-};
-type ResolvedExportOptions = Required<TMDataGridCellExportOptions>;
-declare const DEFAULT_CELL_EXPORT_OPTIONS: ResolvedExportOptions;
-/**
- * One value as text.
- *
- * Deliberately not the rendered cell: what a cell renders is React, and often a
- * badge, a link or an icon rather than the value. The value is what a
- * spreadsheet wants, and it is the one thing every column is guaranteed to
- * have.
- */
-declare function formatExportValue(value: unknown, { decimalComma }: {
-  decimalComma: boolean;
-}): string;
-type BuildCellMatrixArgs = {
-  rows: ReadonlyArray<Row<TMDataGridFeatures, TMDataGridRowData>>;
-  /** Every visible column, in render order - the same list the bounds index into. */
-  columns: ReadonlyArray<Column<TMDataGridFeatures, TMDataGridRowData, unknown>>;
-  bounds: TMDataGridRangeBounds;
-  includeHeaders: boolean;
-  decimalComma: boolean;
-};
-/**
- * The selected rectangle as rows of text.
- *
- * The generated lanes - the checkbox, the tree chevron, the details chevron -
- * are dropped even when the rectangle covers them. They hold controls rather
- * than data, so a column of empty strings is all they could contribute, and
- * pasting one into a spreadsheet only shifts everything to its right.
- */
-declare function buildCellMatrix({ rows, columns, bounds, includeHeaders, decimalComma }: BuildCellMatrixArgs): TMDataGridCellMatrix;
-/**
- * The whole grid as rows of text: every filtered and sorted data row - all
- * pages, not the one on screen - by every visible non-control column, in
- * render order.
- *
- * The values are the same ones a cell-range export writes; only the bounds
- * differ. Group rows are left out (their records are the rows themselves),
- * and hidden columns are not exported - what you see is what you get, minus
- * paging.
- */
-declare function buildGridCellMatrix<TData extends RowData>({ table, includeHeaders, decimalComma }: {
-  table: TMDataGridTable<TData>;
-  includeHeaders?: boolean;
-  decimalComma?: boolean;
-}): TMDataGridCellMatrix;
-/**
- * Downloads the whole grid as a CSV for Excel - {@link buildGridCellMatrix}
- * through {@link toExcelCsv}, with the same Nordic defaults and overrides as
- * the cell-range export.
- *
- * No built-in button: wire it to your own toolbar.
- *
- * ```tsx
- * <Button onClick={() => exportGridToCsv({ table: grid.table })}>Export</Button>
- * ```
- */
-declare function exportGridToCsv<TData extends RowData>({ table, options }: {
-  table: TMDataGridTable<TData>;
-  options?: TMDataGridCellExportOptions;
-}): void;
-/**
- * The clipboard format spreadsheets read: tab between cells, CRLF between rows.
- *
- * Tabs rather than commas because that is what Excel, Sheets and Numbers all
- * put on the clipboard themselves - paste it and the cells land in cells. A
- * comma-separated string pastes into a single column, which is the thing this
- * exists to avoid.
- */
-declare function toClipboardText(matrix: TMDataGridCellMatrix): string;
-/**
- * A CSV that opens straight into columns in Excel.
- *
- * Three things make that true, and all three are needed:
- *
- * | Part | Why |
- * | ---- | --- |
- * | `sep=;` first line | Excel's own directive - it stops guessing and uses this |
- * | UTF-8 BOM | without it Excel reads the file as ANSI, and å ä ö arrive broken |
- * | CRLF line endings | what Excel writes, and what its importer is happiest with |
- *
- * The `sep=` line is Excel's alone; other readers show it as a first row. This
- * export targets Excel, so opening correctly there takes priority over strict
- * CSV.
- */
-declare function toExcelCsv(matrix: TMDataGridCellMatrix, { separator }: {
-  separator: string;
-}): string;
-/**
- * Puts text on the clipboard, reporting whether it landed.
- *
- * The async clipboard API only resolves for a document that has the focus and a
- * user gesture behind it - both true when this runs off Ctrl+C or a menu item.
- * It is still allowed to reject (a permissions policy, a page that lost focus
- * mid-copy), so the result is a boolean the caller can act on.
- */
-declare function writeClipboardText(text: string): Promise<boolean>;
-/**
- * Downloads text as a file, through the one mechanism a library can use: an
- * anchor with an object URL behind it, clicked. Revoked on the next frame -
- * immediately would race the browser's own read of it.
- */
-declare function downloadTextFile({ fileName, text, mimeType }: {
-  fileName: string;
-  text: string;
-  mimeType?: string;
-}): void;
-//#endregion
 //#region .types-tmp/components/TMDataGridTable.d.ts
-/** Where a column sits relative to the pinned regions, resolved once per render. */
-type TMDataGridColumnLayout = {
-  pinnedAt: "left" | "right" | false;
-  /** Distance in px from the grid's left or right edge. */
-  offset: number;
-  /** Last left-pinned / first right-pinned column - the one that casts the edge. */
-  isBoundary: boolean;
-};
-/**
- * What a cell needs to take part in cell selection, or `undefined` while the
- * feature is off - which is what keeps a plain grid's cells exactly as they
- * were: no tab stop, no `gridcell` role, no coordinates in the DOM.
- *
- * The coordinates are there for the delegated key handler, which reads them off
- * `event.target` rather than closing over per-cell state, and for the effect
- * that puts DOM focus where {@link TMDataGridUiState.focusedCell} says.
- */
-type TMDataGridCellNav = {
-  rowId: string;
-  /** 1-based, for `aria-colindex`. */
-  columnIndex: number;
-  focused: boolean;
-  /** The roving tab stop: `0` on exactly one mounted cell, `-1` on the rest. */
-  tabIndex: 0 | -1;
-  /** Inside the selected rectangle. Always `false` under `"single"`. */
-  selected: boolean;
-  /**
-   * Which sides of the rectangle this cell is on, or `null` when it is not in
-   * one. The outline is drawn per cell - see {@link boundsEdges}.
-   */
-  edges: {
-    top: boolean;
-    bottom: boolean;
-    left: boolean;
-    right: boolean;
-  } | null;
-};
 /** What `renderRowContextMenu` is handed for the right-clicked row. */
 type TMDataGridRowContextMenuArgs<TData extends RowData> = {
   table: Table<TMDataGridFeatures, TData>;
@@ -2803,12 +3352,6 @@ type TMDataGridTableProps<TData extends RowData> = {
    * `position`, `transitionProps` and the rest. Its open state is the grid's.
    */
   rowContextMenuProps?: Omit<MenuProps, "opened" | "onChange" | "children">;
-  /**
-   * How Ctrl+C and the export item write values, under
-   * `cellSelection: "range"`. Defaults to the Nordic Excel conventions - see
-   * {@link TMDataGridCellExportOptions}.
-   */
-  cellExport?: TMDataGridCellExportOptions;
   /**
    * Called when the scroll approaches the last row - the infinite-scroll
    * hook-in. Append the next page to `data` and the virtualizer keeps its
@@ -2843,15 +3386,25 @@ type TMDataGridTableProps<TData extends RowData> = {
  * no-pagination mode work at any row count. Pagination is opt in through
  * `enablePagination`, or implied by `manualPagination`.
  */
-declare function TMDataGridTable$1<TData extends RowData = TMDataGridRowData>({ onRowClick, onCellClick, onCellDoubleClick, onCellContextMenu, rowClassName, rowStyle, striped, onScrollToTop, onScrollToBottom, onScrollToLeft, onScrollToRight, renderEmptyState, renderRowContextMenu, renderColumnMenuItems, rowContextMenuProps, cellExport, onReachEnd, reachEndThreshold, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy }: TMDataGridTableProps<TData>): import("react").JSX.Element;
+declare function TMDataGridTable$1<TData extends RowData = TMDataGridRowData>({ onRowClick, onCellClick, onCellDoubleClick, onCellContextMenu, rowClassName, rowStyle, striped, onScrollToTop, onScrollToBottom, onScrollToLeft, onScrollToRight, renderEmptyState, renderRowContextMenu, renderColumnMenuItems, rowContextMenuProps, onReachEnd, reachEndThreshold, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy }: TMDataGridTableProps<TData>): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/TMDataGridToolbar.d.ts
-/** Row above the grid. Compose it from the pieces below, or anything else. */
-declare function TMDataGridToolbar({ children }: {
+type TMDataGridToolbarProps = BoxProps & {
   children?: ReactNode;
-}): import("react").JSX.Element;
-/** Pushes the following toolbar items to the right. */
-declare function TMDataGridToolbarSpacer(): import("react").JSX.Element;
+  /**
+   * Draws a 1px line under the toolbar in the theme's default border colour -
+   * the same line the header draws under itself. Defaults to `false`.
+   */
+  withBottomBorder?: boolean;
+};
+/**
+ * Row above the grid. Compose it from the pieces below, or anything else.
+ * Takes Mantine's style props (`mb="sm"`, `px="md"`, `hiddenFrom="sm"`) and
+ * sets them on the row.
+ */
+declare function TMDataGridToolbar({ children, withBottomBorder, className, mod, ...others }: TMDataGridToolbarProps): import("react").JSX.Element;
+/** Pushes the following toolbar items to the right. Takes Mantine's style props. */
+declare function TMDataGridToolbarSpacer({ className, ...others }: BoxProps): import("react").JSX.Element;
 /**
  * A small spinner shown while `meta.loading` is true, and nothing otherwise.
  *
@@ -2873,18 +3426,22 @@ declare function TMDataGridLoadingIndicator(): import("react").JSX.Element | nul
 /**
  * Visible rows over total rows. On a server-driven grid, set
  * `meta.totalRowCount` for the denominator - the client never sees every row.
+ * Without it the count is rendered alone, since the fallback denominator would
+ * be the rows the server sent for the current page: a plausible-looking wrong
+ * total, and on an unfiltered first page the same number twice.
  */
 declare function TMDataGridSummaryCount({ children }: {
   children?: ReactNode;
 }): import("react").JSX.Element;
 /**
- * Burger menu in the grid's top-right corner - opens "Manage columns".
- * Renders nothing when no column can be hidden (`enableHiding: false`).
- */
-declare function TMDataGridColumnsButton(): import("react").JSX.Element | null;
-/**
- * Toggles the filter panel, seeding a filter row on the first filterable column.
- * Renders nothing when no column can be filtered (`enableColumnFilters: false`).
+ * Toggles the grid's filter surface - the popup or the sidebar, whichever
+ * `filters.surface` names - seeding a filter row on the first filterable
+ * column. The count of active filters tints it.
+ *
+ * Renders nothing when no column can be filtered (`enableColumnFilters:
+ * false`), and nothing under `filters.surface: "none"`, where there is no
+ * automatic surface for it to toggle. Read `ui.state.filterPanelOpen` and
+ * render your own control if a hand-placed panel wants one.
  */
 declare function TMDataGridFilterButton(): import("react").JSX.Element | null;
 //#endregion
@@ -2918,6 +3475,7 @@ type TMDataGridProps<TData extends RowData> = TMDataGridApi<TData> & {
    */
   "data-testid"?: string;
 };
+declare function TMDataGridRoot<TData extends RowData>({ table, ui, edit, features, filters, exportOptions, labels, renderDetails, renderDetailsEstHeight, overscan, resetSettings, scrollToRow, scrollerRef, size, children, className, style, id, "data-testid": testId }: TMDataGridProps<TData>): import("react").JSX.Element;
 /**
  * Root of the grid. Takes the object returned by `useTMDataGrid` - spread it -
  * and publishes it to the compound components below it:
@@ -2929,14 +3487,15 @@ type TMDataGridProps<TData extends RowData> = TMDataGridApi<TData> & {
  *   <TMDataGrid.Toolbar>
  *     <TMDataGrid.SummaryCount />
  *     <TMDataGrid.Spacer />
- *     <TMDataGrid.ColumnsButton />
+ *     <TMDataGrid.Menu>
+ *       <TMDataGrid.Menu.Columns />
+ *     </TMDataGrid.Menu>
  *   </TMDataGrid.Toolbar>
  *   <TMDataGrid.Table />
  *   <TMDataGrid.Footer />
  * </TMDataGrid>
  * ```
  */
-declare function TMDataGridRoot<TData extends RowData>({ table, ui, edit, features, labels, renderDetails, renderDetailsEstHeight, overscan, resetSettings, scrollToRow, scrollerRef, size, children, className, style, id, "data-testid": testId }: TMDataGridProps<TData>): import("react").JSX.Element;
 declare const TMDataGrid: typeof TMDataGridRoot & {
   Toolbar: typeof TMDataGridToolbar;
   Spacer: typeof TMDataGridToolbarSpacer;
@@ -2944,7 +3503,14 @@ declare const TMDataGrid: typeof TMDataGridRoot & {
   LoadingIndicator: typeof TMDataGridLoadingIndicator;
   Search: typeof TMDataGridSearch;
   DraftActions: typeof TMDataGridDraftActions;
-  ColumnsButton: typeof TMDataGridColumnsButton;
+  Menu: (({ children, icon, label, ...menuProps }: TMDataGridMenuProps) => import("react").JSX.Element) & {
+    Columns: typeof TMDataGridMenuColumns;
+    ColumnToggles: typeof TMDataGridMenuColumnToggles;
+    ShowHideAll: typeof TMDataGridMenuShowHideAll;
+    ResetLayout: typeof TMDataGridMenuResetLayout;
+    Export: typeof TMDataGridMenuExport;
+    ExportSelected: typeof TMDataGridMenuExportSelected;
+  };
   FilterButton: typeof TMDataGridFilterButton;
   Table: typeof TMDataGridTable$1;
   Footer: typeof TMDataGridFooter;
@@ -2955,7 +3521,10 @@ declare const TMDataGrid: typeof TMDataGridRoot & {
    * rendered outside `<TMDataGrid>` - a page header, for instance.
    */
   FilterPills: typeof TMDataGridFilterPills;
-  /** Rendered by `TMDataGrid.ColumnsButton`; exported for custom layouts. */
+  /**
+   * The column chooser as plain controls, for a Popover, a Drawer or an
+   * inline layout; `TMDataGrid.Menu.Columns` is the same thing as menu items.
+   */
   ColumnsPanel: typeof TMDataGridColumnsPanel;
 };
 //#endregion
@@ -2973,6 +3542,21 @@ declare const ROW_NUMBER_COLUMN_ID = "__rowNumber__";
 //#endregion
 //#region .types-tmp/components/TMDataGridGroupColumn.d.ts
 declare const GROUP_COLUMN_ID = "__group__";
+//#endregion
+//#region .types-tmp/core/grouping.d.ts
+/**
+ * The data rows under a group row, at any depth.
+ *
+ * Not `row.getLeafRows()`, despite the name: that flattens the whole subtree
+ * and keeps the branches, so a group nested two deep reports its sub-groups
+ * alongside the records. Grouping `city` then `name` would have Stockholm
+ * counting four rows and three names as seven, and one tick on it selecting
+ * ids that hold no record.
+ *
+ * A row with no subRows is a data row, which also makes this the identity on an
+ * ungrouped grid.
+ */
+declare function getGroupDataRows<TData extends RowData>(row: Row<TMDataGridFeatures, TData>): Array<Row<TMDataGridFeatures, TData>>;
 /**
  * How a grouping value is written into the tree cell.
  *
@@ -2982,17 +3566,60 @@ declare const GROUP_COLUMN_ID = "__group__";
  */
 declare function formatGroupValue(value: unknown, blankLabel?: string): string;
 //#endregion
+//#region .types-tmp/useTMDataGridExport.d.ts
+/** What {@link useTMDataGridExport} returns. */
+type TMDataGridExportApi = {
+  /**
+   * Downloads every filtered and sorted row, all pages. `overrides` are folded
+   * over the hook's options for this one call - the column picker's chosen
+   * columns, for instance.
+   */
+  exportAll: (overrides?: TMDataGridExportOptions) => Promise<void>;
+  /**
+   * Downloads the selected rows of the current view, in grid order. Resolves
+   * without a download when none is selected.
+   */
+  exportSelected: (overrides?: TMDataGridExportOptions) => Promise<void>;
+  /** How many rows `exportSelected` would write. Subscribes to the selection. */
+  selectedCount: number;
+  /**
+   * Whether row selection is on at all - `false` under
+   * `selectionMode: "highlight"` or `enableRowSelection: false`, where a
+   * "selected rows" control has nothing to offer.
+   */
+  canExportSelected: boolean;
+};
+/**
+ * The export as click handlers, for a button of your own anywhere inside the
+ * grid. The `TMDataGrid.Menu.Export*` items are this hook behind a
+ * `Menu.Item`.
+ *
+ * ```tsx
+ * function ExportButton() {
+ *   const { exportAll } = useTMDataGridExport();
+ *   return <Button onClick={() => void exportAll()}>Export</Button>;
+ * }
+ * ```
+ *
+ * `overrides` are folded over the grid's `exportOptions` for this caller:
+ * another format, another file name, another set of columns.
+ */
+declare function useTMDataGridExport(overrides?: TMDataGridExportOptions): TMDataGridExportApi;
+//#endregion
 //#region .types-tmp/components/filters/TMDataGridFilterValueInput.d.ts
 /**
- * The built-in value control of a filter-panel row - what renders when a
- * column declares no `meta.filter.control`. Shaped by the operator: a
- * multi-select for the set operators, a From/To pair for `between`, a Yes/No
- * dropdown for booleans, a typed input otherwise.
+ * The built-in value control of a filter row - what renders when a column
+ * declares no `meta.filter.control`. Shaped by the operator: a multi-select
+ * for the set operators, a From/To pair for `between`, a Yes/No dropdown for
+ * booleans, a typed input otherwise.
+ *
+ * Shaped by `layout` as well: in a header cell the fields drop their labels,
+ * fill the column's width and name themselves through `aria-label`.
  *
  * Exported so a custom control can fall back to it for the operators it does
  * not care about, instead of rebuilding them.
  */
-declare function TMDataGridFilterValueInput({ column, operator, value, onChange, options, size, labels }: TMDataGridFilterControlArgs): import("react").JSX.Element;
+declare function TMDataGridFilterValueInput(args: TMDataGridFilterControlArgs): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/filters/DgRangeSliderFilter.d.ts
 /**
@@ -3080,92 +3707,6 @@ declare function TMDataGridMultiSelectEditor({ field, column, row, table, size }
  */
 declare const TMDATAGRID_LABELS_SV: TMDataGridLabels;
 //#endregion
-//#region .types-tmp/core/columnUtils.d.ts
-/**
- * Structural shape of the column bits the chrome reads. Kept minimal so these
- * helpers work with any `Column`/`Header` instance without dragging generics
- * through every call site.
- */
-type ColumnLike = {
-  id: string;
-  columnDef: {
-    header?: unknown;
-    meta?: TMDataGridColumnMeta;
-  };
-  /** Set on a leaf that sits inside a header group. */
-  parent?: unknown;
-};
-/** Menu- and panel-facing column name. */
-declare function getColumnLabel(column: ColumnLike): string;
-declare function getColumnType(column: ColumnLike): TMDataGridColumnType;
-/**
- * The operator a fresh filter on this column starts with -
- * `meta.filter.defaultOperator`, else the type's default.
- */
-declare function getColumnDefaultOperator(column: ColumnLike): TMDataGridFilterOperator;
-/**
- * This column's filter-panel value control - `meta.filter.control`, or
- * `undefined` for the built-in shape-by-operator input.
- */
-declare function getColumnFilterControl(column: ColumnLike): TMDataGridFilterControlComponent | undefined;
-/**
- * Whether `meta.edit.enabled` lets this column's cell on this row be edited -
- * the switch, then the predicate.
- *
- * This is only the column's half of the rule. A cell also needs the column to
- * map to a field (`getEditFieldName`) and the row to take edits at all
- * (`isRowEditable`); `edit.canEditCell` is the whole question.
- */
-declare function isColumnEditableForRow(column: ColumnLike, row: Row<TMDataGridFeatures, TMDataGridRowData>): boolean;
-/**
- * A generated lane holding one fixed-width thing - the checkbox, the details
- * chevron, the row number.
- *
- * They are laid out differently from every other column: cell padding is sized
- * for text and grows with the scale, which at `xl` squeezed a 16px checkbox out
- * of its track, so these lanes centre their content in an unpadded cell.
- * Their headers carry no column menu, and none of them is ever exported -
- * they hold chrome, not values.
- *
- * The tree column is deliberately not one of them: it holds a label as well as a
- * chevron, and wants the padding.
- */
-declare function isControlColumn(columnId: string): boolean;
-/**
- * Whether the grid generated this column rather than the consumer declaring it
- * - the four control lanes plus the tree column.
- *
- * These hold the grid's own chrome, and they keep the edges of the row: the
- * generated left lanes before every consumer column, the edit lane after all of
- * them. `isControlColumn` answers a narrower question about layout, and leaves
- * the tree column out because it is padded like a data column.
- */
-declare function isGeneratedColumn(columnId: string): boolean;
-/**
- * Whether a column may be moved. Ordering is the one column feature TanStack
- * has no column option for, so the switch lives in `meta.enableOrdering`.
- *
- * A leaf inside a header group is never movable: `columnOrder` sequences leaf
- * columns, so moving one out of its group would leave the group header spanning
- * columns that no longer belong to it.
- */
-declare function isColumnReorderable(column: ColumnLike): boolean;
-//#endregion
-//#region .types-tmp/core/grouping.d.ts
-/**
- * The data rows under a group row, at any depth.
- *
- * Not `row.getLeafRows()`, despite the name: that flattens the whole subtree
- * and keeps the branches, so a group nested two deep reports its sub-groups
- * alongside the records. Grouping `city` then `name` would have Stockholm
- * counting four rows and three names as seven, and one tick on it selecting
- * ids that hold no record.
- *
- * A row with no subRows is a data row, which also makes this the identity on an
- * ungrouped grid.
- */
-declare function getGroupDataRows<TData extends RowData>(row: Row<TMDataGridFeatures, TData>): Array<Row<TMDataGridFeatures, TData>>;
-//#endregion
 //#region .types-tmp/core/summary.d.ts
 /** The registered aggregation names - the same set `aggregationFn` accepts. */
 type TMDataGridAggregationName = keyof typeof aggregationFns;
@@ -3194,20 +3735,6 @@ declare function aggregateColumn<TData extends RowData>({ table, columnId, fn }:
 }): unknown;
 //#endregion
 //#region .types-tmp/core/autosize.d.ts
-/**
- * Widest rendered content of one column, in px, measured from the DOM.
- *
- * Mounted cells only: under virtualization the unmounted rows do not exist to
- * be measured, so this reads the visible window plus overscan - the same
- * trade AG Grid's autosize makes by default. With no rows mounted at all the
- * header is the only thing left to measure, which is a width that fits the
- * title and nothing else - see `hasMountedCells`.
- */
-declare function measureColumnContentWidth({ container, columnId }: {
-  /** The grid's scroll container - anything enclosing the column's cells. */
-  container: HTMLElement;
-  columnId: string;
-}): number;
 /**
  * Sizes a column to its widest mounted content - what double-clicking the
  * resize divider does, exported so a menu item or consumer code can trigger
@@ -3274,11 +3801,11 @@ type GridTable = TMDataGridTable<TMDataGridRowData>;
  * The lane a column renders in.
  *
  * Pinning splits the grid into three, and TanStack sequences them from two
- * different state slices: `columnPinning.left` / `.right` order the pinned
+ * different state slices: `columnPinning.start` / `.end` order the pinned
  * lanes, `columnOrder` orders the centre. A move therefore always stays inside
  * one lane - moving a column into another one would be a pin, not a reorder.
  */
-type TMDataGridColumnRegion = "left" | "center" | "right";
+type TMDataGridColumnRegion = "start" | "center" | "end";
 /** Which edge of the column under the pointer a dragged column lands on. */
 type TMDataGridDropSide = "before" | "after";
 declare function getColumnRegion(columnPinning: ColumnPinningState, columnId: string): TMDataGridColumnRegion;
@@ -3304,7 +3831,7 @@ declare function moveColumn({ table, columnId, targetId, side }: MoveColumnArgs)
  * Puts the generated lanes back on the outside of both pinned lanes: the ones
  * on the left before every consumer column, the edit lane after all of them.
  *
- * `column.pin("right")` appends, so pinning a column right would otherwise drop
+ * `column.pin("end")` appends, so pinning a column right would otherwise drop
  * it outside the edit lane, so the row's Save and Delete would no longer be
  * last in the row. Pinning left appends too, which is already correct there,
  * but the same pass keeps both lanes in place whatever a consumer writes into
@@ -3430,4 +3957,4 @@ declare function getSelectableRowIds<TData extends RowData>(row: Row<TMDataGridF
  */
 declare function resolveRowSelectionClick<TData extends RowData>({ rows, rowId, anchorRowId, modifiers, selection, canReplaceSelection }: ResolveRowSelectionClickArgs<TData>): ResolvedRowSelection;
 //#endregion
-export { type BuildCellMatrixArgs, type ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_CELL_EXPORT_OPTIONS, DEFAULT_TMDATAGRID_SIZE, DETAILS_COLUMN_ID, DgAutocompleteFilter, DgDateRangeFilter, DgRangeSliderFilter, DgTriStateFilter, EDIT_COLUMN_ID, FILTER_OPERATOR_LABELS, GROUP_COLUMN_ID, type MoveColumnArgs, PERSIST_PAYLOAD_VERSION, ROW_NUMBER_COLUMN_ID, type ResolveCellMoveArgs, type ResolveRangeBoundsArgs, type ResolveRowSelectionClickArgs, type ResolvedRowSelection, SELECT_COLUMN_ID, SETTINGS_STATE_SLICES, SIZE_CONTROL_SIZE, SIZE_ROW_HEIGHT, TMDATAGRID_LABELS_EN, TMDATAGRID_LABELS_SV, TMDataGrid, type TMDataGridAddRowsOptions, type TMDataGridAddRowsResult, type TMDataGridAggregationName, type TMDataGridApi, TMDataGridBooleanEditor, type TMDataGridCapabilities, type TMDataGridCellCoords, type TMDataGridCellEventArgs, type TMDataGridCellExportOptions, type TMDataGridCellMatrix, type TMDataGridCellNav, type TMDataGridCellPosition, type TMDataGridCellRange, type TMDataGridCellSelectionMode, type TMDataGridColumnCapabilities, type TMDataGridColumnEditOptions, type TMDataGridColumnFilterOptions, type TMDataGridColumnLayout, type TMDataGridColumnMenuItemsArgs, type TMDataGridColumnMenuItemsRenderer, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnType, type TMDataGridContextValue, type TMDataGridDataSlice, TMDataGridDateEditor, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, TMDataGridDraftActions, type TMDataGridDraftActionsActions, type TMDataGridDraftActionsControls, type TMDataGridDraftActionsProps, type TMDataGridDraftActionsSlotArgs, type TMDataGridDraftActionsState, type TMDataGridDropSide, type TMDataGridEditApi, type TMDataGridEditChange, type TMDataGridEditCommitArgs, type TMDataGridEditCommitDraftsArgs, type TMDataGridEditField, type TMDataGridEditMode, type TMDataGridEditRowProjection, type TMDataGridEditState, type TMDataGridEditValueMap, type TMDataGridEditValueMapArgs, type TMDataGridEditingOptions, type TMDataGridEditorArgs, type TMDataGridEditorComponent, type TMDataGridExpandAllArgs, type TMDataGridExpandTarget, type TMDataGridFeatureFlags, type TMDataGridFeatures, type TMDataGridFieldValidate, type TMDataGridFilterControlArgs, type TMDataGridFilterControlComponent, type TMDataGridFilterOperator, TMDataGridFilterPills, type TMDataGridFilterPillsProps, type TMDataGridFilterValue, TMDataGridFilterValueInput, type TMDataGridFooterProps, type TMDataGridLabels, type TMDataGridLabelsOverride, TMDataGridMultiSelectEditor, TMDataGridNumberEditor, type TMDataGridOption, type TMDataGridOptionsArgs, type TMDataGridOptionsSource, type TMDataGridPaginationActions, type TMDataGridPaginationApi, type TMDataGridPaginationControls, type TMDataGridPaginationSlotArgs, type TMDataGridPaginationState, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridQuickSearchMode, type TMDataGridRangeBounds, type TMDataGridRowAddArgs, type TMDataGridRowClickModifiers, type TMDataGridRowContextMenuArgs, type TMDataGridRowContextMenuRenderer, type TMDataGridRowData, type TMDataGridRowDeleteArgs, type TMDataGridRowEditForm, type TMDataGridRowStyle, type TMDataGridRowValidators, type TMDataGridSaveDraftsArgs, type TMDataGridSaveDraftsResult, type TMDataGridSaveOutcomes, type TMDataGridScrollAlign, type TMDataGridScrollToRowArgs, TMDataGridSearch, type TMDataGridSearchProps, TMDataGridSelectEditor, type TMDataGridSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, TMDataGridStringEditor, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridTableProps, type TMDataGridTableValidateArgs, type TMDataGridTableValidators, type TMDataGridUiActions, type TMDataGridUiState, type TMDataGridUiStore, type UseTMDataGridOptions, aggregateColumn, areAllRowsExpanded, autosizeColumn, boundsCellCount, boundsEdges, buildCellMatrix, buildGridCellMatrix, clearedValueForType, createTMDataGridColumnHelper, downloadTextFile, emptyValueForOperator, exportGridToCsv, formatExportValue, formatFilterLabel, formatGroupValue, fuzzyGlobalFilterFn, getColumnCapabilities, getColumnDefaultOperator, getColumnFilterControl, getColumnLabel, getColumnRegion, getColumnType, getDefaultOperator, getDisplayedRows, getEditFieldName, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, isColumnEditableForRow, isColumnReorderable, isControlColumn, isFilterActive, isGeneratedColumn, isPagingActive, isSameCell, isWithinBounds, keepGeneratedColumnsOutermost, measureColumnContentWidth, mergeLabels, moveColumn, moveColumnByStep, normalizeFieldValidate, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, operatorTakesRangeValue, optionsToComboboxData, readFeatureFlags, resolveCellMove, resolveColumnOptions, resolveExpandAll, resolveRangeBounds, resolveRowSelectionClick, tmDataGridFeatures, toClipboardText, toExcelCsv, useCellControlTabIndex, useTMDataGrid, useTMDataGridContext, writeClipboardText };
+export { type BuildExportDataArgs, type ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_EXPORT_OPTIONS, DEFAULT_TMDATAGRID_SIZE, DETAILS_COLUMN_ID, DgAutocompleteFilter, DgDateRangeFilter, DgRangeSliderFilter, DgTriStateFilter, EDIT_COLUMN_ID, type ExportGridArgs, FILTER_OPERATOR_LABELS, GROUP_COLUMN_ID, type MoveColumnArgs, PERSIST_PAYLOAD_VERSION, ROW_NUMBER_COLUMN_ID, type ResolveRangeBoundsArgs, type ResolveRowSelectionClickArgs, type ResolvedRowSelection, SELECT_COLUMN_ID, SETTINGS_STATE_SLICES, SIZE_CONTROL_SIZE, SIZE_ROW_HEIGHT, TMDATAGRID_LABELS_EN, TMDATAGRID_LABELS_SV, TMDataGrid, type TMDataGridAddRowsOptions, type TMDataGridAddRowsResult, type TMDataGridAggregationName, type TMDataGridApi, TMDataGridBooleanEditor, type TMDataGridCapabilities, type TMDataGridCellEventArgs, type TMDataGridCellPosition, type TMDataGridCellRange, type TMDataGridCellSelectionMode, type TMDataGridClipboardTextOptions, type TMDataGridColumnCapabilities, type TMDataGridColumnEditOptions, type TMDataGridColumnFilter, type TMDataGridColumnFilterOptions, type TMDataGridColumnHelper, type TMDataGridColumnMenuItemsArgs, type TMDataGridColumnMenuItemsRenderer, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnSearchable, type TMDataGridColumnType, type TMDataGridColumnsPanelProps, type TMDataGridCommitAllResult, type TMDataGridContextValue, type TMDataGridCsvFormatOptions, type TMDataGridDataSlice, TMDataGridDateEditor, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, TMDataGridDraftActions, type TMDataGridDraftActionsActions, type TMDataGridDraftActionsControls, type TMDataGridDraftActionsProps, type TMDataGridDraftActionsSlotArgs, type TMDataGridDraftActionsState, type TMDataGridDropSide, type TMDataGridEditApi, type TMDataGridEditChange, type TMDataGridEditCommitArgs, type TMDataGridEditField, type TMDataGridEditMode, type TMDataGridEditRowProjection, type TMDataGridEditRowSnapshot, type TMDataGridEditState, type TMDataGridEditValueMap, type TMDataGridEditValueMapArgs, type TMDataGridEditingOptions, type TMDataGridEditorArgs, type TMDataGridEditorComponent, type TMDataGridExpandAllArgs, type TMDataGridExpandTarget, type TMDataGridExportApi, type TMDataGridExportColumns, type TMDataGridExportData, type TMDataGridExportFormat, type TMDataGridExportOptions, type TMDataGridExportPickerRequest, type TMDataGridExportRows, type TMDataGridExportSettings, type TMDataGridExportValueGetter, type TMDataGridExportWriteOptions, type TMDataGridFeatureFlags, type TMDataGridFeatures, type TMDataGridFieldValidate, type TMDataGridFilterControlArgs, type TMDataGridFilterControlComponent, type TMDataGridFilterControlLayout, type TMDataGridFilterOperator, type TMDataGridFilterPanelLayout, type TMDataGridFilterPanelProps, TMDataGridFilterPills, type TMDataGridFilterPillsProps, type TMDataGridFilterSidebarSide, type TMDataGridFilterSurface, type TMDataGridFilterValue, TMDataGridFilterValueInput, type TMDataGridFilterValueShape, type TMDataGridFiltersOptions, type TMDataGridFiltersSettings, type TMDataGridFooterProps, type TMDataGridJsonFormatOptions, type TMDataGridLabels, type TMDataGridLabelsOverride, type TMDataGridMenuColumnsProps, type TMDataGridMenuExportProps, type TMDataGridMenuProps, TMDataGridMultiSelectEditor, TMDataGridNumberEditor, type TMDataGridOption, type TMDataGridOptionsArgs, type TMDataGridOptionsSource, type TMDataGridPaginationActions, type TMDataGridPaginationApi, type TMDataGridPaginationControls, type TMDataGridPaginationSlotArgs, type TMDataGridPaginationState, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridQuickSearchMode, type TMDataGridRangeBounds, type TMDataGridRowAddArgs, type TMDataGridRowClickModifiers, type TMDataGridRowContextMenuArgs, type TMDataGridRowContextMenuRenderer, type TMDataGridRowData, type TMDataGridRowDeleteArgs, type TMDataGridRowEditForm, type TMDataGridRowStyle, type TMDataGridRowValidators, type TMDataGridSaveDraftsArgs, type TMDataGridSaveDraftsResponse, type TMDataGridSaveDraftsResult, type TMDataGridSaveOutcomes, type TMDataGridScrollAlign, type TMDataGridScrollToRowArgs, TMDataGridSearch, type TMDataGridSearchProps, TMDataGridSelectEditor, type TMDataGridSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, TMDataGridStringEditor, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridTableProps, type TMDataGridTableValidateArgs, type TMDataGridTableValidators, type TMDataGridToolbarProps, type TMDataGridTsvFormatOptions, type TMDataGridUiActions, type TMDataGridUiState, type TMDataGridUiStore, type UseTMDataGridOptions, activeColumnFilters, aggregateColumn, areAllRowsExpanded, autosizeColumn, buildExportData, clearedValueForType, countSelectedExportRows, createTMDataGridColumnHelper, csvExcelFormat, csvFormat, downloadFile, emptyValueForOperator, exportGrid, filterValueShape, formatExportValue, formatFilterLabel, formatGroupValue, fuzzyGlobalFilterFn, getColumnCapabilities, getColumnDefaultOperator, getColumnLabel, getColumnOperators, getColumnRegion, getColumnType, getDisplayedRows, getEditFieldName, getExportableColumns, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, guardFormula, hasPendingEdits, isControlColumn, isFilterActive, isGeneratedColumn, isPagingActive, jsonFormat, keepGeneratedColumnsOutermost, mergeLabels, moveColumn, moveColumnByStep, normalizeFieldValidate, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, operatorTakesRangeValue, optionsToComboboxData, readFeatureFlags, resolveColumnOptions, resolveExpandAll, resolveExportOptions, resolveRangeBounds, resolveRowSelectionClick, toClipboardText, tsvFormat, useTMDataGrid, useTMDataGridContext, useTMDataGridExport, writeClipboardText, writeExportFile };