@jielga/tmdatagrid 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index.d.ts

@@ -1,89 +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 { MantineSize, MenuProps } from "@mantine/core";
+import { Cell, Column, ColumnFiltersState, ColumnPinningState, ExpandedState, Header, Row, RowData, RowSelectionState, Table, TableFeatures, TableOptions, TableState, aggregationFns } from "@tanstack/react-table";
 import { Store } from "@tanstack/store";
 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/components/TMDataGridEditActions.d.ts
-/** What the edit chrome is showing. */
-type TMDataGridEditActionsState = {
-  /** Rows with unsaved work: dirty edits, entry rows, and deletion marks. */
-  pendingCount: number;
-  /** Whether a submit is in flight. */
-  isSubmitting: boolean;
-};
-/** What the edit chrome can do. */
-type TMDataGridEditActionsActions = {
-  /** Commits every open row. Resolves `false` when a row stayed open. */
-  save: () => Promise<boolean>;
-  /** Drops every draft. */
-  discard: () => void;
-};
-/** The pre-bound pieces of the built-in edit chrome. */
-type TMDataGridEditActionsControls = {
-  /** Save, with the pending count, disabled while nothing is pending. */
-  Save: () => ReactNode;
-  /** Discard, disabled while nothing is pending. */
-  Discard: () => ReactNode;
-};
-/** What {@link TMDataGridEditActionsProps.renderActions} is handed. */
-type TMDataGridEditActionsSlotArgs = {
-  state: TMDataGridEditActionsState;
-  actions: TMDataGridEditActionsActions;
-  Controls: TMDataGridEditActionsControls;
-};
-type TMDataGridEditActionsProps = {
-  /**
-   * Replaces the built-in Save/Discard pair, and is handed the pieces of it.
-   *
-   * ```tsx
-   * <TMDataGrid.EditActions
-   *   renderActions={({ state, Controls }) => (
-   *     <Group>
-   *       {state.pendingCount > 0 && <Badge>{state.pendingCount}</Badge>}
-   *       <Controls.Save />
-   *       <Controls.Discard />
-   *     </Group>
-   *   )}
-   * />
-   * ```
-   */
-  renderActions?: (args: TMDataGridEditActionsSlotArgs) => ReactNode;
-};
-/**
- * Draft mode's toolbar chrome: Save with the dirty-row count, and Discard.
- * Both read the edit store, so they grey out while nothing is dirty and the
- * Save spins while a submit is in flight. Works under any `editing.mode` - a
- * cellConfirm grid accumulating drafts can offer the same pair - and renders
- * nothing while editing is off.
- *
- * ```tsx
- * <TMDataGrid.Toolbar>
- *   <TMDataGrid.SummaryCount />
- *   <TMDataGrid.Spacer />
- *   <TMDataGrid.EditActions />
- * </TMDataGrid.Toolbar>
- * ```
- */
-declare function TMDataGridEditActions({ renderActions }?: TMDataGridEditActionsProps): 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
-/**
- * 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.
- */
-declare function TMDataGridFilterPanel(): import("react").JSX.Element | null;
-//#endregion
 //#region .types-tmp/core/sizes.d.ts
 type TMDataGridSize = MantineSize;
 declare const DEFAULT_TMDATAGRID_SIZE: TMDataGridSize;
@@ -113,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
 /**
@@ -199,70 +97,23 @@ type ComboboxData = Array<ComboboxItem | {
  */
 declare function optionsToComboboxData(options: ReadonlyArray<TMDataGridOption>): ComboboxData;
 //#endregion
-//#region .types-tmp/core/filterOperators.d.ts
+//#region .types-tmp/core/editEngine.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.
+ * What counts as a commit - one axis, each mode a thin policy over the same
+ * engine. Where a commit *goes* is the other axis, `editing.draft`: out to
+ * the consumer, or into the draft store. See `editing` on
+ * `UseTMDataGridOptions`.
  *
