@jielga/tmdatagrid 2.0.0-beta.1 → 2.0.0-beta.10

package/dist/index.d.ts

@@ -1,88 +1,61 @@
-import { Cell, Column, ColumnPinningState, ExpandedState, Header, Row, RowData, RowSelectionState, Table, TableFeatures, TableOptions, TableState, aggregationFns } from "@tanstack/react-table";
-import { CSSProperties, ComponentType, MouseEvent, MutableRefObject, ReactNode } from "react";
 import { MantineSize, MenuProps } from "@mantine/core";
+import { CSSProperties, ComponentType, MouseEvent, MutableRefObject, ReactNode } from "react";
+import { Cell, Column, 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;
+//#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 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;
+type TMDataGridMenuColumnsProps = {
+  /** Renders a `Menu.Search` above the toggles. Default `true`. Use `false` inside a `Menu.Sub`. */
+  searchable?: boolean;
 };
 /**
- * Batch 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.
+ * 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.
  *
- * ```tsx
- * <TMDataGrid.Toolbar>
- *   <TMDataGrid.SummaryCount />
- *   <TMDataGrid.Spacer />
- *   <TMDataGrid.EditActions />
- * </TMDataGrid.Toolbar>
- * ```
+ * `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 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;
+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;
 //#endregion
-//#region .types-tmp/components/TMDataGridFilterPanel.d.ts
+//#region .types-tmp/components/TMDataGridColumnsPanel.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.
+ * The "Manage columns" surface as plain controls, for a host that is not a
+ * menu - a Popover, a Drawer, an inline layout. `TMDataGrid.Menu.Columns` is
+ * the same chooser as menu items.
  */
-declare function TMDataGridFilterPanel(): import("react").JSX.Element | null;
+declare function TMDataGridColumnsPanel(): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/core/sizes.d.ts
 type TMDataGridSize = MantineSize;
@@ -113,28 +86,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
 /**
@@ -259,10 +210,21 @@ declare function tmDataGridFilterFn<TFeatures extends TableFeatures, TData exten
 //#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`.
+ * 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`.
+ *
+ * | 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 |
+ *
+ * An entry row is row-shaped in every mode - every editable cell open at
+ * once, the browser's Tab between them, and an explicit ✓.
  */
-type TMDataGridEditMode = "cell" | "cellConfirm" | "row" | "batch";
+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 +277,40 @@ 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 parked row during
+ * `saveDrafts` - so a draft invalidated by a later edit blocks the save.
+ *
+ * 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,11 +335,29 @@ 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;
+  /**
+   * The row as drafted - the form's `state.values`. Reference-stable while no
+   * value changes, so a cell may subscribe to it and repaint only when its
+   * row's draft actually moves.
+   */
+  values: TMDataGridRowData;
 };
 /**
  * The grid-facing index of everything mid-edit. A projection synced from the
@@ -362,16 +376,43 @@ type TMDataGridEditState = {
     columnId: string | null;
   } | null;
   /**
-   * Rows with a live form. In cell mode at most one; in row, cellConfirm and
-   * batch, as many as the user opened - which rows are editing.
+   * Rows with a live form, committed or not - every row the grid is holding
+   * work for. A row is *open* (undecided form state) when it is in here and
+   * not in {@link committedRowIds}.
    */
   openRowIds: ReadonlyArray<string>;
   rows: Record<string, TMDataGridEditRowProjection>;
