@jielga/tmdatagrid 2.0.0-beta.4 → 2.0.0-beta.7

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 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 { Store } from "@tanstack/store";
+import { MantineSize, MenuProps } from "@mantine/core";
 import { AnyFieldApi, AnyFormApi, StandardSchemaV1 } from "@tanstack/react-form";
 import { RankingInfo } from "@tanstack/match-sorter-utils";
 //#region .types-tmp/components/TMDataGridColumnsPanel.d.ts
@@ -12,96 +12,6 @@ import { RankingInfo } from "@tanstack/match-sorter-utils";
  */
 declare function TMDataGridColumnsPanel(): import("react").JSX.Element;
 //#endregion
-//#region .types-tmp/components/TMDataGridEditActions.d.ts
-/** What the edit chrome is showing. */
-type TMDataGridEditActionsState = {
-  /**
-   * 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;
-  /**
-   * @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 TMDataGridEditActionsActions = {
-  /** 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;
-};
-/** The pre-bound pieces of the built-in edit chrome. */
-type TMDataGridEditActionsControls = {
-  /** 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 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.draftCount > 0 && <Badge>{state.draftCount}</Badge>}
-   *       <Controls.OpenRowsNote />
-   *       <Controls.Save />
-   *       <Controls.Discard />
-   *     </Group>
-   *   )}
-   * />
-   * ```
-   */
-  renderActions?: (args: TMDataGridEditActionsSlotArgs) => ReactNode;
-};
-/**
- * Draft mode's toolbar chrome: Save with the draft-store count, Discard, and
- * a note counting rows still open. Save sends the draft store and leaves open
- * rows alone, so it greys out while nothing is committed however much is
- * being typed - the note is what makes those rows visible. Works under any
- * `editing.mode` 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;
@@ -277,10 +187,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" | "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,
@@ -333,6 +254,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. */
@@ -357,8 +312,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;
@@ -398,22 +365,21 @@ type TMDataGridEditState = {
    * 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 draft mode parks; the immediate modes send a commit straight to the
-   * consumer and drop the form, so there this stays empty.
+   * 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>;
   /**
    * 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. Under the immediate modes a commit adds
-   * through `onRowAdd` and the entry is dropped, so there it never turns
-   * `true`.
+   * 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;
   }>;
-  /** The draft store's delete slice: rows marked deleted under draft mode. */
+  /** The draft store's delete slice: rows marked deleted, awaiting the save. */
   deletedRowIds: ReadonlyArray<string>;
 };
 type ErasedRow = Row<TMDataGridFeatures, TMDataGridRowData>;
@@ -523,7 +489,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;
@@ -639,6 +605,13 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
   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
@@ -665,10 +638,10 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
   cancelAll: () => void;
   /**
    * Submits every open row, as if each had been OK'd: a row that validates
-   * commits (into the draft store under draft mode, straight to the consumer
-   * under the immediate modes), a row that fails stays open with its errors.
-   * `true` when every row committed. Sends nothing to the consumer by itself
-   * under draft mode - that is `saveDrafts`.
+   * 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>;
   /**
@@ -687,13 +660,38 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
   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`. `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` (immediate modes) or joins
-   * `submitAll`'s `added` (draft).
+   * row yet. Committing it calls `onRowAdd`, or parks it for `saveDrafts`
+   * under `editing.draft`.
    */
   addRow: (values?: Partial<TData>) => string;
   /**
@@ -702,17 +700,17 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
    * `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 draft
-   * mode, added through `onRowAdd` under the immediate modes - once per row),
+   * 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 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
+   * 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. */
@@ -821,12 +819,12 @@ type TMDataGridLabels = {
   cancelRowEdit: string;
   /** Save tooltip when field errors block the row, with no row message. */
   editRowErrors: string;
-  /** `EditActions`' Save, with the count of rows in the draft store. */
+  /** `DraftActions`' Save, with the count of rows in the draft store. */
   saveAllEdits: (rows: number) => string;
-  /** `EditActions`' Discard. */
+  /** `DraftActions`' Discard. */
   discardAllEdits: string;
   /**
-   * `EditActions`' note about rows still open - edited but not committed, so
+   * `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;
@@ -1128,13 +1126,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 parked entry row stays pinned in the sticky entry block until
+   * the draft store is saved - `editing.newRowsSticky`, which needs
+   * `editing.draft`. Off by default: a parked row joins the scrolling flow
+   * instead, so entering many rows cannot fill the viewport with sticky
+   * chrome.
    */
   editNewRowsSticky: boolean;
   /** The generated row-number gutter - `enableRowNumbers`. Off by default. */
@@ -1731,6 +1736,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;
   /**
@@ -1751,35 +1777,43 @@ type TMDataGridEditingCallbacks<TData extends RowData> = {
    */
   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.commit(rowId)` into the draft store, `edit.saveDrafts()` out | `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
- * `onSaveDrafts` exists only under `mode: "draft"`, the one mode with a draft
- * store to save.
+ * `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.
@@ -1790,10 +1824,34 @@ 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.saveDrafts()` with the
+   * 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
@@ -1811,20 +1869,21 @@ type TMDataGridEditingOptions<TData extends RowData> = TMDataGridEditingCallback
    */
   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. Off by default: a committed row joins
-   * the scrolling flow above the body rows instead - the block a row
-   * is *typed* into is always sticky, but committed rows scroll, so
-   * committing many cannot fill the viewport with sticky chrome.
+   * Keep parked entry rows pinned in the sticky entry block until
+   * the draft store is saved. Off by default: a parked row joins the
+   * scrolling flow above the body rows instead - the block a row is
+   * *typed* into is always sticky, but parked rows scroll, so
+   * entering many cannot fill the viewport with sticky chrome.
    */
   newRowsSticky?: boolean;
 } | {
-  mode: Exclude<TMDataGridEditMode, "draft">;
-  /** Only `"draft"` has a draft store to save - 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;
-  /** Committed 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"> & ({
@@ -2091,6 +2150,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`. */
@@ -2760,7 +2943,7 @@ declare const TMDataGrid: typeof TMDataGridRoot & {
   SummaryCount: typeof TMDataGridSummaryCount;
   LoadingIndicator: typeof TMDataGridLoadingIndicator;
   Search: typeof TMDataGridSearch;
-  EditActions: typeof TMDataGridEditActions;
+  DraftActions: typeof TMDataGridDraftActions;
   ColumnsButton: typeof TMDataGridColumnsButton;
   FilterButton: typeof TMDataGridFilterButton;
   Table: typeof TMDataGridTable$1;
@@ -2999,6 +3182,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>;
@@ -3243,4 +3430,4 @@ declare function getSelectableRowIds<TData extends RowData>(row: Row<TMDataGridF
  */
 declare function resolveRowSelectionClick<TData extends RowData>({ rows, rowId, anchorRowId, modifiers, selection, canReplaceSelection }: ResolveRowSelectionClickArgs<TData>): ResolvedRowSelection;
 //#endregion
-export { type BuildCellMatrixArgs, type ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_CELL_EXPORT_OPTIONS, DEFAULT_TMDATAGRID_SIZE, DETAILS_COLUMN_ID, DgAutocompleteFilter, DgDateRangeFilter, DgRangeSliderFilter, DgTriStateFilter, EDIT_COLUMN_ID, FILTER_OPERATOR_LABELS, GROUP_COLUMN_ID, type MoveColumnArgs, PERSIST_PAYLOAD_VERSION, ROW_NUMBER_COLUMN_ID, type ResolveCellMoveArgs, type ResolveRangeBoundsArgs, type ResolveRowSelectionClickArgs, type ResolvedRowSelection, SELECT_COLUMN_ID, SETTINGS_STATE_SLICES, SIZE_CONTROL_SIZE, SIZE_ROW_HEIGHT, TMDATAGRID_LABELS_EN, TMDATAGRID_LABELS_SV, TMDataGrid, type TMDataGridAddRowsOptions, type TMDataGridAddRowsResult, type TMDataGridAggregationName, type TMDataGridApi, TMDataGridBooleanEditor, type TMDataGridCapabilities, type TMDataGridCellCoords, type TMDataGridCellEventArgs, type TMDataGridCellExportOptions, type TMDataGridCellMatrix, type TMDataGridCellNav, type TMDataGridCellPosition, type TMDataGridCellRange, type TMDataGridCellSelectionMode, type TMDataGridColumnCapabilities, type TMDataGridColumnEditOptions, type TMDataGridColumnFilterOptions, type TMDataGridColumnLayout, type TMDataGridColumnMenuItemsArgs, type TMDataGridColumnMenuItemsRenderer, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnType, type TMDataGridContextValue, type TMDataGridDataSlice, TMDataGridDateEditor, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, 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 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 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 TMDataGridEditState, type TMDataGridEditValueMap, type TMDataGridEditValueMapArgs, type TMDataGridEditingOptions, type TMDataGridEditorArgs, type TMDataGridEditorComponent, type TMDataGridExpandAllArgs, type TMDataGridExpandTarget, type TMDataGridFeatureFlags, type TMDataGridFeatures, type TMDataGridFieldValidate, type TMDataGridFilterControlArgs, type TMDataGridFilterControlComponent, type TMDataGridFilterOperator, TMDataGridFilterPills, type TMDataGridFilterPillsProps, type TMDataGridFilterValue, TMDataGridFilterValueInput, type TMDataGridFooterProps, type TMDataGridLabels, type TMDataGridLabelsOverride, TMDataGridMultiSelectEditor, TMDataGridNumberEditor, type TMDataGridOption, type TMDataGridOptionsArgs, type TMDataGridOptionsSource, type TMDataGridPaginationActions, type TMDataGridPaginationApi, type TMDataGridPaginationControls, type TMDataGridPaginationSlotArgs, type TMDataGridPaginationState, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridQuickSearchMode, type TMDataGridRangeBounds, type TMDataGridRowAddArgs, type TMDataGridRowClickModifiers, type TMDataGridRowContextMenuArgs, type TMDataGridRowContextMenuRenderer, type TMDataGridRowData, type TMDataGridRowDeleteArgs, type TMDataGridRowEditForm, type TMDataGridRowStyle, type TMDataGridRowValidators, type TMDataGridSaveDraftsArgs, type TMDataGridSaveDraftsResult, type TMDataGridSaveOutcomes, type TMDataGridScrollAlign, type TMDataGridScrollToRowArgs, TMDataGridSearch, type TMDataGridSearchProps, TMDataGridSelectEditor, type TMDataGridSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, TMDataGridStringEditor, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridTableProps, type TMDataGridTableValidateArgs, type TMDataGridTableValidators, type TMDataGridUiActions, type TMDataGridUiState, type TMDataGridUiStore, type UseTMDataGridOptions, aggregateColumn, areAllRowsExpanded, autosizeColumn, boundsCellCount, boundsEdges, buildCellMatrix, buildGridCellMatrix, clearedValueForType, createTMDataGridColumnHelper, downloadTextFile, emptyValueForOperator, exportGridToCsv, formatExportValue, formatFilterLabel, formatGroupValue, fuzzyGlobalFilterFn, getColumnCapabilities, getColumnDefaultOperator, getColumnFilterControl, getColumnLabel, getColumnRegion, getColumnType, getDefaultOperator, getDisplayedRows, getEditFieldName, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, isColumnEditableForRow, isColumnReorderable, isControlColumn, isFilterActive, isGeneratedColumn, isPagingActive, isSameCell, isWithinBounds, keepGeneratedColumnsOutermost, measureColumnContentWidth, mergeLabels, moveColumn, moveColumnByStep, normalizeFieldValidate, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, operatorTakesRangeValue, optionsToComboboxData, readFeatureFlags, resolveCellMove, resolveColumnOptions, resolveExpandAll, resolveRangeBounds, resolveRowSelectionClick, tmDataGridFeatures, toClipboardText, toExcelCsv, useCellControlTabIndex, useTMDataGrid, useTMDataGridContext, writeClipboardText };