- * `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.
+ * | Mode | Enter | Tab | Focus leaves | Escape |
+ * | ---- | ----- | --- | ------------ | ------ |
+ * | `"cell"` | commits | commits, caret moves on | commits | cancels |
+ * | `"cellConfirm"` | commits | keeps the draft, caret moves on | keeps the draft | cancels |
+ * | `"row"` | commits the row | the browser's, along the row | nothing | cancels the row |
  *
- * 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.
+ * An entry row is row-shaped in every mode - every editable cell open at
+ * once, the browser's Tab between them, and an explicit ✓.
  */
-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
-/**
- * How commits happen - one axis, each mode a thin policy over the same
- * engine. See `editMode` on `UseTMDataGridOptions`.
- */
-type TMDataGridEditMode = "cell" | "cellConfirm" | "row" | "draft";
+type TMDataGridEditMode = "cell" | "cellConfirm" | "row";
 /**
  * One editing row's live form. TanStack Form's `FormApi`, not a wrapper: the
  * engine is a form library, and everything mid-edit - values, dirty state,
@@ -315,6 +166,41 @@ type TMDataGridRowValidators = {
   onSubmitAsync?: TMDataGridValidator;
   onSubmitAsyncDebounceMs?: number;
 };
+/** What `editing.tableValidators` is handed for one commit. */
+type TMDataGridTableValidateArgs<TData extends RowData = TMDataGridRowData> = {
+  /** The committing row, as drafted. */
+  value: TData;
+  /** Its id - `addRow`'s temp id for an entry row. */
+  rowId: string;
+  /** Whether the row is an entry row, not yet in `data`. */
+  isNew: boolean;
+  /**
+   * The collection as it would stand if this commit landed: every data row
+   * overlaid with its draft where one is held (this row's `value` included),
+   * entry rows appended, deletion-marked rows removed. Unfiltered - a rule
+   * sees the whole collection whatever the view shows.
+   */
+  rows: ReadonlyArray<{
+    rowId: string;
+    value: TData;
+  }>;
+};
+/**
+ * `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 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 resolves `false`.
+ *
+ * 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.
+ * `onSubmit` runs first, and its failure stands without `onSubmitAsync`
+ * running.
+ */
+type TMDataGridTableValidators<TData extends RowData = TMDataGridRowData> = {
+  onSubmit?: (args: TMDataGridTableValidateArgs<TData>) => unknown;
+  onSubmitAsync?: (args: TMDataGridTableValidateArgs<TData>) => unknown | Promise<unknown>;
+};
 /** One field's before/after across a commit. */
 type TMDataGridEditChange = {
   /** Column the field maps back to, for consumers thinking in columns. */
@@ -339,8 +225,20 @@ type TMDataGridEditCommitArgs<TData extends RowData> = {
 type TMDataGridEditRowProjection = {
   /** Field names whose value differs from the original. */
   dirtyFields: ReadonlyArray<string>;
-  /** Field names carrying a validation error. */
+  /** Field names carrying a validation error, live or from a failed commit. */
   errorFields: ReadonlyArray<string>;
+  /**
+   * Those errors as text: what each cell editor is showing, plus what the
+   * row's last failed commit found. The second half is the reason this
+   * exists - Form clears a field's errors when its editor unmounts, so a row
+   * left invalid would go back to looking like an ordinary edited row. Such
+   * a message is dropped as soon as its field's value moves: the fix is what
+   * clears the mark.
+   */
+  errorMessages: ReadonlyArray<{
+    field: string;
+    message: string;
+  }>;
   /** A row-level error - a pathless `.refine()`, or a rejected commit. */
   hasRowError: boolean;
   isSubmitting: boolean;
@@ -368,26 +266,58 @@ type TMDataGridEditState = {
     columnId: string | null;
   } | null;
   /**
-   * Rows with a live form. In cell mode at most one; in row, cellConfirm and
-   * draft, as many as the user opened - which rows are editing.
+   * 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>;
   /**
-   * Rows being created, not yet in `data`. `confirmed` is draft mode's
-   * "entered, awaiting Save all": the entry row renders as a value row until
-   * `begin` re-opens it. Under the immediate modes a confirm commits through
-   * `onRowAdd` and the entry is dropped, so there it never turns `true`.
+   * 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` 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
+   * 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;
-    confirmed: boolean;
+    committed: boolean;
   }>;
-  /** Rows marked deleted under draft mode. */
+  /** 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>;
+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`,
@@ -405,8 +335,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>;
@@ -431,8 +361,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>;
 };
 /**
@@ -493,7 +423,7 @@ type TMDataGridColumnEditOptions = {
    */
   mapValue?: TMDataGridEditValueMap;
 };
-/** A new row being committed - `onRowAdd`, and `submitAll`'s `added`. */
+/** A new row being committed - `onRowAdd`, and `saveDrafts`'s `created`. */
 type TMDataGridRowAddArgs<TData extends RowData> = {
   /** The engine's placeholder id; the real id is the consumer's to mint. */
   tempId: string;
@@ -504,15 +434,51 @@ type TMDataGridRowDeleteArgs<TData extends RowData> = {
   rowId: string;
   row: Row<TMDataGridFeatures, TData>;
 };
-/** What `submitAll` hands `onEditCommitDrafts` - everything pending at once. */
-type TMDataGridEditCommitDraftsArgs<TData extends RowData> = {
-  /** Every valid dirty existing row. */
-  rows: Array<TMDataGridEditCommitArgs<TData>>;
-  /** Every valid new row from the entry block. */
-  added: Array<TMDataGridRowAddArgs<TData>>;
+/**
+ * The draft store, flushed - what `saveDrafts` hands `onSaveDrafts`. Every
+ * committed change at once, so a server can apply it as one transaction.
+ * Rows still open (undecided form state) are not in here and stay open.
+ */
+type TMDataGridSaveDraftsArgs<TData extends RowData> = {
+  /** Committed edits to existing rows; each entry carries its `rowId`. */
+  updated: Array<TMDataGridEditCommitArgs<TData>>;
+  /** Committed new rows from the entry block; each entry carries its `tempId`. */
+  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,
+ * saved and is dropped from the draft store; `false` failed and keeps its
+ * draft. A bare boolean answers for the whole bucket.
+ */
+type TMDataGridSaveOutcomes = boolean | Record<string, boolean>;
+/**
+ * What `onSaveDrafts` may return to save part of the store.
+ *
+ * Returning nothing saves everything, and throwing saves nothing. Between
+ * those, name the ids that failed: they keep their drafts, committed and
+ * ready for the next save, while the rest are dropped. The grid marks them
+ * 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 = {
+  /** Keyed by `rowId`. */
+  updated?: TMDataGridSaveOutcomes;
+  /** Keyed by `tempId`. */
+  created?: TMDataGridSaveOutcomes;
+  /** 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.
  *
@@ -534,27 +500,83 @@ declare function getEditFieldName(column: {
 }): string | null;
 /** What Delete writes into a cell - the type's honest empty value. */
 declare function clearedValueForType(type: TMDataGridColumnType): unknown;
+/** `edit.addRows` options. */
+type TMDataGridAddRowsOptions = {
+  /**
+   * Submit each row as it is added instead of leaving it open. Defaults to
+   * `false` - the rows open as editable entry rows, as `addRow` does.
+   */
+  commit?: boolean;
+};
+/** What `edit.addRows` reports back. Every added row is in exactly one list. */
+type TMDataGridAddRowsResult = {
+  /** Temp ids that committed - parked as drafts, or added outright. */
+  committed: Array<string>;
+  /**
+   * Temp ids still open in the entry block: everything, when `commit` was
+   * not asked for; the rows that failed validation, when it was.
+   */
+  open: 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 = {
+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$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
@@ -577,26 +599,102 @@ type TMDataGridEditApi = {
    * `"cellConfirm"`, where the dirty cell keeps waiting for its ✓.
    */
   deactivate: () => void;
-  /** Drops every draft. */
+  /** Drops every draft - open form state and the draft store alike. */
   cancelAll: () => void;
-  /** Commits every open row - draft mode's save. `true` when all landed. */
+  /**
+   * 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`.
+   */
+  commitAll: () => Promise<boolean>;
+  /**
+   * 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>;
   /** Writes the type's empty value into a cell and commits it - Delete. */
   clearCell: (rowId: string, columnId: string) => Promise<boolean>;
+  /**
+   * Writes one cell and commits the row - a typed edit without the typing,
+   * for toolbar actions and bulk fills. Under `editing.draft` the row parks
+   * in the draft store exactly as a hand-made edit does, so it carries the
+   * same change markers and the same per-row revert.
+   *
+   * The row need not be mounted; a row inside a collapsed group takes the
+   * write. Resolves `false` when the cell takes no edit - no such row or
+   * column, `editing.columns` excludes it, `meta.edit.enabled` is off, or the
+   * row is not editable - and when validation refuses the value, which leaves
+   * the row open carrying its errors.
+   *
+   * `value` is the stored value: no editor runs, so `meta.edit.mapValue`
+   * does not either. `meta.edit.validate` does.
+   */
+  setCellValue: (rowId: string, columnId: string, value: unknown) => Promise<boolean>;
+  /**
+   * {@link setCellValue} for several cells of one row, in a single commit -
+   * one consumer call and one draft entry rather than one per column. Keys
+   * are column ids.
+   *
+   * All or nothing: if any named cell takes no edit, nothing is written and
+   * this resolves `false`.
+   */
+  setRowValues: (rowId: string, values: Record<string, unknown>) => Promise<boolean>;
   /**
    * Opens a new entry row (the sticky block under the header) seeded from
-   * `newRowDefaults`. Returns its temporary id - a form with no backing row
-   * yet. Committing it calls `onRowAdd` (immediate modes) or joins
-   * `submitAll`'s `added` (draft).
+   * `newRowDefaults`. `values` overrides that seed key by key, so
+   * `addRow()` opens a blank row and `addRow({ status: "draft" })` opens one
+   * that starts filled in. Returns its temporary id - a form with no backing
+   * row yet. Committing it calls `onRowAdd`, or parks it for `saveDrafts`
+   * under `editing.draft`.
+   */
+  addRow: (values?: Partial<TData>) => string;
+  /**
+   * 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 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. 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.
    */
-  addRow: () => string;
+  addRows: (rows: ReadonlyArray<Partial<TData>>, options?: TMDataGridAddRowsOptions) => Promise<TMDataGridAddRowsResult>;
   /**
-   * Deletes a row: `onRowDelete` straight away under the immediate modes;
-   * under draft it toggles the id in `deletedRowIds` - the row renders
-   * struck through until `submitAll` reports it. On an uncommitted entry
-   * row it just discards the entry.
+   * Deletes a row: `onRowDelete` straight away, or under `editing.draft` a
+   * 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;
 };
@@ -619,13 +717,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;
@@ -656,6 +756,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;
@@ -681,6 +783,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;
@@ -703,10 +810,15 @@ type TMDataGridLabels = {
   cancelRowEdit: string;
   /** Save tooltip when field errors block the row, with no row message. */
   editRowErrors: string;
-  /** `EditActions`' Save, with the dirty-row count. */
+  /** `DraftActions`' Save, with the count of rows in the draft store. */
   saveAllEdits: (rows: number) => string;
-  /** `EditActions`' Discard. */
+  /** `DraftActions`' Discard. */
   discardAllEdits: string;
+  /**
+   * `DraftActions`' note about rows still open - edited but not committed, so
+   * not part of the save. Shown only while there are any.
+   */
+  editRowsStillOpen: (rows: number) => string;
   /** The entry row's ✓ - commit the add. */
   confirmNewRow: string;
   /** The entry row's ✕ - drop the entry. */
@@ -725,8 +837,24 @@ type TMDataGridLabels = {
   rowStateDeleted: string;
   cellCount: (count: number) => string;
   copy: string;
-  exportCsv: string;
+  exportCells: string;
+  /** @deprecated Use `exportCells`. Read as its fallback for one beta. */
+  exportCsv?: 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;
@@ -781,7 +909,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
@@ -802,10 +953,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;
   /**
@@ -815,6 +975,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";
@@ -1005,13 +1242,20 @@ type TMDataGridFeatureFlags = {
   grouping: boolean;
   /** Whether cells can be edited at all - the `editing` option was set. */
   editing: boolean;
-  /** The commit policy, or `null` while editing is off. */
+  /** What counts as a commit, or `null` while editing is off. */
   editMode: TMDataGridEditMode | null;
   /**
-   * Whether a confirmed entry row stays pinned in the sticky entry block
-   * until Save all - `editing.newRowsSticky`, draft mode only. Off by
-   * default: a confirmed row joins the scrolling flow instead, so entering
-   * many rows cannot fill the viewport with sticky chrome.
+   * Where a commit goes - `editing.draft`. On, commits park in the grid's
+   * draft store and leave through `edit.saveDrafts()`; off, each one reaches
+   * the consumer as it happens.
+   */
+  editDraft: boolean;
+  /**
+   * 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. */
@@ -1182,27 +1426,361 @@ declare function boundsEdges(bounds: TMDataGridRangeBounds | null, rowIndex: num
   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;
+type TMDataGridExportData = {
+  columnIds: Array<string>;
+  /** `getColumnLabel` per column: `meta.label`, a string header, or the id. */
+  headers: Array<string>;
+  rows: Array<Array<unknown>>;
+};
+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;
   /**
-   * Drives which filter operators are offered and, once editing is on, which
-   * editor the cell opens. Defaults to `"string"`.
+   * 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.
    */
-  type?: TMDataGridColumnType;
-  /**
-   * The choices of a `select` / `multiSelect` column - one declaration feeding
+  decimalComma?: boolean;
+  write: (data: TMDataGridExportData, options: TMDataGridExportWriteOptions) => string | Blob | Promise<string | Blob>;
+};
+/**
+ * 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.
+ */
+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;
+};
+/**
+ * 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, for callers of the
+ * deprecated `buildCellMatrix`.
+ */
+declare function toClipboardText(data: TMDataGridExportData | TMDataGridCellMatrix, { 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;
+/** @deprecated Use {@link TMDataGridExportData}; the matrix is text, the data holds values. */
+type TMDataGridCellMatrix = Array<Array<string>>;
+/** @deprecated Use {@link TMDataGridExportOptions} with `csvExcelFormat({ separator, decimalComma })`. */
+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;
+};
+/** @deprecated Use {@link DEFAULT_EXPORT_OPTIONS}. */
+declare const DEFAULT_CELL_EXPORT_OPTIONS: Required<TMDataGridCellExportOptions>;
+/**
+ * The old options as the new: separator and decimal mark become a
+ * `csvExcelFormat`, the rest carries over. Shared by the deprecated
+ * `cellExport` Table prop and {@link exportGridToCsv}.
+ *
+ * @deprecated Write {@link TMDataGridExportOptions} directly.
+ */
+declare function fromCellExportOptions(options: TMDataGridCellExportOptions): TMDataGridExportOptions;
+/** @deprecated Use {@link BuildExportDataArgs}. */
+type BuildCellMatrixArgs = {
+  rows: ReadonlyArray<ErasedRow>;
+  /** Every visible column, in render order - the same list the bounds index into. */
+  columns: ReadonlyArray<ErasedColumn>;
+  bounds: TMDataGridRangeBounds;
+  includeHeaders: boolean;
+  decimalComma: boolean;
+};
+/** @deprecated Use {@link buildExportData} with `bounds`, and a format to write it. */
+declare function buildCellMatrix({ rows, columns, bounds, includeHeaders, decimalComma }: BuildCellMatrixArgs): TMDataGridCellMatrix;
+/** @deprecated Use {@link buildExportData}. */
+declare function buildGridCellMatrix<TData extends RowData>({ table, includeHeaders, decimalComma }: {
+  table: TMDataGridTable<TData>;
+  includeHeaders?: boolean;
+  decimalComma?: boolean;
+}): TMDataGridCellMatrix;
+/** @deprecated Use {@link csvExcelFormat} - its `write` is this over export data. */
+declare function toExcelCsv(matrix: TMDataGridCellMatrix, { separator }: {
+  separator: string;
+}): string;
+/** @deprecated Use {@link exportGrid}. */
+declare function exportGridToCsv<TData extends RowData>({ table, options }: {
+  table: TMDataGridTable<TData>;
+  options?: TMDataGridCellExportOptions;
+}): void;
+/** @deprecated Use {@link downloadFile}. */
+declare function downloadTextFile({ fileName, text, mimeType }: {
+  fileName: string;
+  text: string;
+  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.
+ */
+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
@@ -1225,8 +1803,8 @@ type TMDataGridColumnMeta = {
    */
   enableOrdering?: boolean;
   /**
-   * How this column filters: the operator a fresh filter starts with, and the
-   * value control the filter panel renders for it.
+   * 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: {
@@ -1253,6 +1831,25 @@ type TMDataGridColumnMeta = {
    * See {@link TMDataGridColumnEditOptions}.
    */
   edit?: TMDataGridColumnEditOptions;
+  /**
+   * `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 = {
@@ -1283,6 +1880,7 @@ declare const tmDataGridFeatures: {
   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>;
@@ -1294,62 +1892,47 @@ declare const tmDataGridFeatures: {
   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;
-    };
+    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 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;
+    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;
@@ -1369,6 +1952,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>;
@@ -1380,62 +1964,47 @@ 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;
@@ -1454,9 +2023,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.
@@ -1495,12 +2075,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;
   /**
@@ -1541,12 +2141,27 @@ type TMDataGridApi<TData extends RowData> = {
   /**
    * 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.
+   * 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;
+  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`. */
@@ -1608,6 +2223,27 @@ type TMDataGridEditingCallbacks<TData extends RowData> = {
    * Pathed issues land on the matching columns; pathless ones on the row.
    */
   rowValidators?: TMDataGridRowValidators;
+  /**
+   * Rules that need the other rows - no duplicate keys, no overlapping
+   * ranges, allocations summing to a total. Handed the committing row and
+   * `rows`, the collection as it would stand if the commit landed: every
+   * draft overlaid, entry rows appended, deletion-marked rows removed.
+   *
+   * ```tsx
+   * tableValidators: {
+   *   onSubmit: ({ value, rowId, rows }) =>
+   *     rows.some((r) => r.rowId !== rowId && r.value.code === value.code)
+   *       ? { fields: { code: "Duplicate code" } }
+   *       : undefined,
+   * }
+   * ```
+   *
+   * Runs at every commit, after the row's own validators, and again per
+   * parked row during `saveDrafts` - a draft another edit has invalidated
+   * blocks the save. Pathed issues land on the committing row's cells,
+   * pathless ones on the row.
+   */
+  tableValidators?: TMDataGridTableValidators<TData>;
   /** Rows the pencil skips - `false` keeps a row read-only in every mode. */
   isRowEditable?: (row: Row<TMDataGridFeatures, TData>) => boolean;
   /**
@@ -1624,38 +2260,47 @@ type TMDataGridEditingCallbacks<TData extends RowData> = {
   /**
    * Seed values for `edit.addRow()` - the entry row's starting point. A
    * function is called per added row (fresh timestamps, empty arrays).
+   * `edit.addRow(values)` overrides this key by key for that one row.
    */
   newRowDefaults?: TData | (() => TData);
   /**
-   * Called when an entry row commits: `Enter` or the lane's ✓ under the
-   * immediate modes, `submitAll` under draft. Create the record and let it
-   * arrive back through `data`; the engine's `tempId` never leaves the grid.
+   * Called when an entry row commits: `Enter` or the lane's ✓, or
+   * `saveDrafts` under `editing.draft`. Create the record and let it arrive
+   * back through `data`; the engine's `tempId` never leaves the grid.
    */
   onRowAdd?: (args: TMDataGridRowAddArgs<TData>) => void | Promise<void>;
   /**
-   * Called by `edit.deleteRow` under the immediate modes - confirmation, if
-   * any, belongs in here. Under draft, deletions accumulate in
-   * `edit.state.deletedRowIds` instead and are reported by `submitAll`.
-   * Setting this also puts the trash can in the edit lane.
+   * Called by `edit.deleteRow` - confirmation, if any, belongs in here. Under
+   * `editing.draft` deletions accumulate in `edit.state.deletedRowIds`
+   * instead and are reported by `saveDrafts`. Setting this also puts the
+   * trash can in the edit lane.
    */
   onRowDelete?: (args: TMDataGridRowDeleteArgs<TData>) => void | Promise<void>;
 };
 /**
  * The `editing` option: one object that turns editing on and holds
- * everything about it. `mode` picks what counts as a commit and which
- * controls trigger it; the other members act within that mode.
+ * everything about it. Two axes, and they are independent: `mode` picks what
+ * counts as a commit, `draft` picks where that commit goes.
+ *
+ * | Mode | Commit | Cancel | Controls |
+ * | ---- | ------ | ------ | -------- |
+ * | `"cell"` | Enter, Tab, blur - Sheets | Escape | none |
+ * | `"cellConfirm"` | ✓ or Enter; Tab and blur keep the draft | ✕ or Escape | ✓ / ✕ beside the input |
+ * | `"row"` | Save in the edit lane, or Enter | Cancel, or Escape | generated edit lane |
+ *
+ * | `draft` | Where a commit goes |
+ * | ------- | ------------------- |
+ * | `false` (default) | Out as it happens - `onCommit`, `onRowAdd`, `onRowDelete` |
+ * | `true` | Into the grid's draft store; `edit.saveDrafts()` sends the lot |
  *
- * | Mode | Commit | Cancel |
- * | ---- | ------ | ------ |
- * | `"cell"` | Enter, Tab, blur - Sheets | Escape |
- * | `"cellConfirm"` | ✓ or Enter only; blur keeps the draft | ✕ or Escape |
- * | `"row"` | Save in the edit lane, or Ctrl+Enter | Cancel, or Escape |
- * | `"draft"` | `edit.submitAll()` | `edit.cancelAll()` |
+ * So `{ mode: "row", draft: true }` is "edit a row, the lane's ✓ parks it,
+ * the toolbar's Save sends every parked row at once", and
+ * `{ mode: "cell", draft: true }` is the same store filled cell by cell.
  *
  * Setting `editing` makes `getRowId` required - drafts are keyed by row id,
  * and the index fallback would name a different record after any sort - and
- * `onCommitDrafts` exists only under `mode: "draft"`, the one mode whose
- * `submitAll` calls it.
+ * `onSaveDrafts` exists only under `draft: true`, the one configuration with
+ * a draft store to save.
  *
  * The object may be written inline: the callbacks are read through a ref
  * every render, so its identity does not matter.
@@ -1666,28 +2311,67 @@ type TMDataGridEditingCallbacks<TData extends RowData> = {
  * built-in editor, and `enabled`, `field`, `editor`, `validate` and `mapValue`
  * override the rest.
  */
-type TMDataGridEditingOptions<TData extends RowData> = TMDataGridEditingCallbacks<TData> & ({
-  mode: "draft";
+type TMDataGridEditingOptions<TData extends RowData> = TMDataGridEditingCallbacks<TData> & {
+  /** What counts as a commit. See the table above. */
+  mode: TMDataGridEditMode;
   /**
-   * Draft mode's save, called once by `edit.submitAll()` with every
-   * valid dirty row. Without it, `submitAll` falls back to the per-row
-   * {@link TMDataGridEditingCallbacks.onCommit} loop. Rows failing
-   * validation stay open either way; a rejection keeps every draft.
+   * The column ids that take edits, by id. Unset - the default - every
+   * column mapping to a data path is editable, which is what a grid whose
+   * columns are mostly the record itself wants.
+   *
+   * Set it for the other shape: a grid of reference data with one or two
+   * columns the user maintains, where naming those is shorter and harder to
+   * get wrong than switching every other column off one by one.
+   *
+   * This gates before `meta.edit`, never past it: a column left out takes no
+   * edits whatever its own meta says, and a column listed here still answers
+   * to its `meta.edit.enabled`.
    */
-  onCommitDrafts?: (args: TMDataGridEditCommitDraftsArgs<TData>) => void | Promise<void>;
+  columns?: ReadonlyArray<string>;
+} & ({
   /**
-   * Keep confirmed entry rows pinned in the sticky entry block until
-   * Save all. Off by default: a confirmed row joins the scrolling
-   * flow above the body rows instead - the block a row is *typed*
-   * into is always sticky, but entered rows scroll, so entering many
-   * cannot fill the viewport with sticky chrome.
+   * Commits park in the grid's draft store instead of reaching the
+   * consumer, and leave together through `edit.saveDrafts()`. The
+   * edit lane gains the change markers and the per-row revert, the
+   * trash marks a row for deletion rather than deleting it, and
+   * `TMDataGrid.DraftActions` gets something to save.
+   */
+  draft: true;
+  /**
+   * The bulk save: called once by `edit.saveDrafts()` with the
+   * whole draft store - committed edits, added rows and deletion
+   * marks - so a server can apply it as one transaction. Without it,
+   * `saveDrafts` falls back to the per-row
+   * {@link TMDataGridEditingCallbacks.onCommit} loop.
+   *
+   * 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.
+   */
+  onSaveDrafts?: (args: TMDataGridSaveDraftsArgs<TData>) => void | TMDataGridSaveDraftsResult | Promise<void | TMDataGridSaveDraftsResult>;
+  /**
+   * @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 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;
 } | {
-  mode: Exclude<TMDataGridEditMode, "draft">;
-  /** Only `"draft"`'s `submitAll` ever calls it - see the other branch. */
+  /** Every commit reaches the consumer as it happens. The default. */
+  draft?: false;
+  /** Only `draft: true` has a store to save - see the other branch. */
+  onSaveDrafts?: never;
+  /** @deprecated See {@link onSaveDrafts}. */
   onCommitDrafts?: never;
-  /** Confirmed entry rows exist only under `"draft"` - see there. */
+  /** Parked entry rows exist only under `draft: true` - see there. */
   newRowsSticky?: never;
 });
 type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridFeatures, TData>, "features"> & ({
@@ -1743,12 +2427,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
@@ -1915,47 +2642,472 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
    * fields or an action strip; a highlight-driven side panel has room for more
    * and survives scrolling. Nothing stops a grid from doing both.
    */
-  renderDetails?: TMDataGridDetailsRenderer<TData>;
+  renderDetails?: TMDataGridDetailsRenderer<TData>;
+  /**
+   * What the virtualizer assumes an unmeasured detail panel is worth, in px.
+   * Defaults to 160.
+   *
+   * An estimate, not a height: every mounted row is measured, so the real one
+   * takes over as soon as the panel is on screen. It keeps the scrollbar
+   * accurate for panels that open off screen, such as restored `expanded`
+   * state. An approximate value is enough.
+   */
+  renderDetailsEstHeight?: number;
+  /**
+   * Rows the virtualizer keeps mounted above and below the viewport. Defaults
+   * to 6.
+   *
+   * Raise it to trade memory for a scroll that stays painted - fast wheel or
+   * touch flings can outrun the virtualizer and flash blank rows, and a larger
+   * buffer covers the gap. Lower it when rows are expensive to render.
+   */
+  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.
+ */
+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 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>;
+/**
+ * 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;
+/**
+ * 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;
+/** `"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 TMDataGridMenuExportSelected(props: TMDataGridMenuExportProps): import("react").JSX.Element | null;
+//#endregion
+//#region .types-tmp/components/TMDataGridColumnsPanel.d.ts
+/**
+ * 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.
+ */
+/** 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. */
+type TMDataGridDraftActionsState = {
+  /**
+   * Rows in the draft store, which is what Save sends: committed edits,
+   * committed entry rows and deletion marks.
+   */
+  draftCount: number;
+  /**
+   * Rows still open - edited or entered but not committed, so not part of
+   * the save. They stay open across a save.
+   */
+  openCount: number;
+  /**
+   * The ids behind {@link openCount}, in the order the grid opened them - a
+   * sort, a filter or a page never moves this list. An entered row appears as
+   * its `tempId`.
+   *
+   * Narrower than `edit.state.openRowIds`, which is every row holding a form,
+   * the parked ones included. And note the ordering:
+   * {@link TMDataGridDraftActionsActions.scrollToFirstOpenRow} takes "first"
+   * 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 - 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>;
+  /** Drops everything - open form state and the draft store alike. */
+  discard: () => void;
+  /**
+   * `grid.scrollToRow`, so a control in here can take the user to a row
+   * without the grid being threaded down to it.
+   */
+  scrollToRow: (args: TMDataGridScrollToRowArgs) => boolean;
   /**
-   * What the virtualizer assumes an unmeasured detail panel is worth, in px.
-   * Defaults to 160.
+   * Scrolls to the first row still open, taking "first" in display order: the
+   * topmost open row under the current sort, filter and page. That need not
+   * be {@link TMDataGridDraftActionsState.openRowIds}`[0]`, which is the
+   * order the grid opened them in.
    *
-   * An estimate, not a height: every mounted row is measured, so the real one
-   * takes over as soon as the panel is on screen. It keeps the scrollbar
-   * accurate for panels that open off screen, such as restored `expanded`
-   * state. An approximate value is enough.
+   * Answers whether an open row could be reached. `false` when nothing is
+   * open, and when every open row is filtered out, on another page or
+   * collapsed inside a group. An open entry row answers `true` without
+   * scrolling - it is sticky under the header, so it is on screen already -
+   * and so does an open row pinned to an edge. The scroll goes through
+   * `scrollToRow`, so before `TMDataGrid.Table` has mounted there is nothing
+   * to scroll and the answer is `false`.
    */
-  renderDetailsEstHeight?: number;
+  scrollToFirstOpenRow: (align?: TMDataGridScrollAlign) => boolean;
+};
+/** The pre-bound pieces of the built-in edit chrome. */
+type TMDataGridDraftActionsControls = {
+  /** Save, with the draft count, disabled while the draft store is empty. */
+  Save: () => ReactNode;
+  /** Discard, disabled while nothing is pending. */
+  Discard: () => ReactNode;
+  /** The "N rows still being edited" note, or nothing while there are none. */
+  OpenRowsNote: () => ReactNode;
+};
+/** What {@link TMDataGridDraftActionsProps.renderActions} is handed. */
+type TMDataGridDraftActionsSlotArgs = {
+  state: TMDataGridDraftActionsState;
+  actions: TMDataGridDraftActionsActions;
+  Controls: TMDataGridDraftActionsControls;
+};
+type TMDataGridDraftActionsProps = {
   /**
-   * Rows the virtualizer keeps mounted above and below the viewport. Defaults
-   * to 6.
+   * Replaces the built-in Save/Discard pair, and is handed the pieces of it.
    *
-   * Raise it to trade memory for a scroll that stays painted - fast wheel or
-   * touch flings can outrun the virtualizer and flash blank rows, and a larger
-   * buffer covers the gap. Lower it when rows are expensive to render.
+   * ```tsx
+   * <TMDataGrid.DraftActions
+   *   renderActions={({ state, Controls }) => (
+   *     <Group>
+   *       {state.draftCount > 0 && <Badge>{state.draftCount}</Badge>}
+   *       <Controls.OpenRowsNote />
+   *       <Controls.Save />
+   *       <Controls.Discard />
+   *     </Group>
+   *   )}
+   * />
+   * ```
    */
-  overscan?: number;
+  renderActions?: (args: TMDataGridDraftActionsSlotArgs) => ReactNode;
 };
 /**
- * Builds a TMDataGrid table plus its chrome store.
+ * The draft store's toolbar chrome: Save with the store's count, Discard, and
+ * a note counting the rows still open. Save sends the store and leaves open
+ * rows alone, so it greys out while nothing is parked however much is being
+ * typed - the note is what makes those rows visible.
  *
- * 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.
+ * Works under any `editing.mode`. The toolbar is declarative: the grid does
+ * not decide for you, so include this only when the grid runs a draft store -
+ * without `editing.draft` there is nothing to save and Save stays disabled.
+ *
+ * ```tsx
+ * <TMDataGrid.Toolbar>
+ *   <TMDataGrid.SummaryCount />
+ *   <TMDataGrid.Spacer />
+ *   <TMDataGrid.DraftActions />
+ * </TMDataGrid.Toolbar>
+ * ```
  */
-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 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;
+};
 /**
- * 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 MUI-style filter surface: one row per active column filter, each row a
+ * 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 openColumnFilter<TData extends RowData>(api: TMDataGridApi<TData>, columnId: string): void;
+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"`. */
@@ -1967,7 +3119,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
@@ -1989,7 +3140,7 @@ 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
 /** What the pager is showing. The read half of {@link TMDataGridPaginationApi}. */
@@ -2043,6 +3194,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;
 };
@@ -2059,7 +3216,8 @@ type TMDataGridPaginationSlotArgs = TMDataGridPaginationApi & {
  * 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.
@@ -2069,7 +3227,7 @@ type TMDataGridFooterProps = {
    *   renderPagination={({ state, actions, Controls }) => (
    *     <Group>
    *       <Controls.PageSize />
-   *       <MyJumpToPage page={state.pageIndex} onJump={actions.setPageIndex} />
+   *       <Controls.PageNumber />
    *       <Controls.Pager />
    *     </Group>
    *   )}
@@ -2088,7 +3246,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 = {
@@ -2147,135 +3305,6 @@ 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 = {
@@ -2484,9 +3513,10 @@ type TMDataGridTableProps<TData extends RowData> = {
    */
   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}.
+   * @deprecated Set `exportOptions` on `useTMDataGrid` instead; it covers the
+   * cell-range menu and every other export alike. Until it goes, this is
+   * converted (`separator` and `decimalComma` become a `csvExcelFormat`) and
+   * merged over `exportOptions` for the cell-range menu only.
    */
   cellExport?: TMDataGridCellExportOptions;
   /**
@@ -2526,12 +3556,22 @@ type TMDataGridTableProps<TData extends RowData> = {
 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;
 //#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.
  *
@@ -2553,18 +3593,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
@@ -2598,6 +3642,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:
@@ -2609,22 +3654,30 @@ 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;
   SummaryCount: typeof TMDataGridSummaryCount;
   LoadingIndicator: typeof TMDataGridLoadingIndicator;
   Search: typeof TMDataGridSearch;
-  EditActions: typeof TMDataGridEditActions;
-  ColumnsButton: typeof TMDataGridColumnsButton;
+  DraftActions: typeof TMDataGridDraftActions;
+  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;
@@ -2635,7 +3688,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
@@ -2662,17 +3718,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
 /**
@@ -2760,77 +3859,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.
@@ -2862,6 +3890,10 @@ type TMDataGridAggregationName = keyof typeof aggregationFns;
  * Filtered rather than paginated rows, so the total covers everything the
  * filters left (all pages), and follows the filters as they change. Reuses
  * TanStack's registered aggregation functions; `fn` defaults to `"sum"`.
+ *
+ * Every data row counts once. Grouping builds its group rows from this model
+ * rather than into it, so a grouped grid totals its records, not its records
+ * plus their subtotals; a tree counts parents and children alike.
  */
 declare function aggregateColumn<TData extends RowData>({ table, columnId, fn }: {
   table: TMDataGridTable<TData>;
@@ -2950,11 +3982,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;
@@ -2980,7 +4012,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
@@ -3106,4 +4138,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 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, type TMDataGridDropSide, TMDataGridEditActions, type TMDataGridEditActionsActions, type TMDataGridEditActionsControls, type TMDataGridEditActionsProps, type TMDataGridEditActionsSlotArgs, type TMDataGridEditActionsState, 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 TMDataGridScrollAlign, type TMDataGridScrollToRowArgs, TMDataGridSearch, type TMDataGridSearchProps, TMDataGridSelectEditor, type TMDataGridSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, TMDataGridStringEditor, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridTableProps, 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 BuildCellMatrixArgs, type BuildExportDataArgs, type ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_CELL_EXPORT_OPTIONS, 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 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 TMDataGridClipboardTextOptions, type TMDataGridColumnCapabilities, type TMDataGridColumnEditOptions, type TMDataGridColumnFilter, type TMDataGridColumnFilterOptions, type TMDataGridColumnLayout, type TMDataGridColumnMenuItemsArgs, type TMDataGridColumnMenuItemsRenderer, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnSearchable, type TMDataGridColumnType, type TMDataGridColumnsPanelProps, 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 TMDataGridEditCommitDraftsArgs, 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 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, boundsCellCount, boundsEdges, buildCellMatrix, buildExportData, buildGridCellMatrix, clearedValueForType, countSelectedExportRows, createTMDataGridColumnHelper, csvExcelFormat, csvFormat, downloadFile, downloadTextFile, emptyValueForOperator, exportGrid, exportGridToCsv, filterValueShape, formatExportValue, formatFilterLabel, formatGroupValue, fromCellExportOptions, fuzzyGlobalFilterFn, getColumnCapabilities, getColumnDefaultOperator, getColumnFilterControl, getColumnLabel, getColumnOperators, getColumnRegion, getColumnType, getDefaultOperator, getDisplayedRows, getEditFieldName, getExportableColumns, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, guardFormula, isColumnEditableForRow, isColumnReorderable, isControlColumn, isFilterActive, isGeneratedColumn, isPagingActive, isSameCell, isWithinBounds, jsonFormat, keepGeneratedColumnsOutermost, measureColumnContentWidth, mergeLabels, moveColumn, moveColumnByStep, normalizeFieldValidate, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, operatorTakesRangeValue, optionsToComboboxData, readFeatureFlags, resolveCellMove, resolveColumnOptions, resolveExpandAll, resolveExportOptions, resolveRangeBounds, resolveRowSelectionClick, tmDataGridFeatures, toClipboardText, toExcelCsv, tsvFormat, useTMDataGrid, useTMDataGridContext, useTMDataGridExport, writeClipboardText, writeExportFile };