-  /** Phase 4 - rows being created, not yet in `data`. */
+  /**
+   * The draft store's edit slice: existing rows whose form passed its submit
+   * and is parked, waiting for `saveDrafts`. A subset of `openRowIds` - the
+   * values stay in the row's form, this records which side of the line the
+   * row is on. `begin` on one of these takes it back out, into form state.
+   *
+   * Only `editing.draft` parks. Without it a commit goes straight to the
+   * consumer and the form is dropped, so this stays empty.
+   */
+  committedRowIds: ReadonlyArray<string>;
+  /**
+   * The draft store's values, per row - what a committed row *is* to the
+   * table. Snapshotted when a row commits (existing and entry rows alike)
+   * and kept across a reopen until the row commits again or is dropped, so
+   * a row keeps its place in the sort while a second cell is being typed
+   * into. The hook feeds these into the table's `data` in place of the
+   * consumer's records, which is how sorting, filtering, grouping and
+   * aggregates see a draft.
+   */
+  committedValues: Readonly<Record<string, TMDataGridRowData>>;
+  /**
+   * Rows being created, not yet in `data`. `committed` is the draft store's
+   * add slice: the entry row passed its submit and renders as a value row
+   * until `begin` re-opens it. Without `editing.draft` a commit adds through
+   * `onRowAdd` and the entry is dropped, so it never turns `true`.
+   */
   newRows: ReadonlyArray<{
     tempId: string;
+    committed: boolean;
   }>;
-  /** Phase 4 - rows marked deleted under batch mode. */
+  /** The draft store's delete slice: rows marked deleted, awaiting the save. */
   deletedRowIds: ReadonlyArray<string>;
 };
 type ErasedRow = Row<TMDataGridFeatures, TMDataGridRowData>;
@@ -481,7 +522,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;
@@ -492,15 +533,51 @@ type TMDataGridRowDeleteArgs<TData extends RowData> = {
   rowId: string;
   row: Row<TMDataGridFeatures, TData>;
 };
-/** What `submitAll` hands `onEditCommitBatch` - everything pending at once. */
-type TMDataGridEditCommitBatchArgs<TData extends RowData> = {
-  /** Every valid dirty existing row. */
+/**
+ * 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>>;
-  /** Every valid new row from the entry block. */
+  /** @deprecated Renamed to {@link created}. Removed in a later beta. */
   added: Array<TMDataGridRowAddArgs<TData>>;
-  /** Ids marked deleted while the batch accumulated. */
-  deleted: Array<string>;
 };
+/**
+ * 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.
  *
@@ -522,6 +599,35 @@ 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`.
  *
@@ -529,13 +635,27 @@ declare function clearedValueForType(type: TMDataGridColumnType): unknown;
  * 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.
  */
-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. */
   getForm: (rowId: string) => TMDataGridRowEditForm | undefined;
+  /**
+   * The row as shown: its draft values where a form holds one - open or
+   * parked 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.
@@ -543,6 +663,13 @@ type TMDataGridEditApi = {
   canEditCell: (row: ErasedRow, column: ErasedColumn) => boolean;
   /** Whether the row takes edits at all - the edit lane's pencil gate. */
   canEditRow: (row: ErasedRow) => boolean;
+  /**
+   * Whether the column takes edits at all, with no row in hand: it maps to a
+   * field, `editing.columns` lists it if that option is set, and
+   * `meta.edit.enabled` is not `false`. A per-row `enabled` predicate is the
+   * row's half of the question - `canEditCell` asks both.
+   */
+  isColumnEditable: (column: ErasedColumn) => boolean;
   /**
    * 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
@@ -565,24 +692,83 @@ 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 - batch 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` (batch).
+   * `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: () => string;
+  addRow: (values?: Partial<TData>) => string;
   /**
-   * Deletes a row: `onRowDelete` straight away under the immediate modes;
-   * under batch 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.
+   * Opens entry rows for a list of records at once - one state write for the
+   * batch, where a loop over `addRow` is one per row. Each row is seeded over
+   * `newRowDefaults` exactly as `addRow` does.
+   *
+   * `commit: true` submits each row as it lands, which is what an import
+   * wants: rows that validate commit (parked in the draft store under
+   * `editing.draft`, added through `onRowAdd` without it - once per row),
+   * and rows that fail stay open in the entry block carrying their errors,
+   * for the user to fix. The result says which went which way.
+   */
+  addRows: (rows: ReadonlyArray<Partial<TData>>, options?: TMDataGridAddRowsOptions) => Promise<TMDataGridAddRowsResult>;
+  /**
+   * Deletes a row: `onRowDelete` straight away, or under `editing.draft` a
+   * toggle of the id in `deletedRowIds` - the row renders struck through
+   * until `saveDrafts` reports it. On an uncommitted entry row it just
+   * discards the entry.
    */
   deleteRow: (rowId: string) => void;
   /** Whether delete chrome makes sense - the lane's trash gate. */
@@ -607,13 +793,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;
@@ -691,18 +879,31 @@ 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. */
   discardNewRow: string;
   /** The lane's trash can. */
   deleteRow: string;
-  /** The lane's undo on a row marked deleted (batch). */
+  /** The lane's undo on a row marked deleted (draft). */
   restoreRow: string;
+  /** The lane's undo on a row with a dirty draft (draft) - drops it. */
+  revertRow: string;
+  /** The lane's state icon on a confirmed entry row (draft). */
+  rowStateNew: string;
+  /** The lane's state icon on a row with a dirty draft (draft). */
+  rowStateEdited: string;
+  /** The lane's state icon on a row marked deleted (draft). */
+  rowStateDeleted: string;
   cellCount: (count: number) => string;
   copy: string;
   exportCsv: string;
@@ -985,8 +1186,22 @@ 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;
+  /**
+   * 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. */
   rowNumbers: boolean;
   /**
@@ -1427,7 +1642,6 @@ type TMDataGridDetailsRenderer<TData extends RowData> = (args: TMDataGridDetails
  */
 type TMDataGridUiState = {
   filterPanelOpen: boolean;
-  columnsPanelOpen: boolean;
   /** Column whose filter row should be focused when the panel opens. */
   filterPanelColumnId: string | null;
   /**
@@ -1472,8 +1686,6 @@ type TMDataGridUiState = {
 type TMDataGridUiActions = {
   openFilterPanel: (columnId?: string | null) => void;
   closeFilterPanel: () => void;
-  setColumnsPanelOpen: (open: boolean) => void;
-  toggleColumnsPanel: () => void;
   startColumnDrag: (columnId: string) => void;
   endColumnDrag: () => void;
   /**
@@ -1517,7 +1729,7 @@ type TMDataGridApi<TData extends RowData> = {
    * 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.
    */
-  edit: TMDataGridEditApi;
+  edit: TMDataGridEditApi<TData>;
   /** Table-level feature switches, re-read from options on every render. */
   features: TMDataGridFeatureFlags;
   /** Every string the chrome renders, `labels` merged over the English defaults. */
@@ -1581,6 +1793,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;
   /**
@@ -1597,38 +1830,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 batch. 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 batch, 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 |
- * | `"batch"` | `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
- * `onCommitBatch` exists only under `mode: "batch"`, 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.
@@ -1639,19 +1881,68 @@ 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: "batch";
+type TMDataGridEditingOptions<TData extends RowData> = TMDataGridEditingCallbacks<TData> & {
+  /** What counts as a commit. See the table above. */
+  mode: TMDataGridEditMode;
+  /**
+   * 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`.
+   */
+  columns?: ReadonlyArray<string>;
+} & ({
+  /**
+   * 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>;
   /**
-   * Batch 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.
+   * 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.
    */
-  onCommitBatch?: (args: TMDataGridEditCommitBatchArgs<TData>) => void | Promise<void>;
+  newRowsSticky?: boolean;
 } | {
-  mode: Exclude<TMDataGridEditMode, "batch">;
-  /** Only `"batch"`'s `submitAll` ever calls it - see the other branch. */
-  onCommitBatch?: never;
+  /** 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;
+  /** Parked entry rows exist only under `draft: true` - see there. */
+  newRowsSticky?: never;
 });
 type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridFeatures, TData>, "features"> & ({
   editing?: undefined;
@@ -1917,6 +2208,130 @@ declare function useTMDataGrid<TData extends RowData>({ persist, labels: labelsO
  */
 declare function openColumnFilter<TData extends RowData>(api: TMDataGridApi<TData>, columnId: string): void;
 //#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. */
+  isSubmitting: 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;
+  /**
+   * 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.
+   *
+   * 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`.
+   */
+  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 = {
+  /**
+   * Replaces the built-in Save/Discard pair, and is handed the pieces of it.
+   *
+   * ```tsx
+   * <TMDataGrid.DraftActions
+   *   renderActions={({ state, Controls }) => (
+   *     <Group>
+   *       {state.draftCount > 0 && <Badge>{state.draftCount}</Badge>}
+   *       <Controls.OpenRowsNote />
+   *       <Controls.Save />
+   *       <Controls.Discard />
+   *     </Group>
+   *   )}
+   * />
+   * ```
+   */
+  renderActions?: (args: TMDataGridDraftActionsSlotArgs) => ReactNode;
+};
+/**
+ * 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.
+ *
+ * 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 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
+/**
+ * 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/components/TMDataGridFilterPills.d.ts
 type TMDataGridFilterPillsProps<TData extends RowData> = {
   /** The object returned by `useTMDataGrid`. */
@@ -2520,11 +2935,6 @@ declare function TMDataGridLoadingIndicator(): import("react").JSX.Element | nul
 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`).
@@ -2572,7 +2982,9 @@ 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 />
@@ -2586,8 +2998,13 @@ declare const TMDataGrid: typeof TMDataGridRoot & {
   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;
+  };
   FilterButton: typeof TMDataGridFilterButton;
   Table: typeof TMDataGridTable$1;
   Footer: typeof TMDataGridFooter;
@@ -2598,7 +3015,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
@@ -2825,6 +3245,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>;
@@ -3069,4 +3493,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 TMDataGridEditCommitBatchArgs, 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 ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_CELL_EXPORT_OPTIONS, DEFAULT_TMDATAGRID_SIZE, DETAILS_COLUMN_ID, DgAutocompleteFilter, DgDateRangeFilter, DgRangeSliderFilter, DgTriStateFilter, EDIT_COLUMN_ID, FILTER_OPERATOR_LABELS, GROUP_COLUMN_ID, type MoveColumnArgs, PERSIST_PAYLOAD_VERSION, ROW_NUMBER_COLUMN_ID, type ResolveCellMoveArgs, type ResolveRangeBoundsArgs, type ResolveRowSelectionClickArgs, type ResolvedRowSelection, SELECT_COLUMN_ID, SETTINGS_STATE_SLICES, SIZE_CONTROL_SIZE, SIZE_ROW_HEIGHT, TMDATAGRID_LABELS_EN, TMDATAGRID_LABELS_SV, TMDataGrid, type TMDataGridAddRowsOptions, type TMDataGridAddRowsResult, type TMDataGridAggregationName, type TMDataGridApi, TMDataGridBooleanEditor, type TMDataGridCapabilities, type TMDataGridCellCoords, type TMDataGridCellEventArgs, type TMDataGridCellExportOptions, type TMDataGridCellMatrix, type TMDataGridCellNav, type TMDataGridCellPosition, type TMDataGridCellRange, type TMDataGridCellSelectionMode, type TMDataGridColumnCapabilities, type TMDataGridColumnEditOptions, type TMDataGridColumnFilterOptions, type TMDataGridColumnLayout, type TMDataGridColumnMenuItemsArgs, type TMDataGridColumnMenuItemsRenderer, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnType, type TMDataGridContextValue, type TMDataGridDataSlice, TMDataGridDateEditor, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, TMDataGridDraftActions, type TMDataGridDraftActionsActions, type TMDataGridDraftActionsControls, type TMDataGridDraftActionsProps, type TMDataGridDraftActionsSlotArgs, type TMDataGridDraftActionsState, type TMDataGridDropSide, type TMDataGridEditApi, type TMDataGridEditChange, type TMDataGridEditCommitArgs, type TMDataGridEditCommitDraftsArgs, type TMDataGridEditField, type TMDataGridEditMode, type TMDataGridEditRowProjection, type TMDataGridEditRowSnapshot, 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, type TMDataGridMenuColumnsProps, 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 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, useTMDataGrid, useTMDataGridContext, writeClipboardText };