@jielga/tmdatagrid 0.5.0 → 1.0.0

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import { Cell, Column, ColumnPinningState, ExpandedState, Row, RowData, RowSelectionState, Table, TableFeatures, TableOptions, TableState, aggregationFns } from "@tanstack/react-table";
-import { CSSProperties, ReactNode } from "react";
+import { CSSProperties, ComponentType, MouseEvent, MutableRefObject, ReactNode } from "react";
 import { MantineSize, MenuProps } from "@mantine/core";
 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
@@ -10,6 +12,24 @@ import { Store } from "@tanstack/store";
  */
 declare function TMDataGridColumnsPanel(): import("react").JSX.Element;
 //#endregion
+//#region .types-tmp/components/TMDataGridEditActions.d.ts
+/**
+ * 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 `editMode` — a
+ * cellConfirm grid accumulating drafts can offer the same pair — and renders
+ * nothing while editing is off.
+ *
+ * ```tsx
+ * <TMDataGrid.Toolbar>
+ *   <TMDataGrid.SummaryCount />
+ *   <TMDataGrid.Spacer />
+ *   <TMDataGrid.EditActions />
+ * </TMDataGrid.Toolbar>
+ * ```
+ */
+declare function TMDataGridEditActions(): import("react").JSX.Element | null;
+//#endregion
 //#region .types-tmp/components/TMDataGridFilterPanel.d.ts
 /**
  * The MUI-style filter surface: one row per active column filter, each row a
@@ -144,21 +164,27 @@ declare function optionsToComboboxData(options: ReadonlyArray<TMDataGridOption>)
  * `manualFiltering` table (just forward `columnFilters` to the API).
  *
  * `value` is a string array under `isAnyOf` / `isNoneOf` (the set the cell is
- * tested against) and a single string everywhere else — dates travel as ISO
- * `YYYY-MM-DD` strings, booleans as `"true"` / `"false"`. Still plain JSON.
+ * tested against), a `[min, max]` pair under `between` (an empty string means
+ * that end is open), and a single string everywhere else — dates travel as
+ * ISO `YYYY-MM-DD` strings, booleans as `"true"` / `"false"`. Still plain
+ * JSON.
  */
 type TMDataGridFilterValue = {
   operator: TMDataGridFilterOperator;
   value: string | ReadonlyArray<string>;
 };
 type TMDataGridColumnType = "string" | "number" | "boolean" | "date" | "select" | "multiSelect";
-type TMDataGridFilterOperator = "contains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "before" | "after" | "onOrBefore" | "onOrAfter" | "isAnyOf" | "isNoneOf" | "isEmpty" | "isNotEmpty";
+type TMDataGridFilterOperator = "contains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "between" | "before" | "after" | "onOrBefore" | "onOrAfter" | "isAnyOf" | "isNoneOf" | "isEmpty" | "isNotEmpty";
 declare const FILTER_OPERATOR_LABELS: Record<TMDataGridFilterOperator, string>;
 declare function getOperatorsForType(type: TMDataGridColumnType): readonly TMDataGridFilterOperator[];
 declare function getDefaultOperator(type: TMDataGridColumnType): TMDataGridFilterOperator;
 declare function operatorNeedsValue(operator: TMDataGridFilterOperator): boolean;
 /** Whether the operator's value is a string array — `isAnyOf` / `isNoneOf`. */
 declare function operatorTakesArrayValue(operator: TMDataGridFilterOperator): boolean;
+/** Whether the operator's value is a `[min, max]` pair — `between`. */
+declare function operatorTakesRangeValue(operator: TMDataGridFilterOperator): boolean;
+/** The untouched value a fresh filter starts with — the operator's shape, empty. */
+declare function emptyValueForOperator(operator: TMDataGridFilterOperator): string | ReadonlyArray<string>;
 /**
  * A filter only narrows the row set once it has something to compare against.
  * Half-typed filters stay in state (so the panel keeps rendering their row) but
@@ -186,6 +212,267 @@ declare function formatFilterLabel({ label, type, filter, operatorLabels }: {
  */
 declare function tmDataGridFilterFn<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown): boolean;
 //#endregion
+//#region .types-tmp/core/editEngine.d.ts
+/**
+ * How commits happen — one axis, each mode a thin policy over the same
+ * engine. See `editMode` on `UseTMDataGridOptions`.
+ */
+type TMDataGridEditMode = "cell" | "cellConfirm" | "row" | "batch";
+/**
+ * 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,
+ * errors, async validation, submit lifecycle — is form state, read off
+ * `form.store` with the same selector idiom as the rest of the grid.
+ *
+ * The alias erases Form's validator generics the way `TMDataGridRowData`
+ * erases the row type: the concrete types lived at the `useTMDataGrid` call.
+ */
+type TMDataGridRowEditForm = AnyFormApi;
+/** The live field a cell editor binds to — TanStack Form's own `FieldApi`. */
+type TMDataGridEditField = AnyFieldApi;
+/**
+ * A validator as TanStack Form takes it: a Standard Schema (Zod, Valibot,
+ * ArkType…) or a plain function returning an error or nothing. Forwarded
+ * untouched — the vocabulary is Form's, not a grid re-implementation.
+ */
+type TMDataGridValidator = StandardSchemaV1<unknown, unknown> | ((args: {
+  value: never;
+  fieldApi: never;
+}) => unknown);
+/**
+ * `meta.validate` — per-column field validators. A bare schema or function is
+ * shorthand for `{ onChange: it }`; the object form takes every trigger
+ * TanStack Form defines, `Async` variants and debounce included.
+ */
+type TMDataGridFieldValidate = TMDataGridValidator | {
+  onMount?: TMDataGridValidator;
+  onChange?: TMDataGridValidator;
+  onChangeAsync?: TMDataGridValidator;
+  onChangeAsyncDebounceMs?: number;
+  onBlur?: TMDataGridValidator;
+  onBlurAsync?: TMDataGridValidator;
+  onSubmit?: TMDataGridValidator;
+  onSubmitAsync?: TMDataGridValidator;
+};
+/**
+ * `rowValidators` — form-level validators for the whole row, where
+ * cross-field rules live. Passed into each row form's `validators` untouched;
+ * pathed issues land on the matching fields, pathless ones on the row.
+ */
+type TMDataGridRowValidators = {
+  onMount?: TMDataGridValidator;
+  onChange?: TMDataGridValidator;
+  onChangeAsync?: TMDataGridValidator;
+  onChangeAsyncDebounceMs?: number;
+  onBlur?: TMDataGridValidator;
+  onBlurAsync?: TMDataGridValidator;
+  onSubmit?: TMDataGridValidator;
+  onSubmitAsync?: TMDataGridValidator;
+  onSubmitAsyncDebounceMs?: number;
+};
+/** One field's before/after across a commit. */
+type TMDataGridEditChange = {
+  /** Column the field maps back to, for consumers thinking in columns. */
+  columnId: string;
+  /** The data path — `getEditFieldName` of the column. */
+  field: string;
+  previous: unknown;
+  next: unknown;
+};
+type TMDataGridEditCommitArgs<TData extends RowData> = {
+  rowId: string;
+  /** The whole row as edited — for the consumer who saves records. */
+  value: TData;
+  /** The row as it was when editing began. */
+  original: TData;
+  /** Per-field diff — for the consumer who PATCHes. One entry in cell mode. */
+  changes: Array<TMDataGridEditChange>;
+  /** Which policy committed. */
+  source: TMDataGridEditMode;
+};
+/** What one open row's form looks like from outside — the cell markers. */
+type TMDataGridEditRowProjection = {
+  /** Field names whose value differs from the original. */
+  dirtyFields: ReadonlyArray<string>;
+  /** Field names carrying a validation error. */
+  errorFields: ReadonlyArray<string>;
+  /** A row-level error — a pathless `.refine()`, or a rejected commit. */
+  hasRowError: boolean;
+  isSubmitting: boolean;
+};
+/**
+ * The grid-facing index of everything mid-edit. A projection synced from the
+ * open forms' stores, so body cells subscribe to this one store for their
+ * dirty/error markers instead of one store per form. Only the editor host
+ * reads a form's store directly — it is mounted for one cell at a time.
+ */
+type TMDataGridEditState = {
+  /** The cell whose editor is open; `columnId: null` is a whole row (row mode). */
+  active: {
+    rowId: string;
+    columnId: string | null;
+  } | null;
+  /** Rows with a live form. In cell mode at most one; in batch, many. */
+  openRowIds: ReadonlyArray<string>;
+  rows: Record<string, TMDataGridEditRowProjection>;
+  /** Phase 4 — rows being created, not yet in `data`. */
+  newRows: ReadonlyArray<{
+    tempId: string;
+  }>;
+  /** Phase 4 — rows marked deleted under batch mode. */
+  deletedRowIds: ReadonlyArray<string>;
+};
+type ErasedRow = Row<TMDataGridFeatures, TMDataGridRowData>;
+type ErasedColumn = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
+/**
+ * What a cell editor is handed — deliberately both vocabularies at once. The
+ * form side is TanStack Form's real `field` API (`field.state.value`,
+ * `field.state.meta.errors`, `field.handleChange`, `field.handleBlur`), so a
+ * custom calendar, slider or async combobox binds to it exactly as it would
+ * inside any TanStack Form. The table side is where the editor is standing.
+ *
+ * The built-ins are implemented against this same contract, so
+ * `meta.editor` is not a special case — it is the slot the defaults
+ * fill, and the exported built-ins can be wrapped instead of replaced.
+ */
+type TMDataGridEditorArgs = {
+  /** The live TanStack Form field for this cell. */
+  field: TMDataGridEditField;
+  /** The whole row form, for the rare editor that reads sibling fields. */
+  form: TMDataGridRowEditForm;
+  cell: Cell<TMDataGridFeatures, TMDataGridRowData, unknown>;
+  row: ErasedRow;
+  column: ErasedColumn;
+  table: TMDataGridTable<TMDataGridRowData>;
+  /** What Enter would do — commit the edit. For the editor's own UI. */
+  commit: () => Promise<boolean>;
+  /** What Escape would do — drop the draft. */
+  cancel: () => void;
+  size: TMDataGridSize;
+  /**
+   * Whether this editor should take the focus on mount. True for a single
+   * opened cell; in row mode only the row's first editable cell gets it.
+   */
+  autoFocus: boolean;
+  /**
+   * Set when typing opened the editor (the Sheets gesture) — the built-ins
+   * replace the value with it and keep typing. A custom editor may ignore it.
+   */
+  seedText?: string;
+};
+/**
+ * `meta.editor` — replaces the built-in editor for this column. Rendered as
+ * JSX, never invoked as a bare function, so hooks are legal inside. Define it
+ * at module scope: a new identity per render remounts the editor mid-edit.
+ */
+type TMDataGridEditorComponent = ComponentType<TMDataGridEditorArgs>;
+/** A new row being committed — `onRowAdd`, and `submitAll`'s `added`. */
+type TMDataGridRowAddArgs<TData extends RowData> = {
+  /** The engine's placeholder id; the real id is the consumer's to mint. */
+  tempId: string;
+  value: TData;
+};
+/** A deletion — `onRowDelete`. */
+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. */
+  rows: Array<TMDataGridEditCommitArgs<TData>>;
+  /** Every valid new row from the entry block. */
+  added: Array<TMDataGridRowAddArgs<TData>>;
+  /** Ids marked deleted while the batch accumulated. */
+  deleted: Array<string>;
+};
+/**
+ * The data path a column edits, or `null` for a column that has none.
+ *
+ * `accessorKey` is the true path and Form addresses fields by dot-path, so
+ * nested rows work for free: `accessorKey: "address.city"` edits
+ * `values.address.city`. A column built on `accessorFn` has no path and is
+ * not editable unless `meta.editField` names one. TanStack's default column
+ * id turns dots into underscores — which is why this starts from
+ * `accessorKey`, never from `id`.
+ */
+declare function getEditFieldName(column: {
+  columnDef: {
+    meta?: {
+      editField?: string;
+    };
+  };
+}): string | null;
+/** What Delete writes into a cell — the type's honest empty value. */
+declare function clearedValueForType(type: TMDataGridColumnType): unknown;
+/**
+ * The engine plus its store — `api.edit`.
+ *
+ * "One row, one form": `getForm` hands out the same `FormApi` the inline
+ * editors write through, so a consumer can render it in a drawer or a detail
+ * panel and share values, dirty state and errors with the cells.
+ */
+type TMDataGridEditApi = {
+  /** 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;
+  /**
+   * Whether this cell may open an editor: the column maps to a field, nothing
+   * switched it off, and the row takes edits at all.
+   */
+  canEditCell: (row: ErasedRow, column: ErasedColumn) => boolean;
+  /** Whether the row takes edits at all — the edit lane's pencil gate. */
+  canEditRow: (row: ErasedRow) => boolean;
+  /** Opens an editor. `columnId: null` opens the whole row (row mode). */
+  begin: (target: {
+    rowId: string;
+    columnId: string | null;
+  }) => void;
+  /**
+   * Commits one row — `form.handleSubmit` under the hood. Resolves `true`
+   * when the form is gone: validation passed and `onEditCommit` resolved, or
+   * there was nothing to save. `false` keeps the form open with its errors.
+   */
+  commit: (rowId: string) => Promise<boolean>;
+  /** Drops one row's draft. */
+  cancel: (rowId: string) => void;
+  /**
+   * Closes the editor without touching the draft — what blur does under
+   * `"cellConfirm"`, where the dirty cell keeps waiting for its ✓.
+   */
+  deactivate: () => void;
+  /** Drops every draft. */
+  cancelAll: () => void;
+  /** Commits every open row — batch mode's save. `true` when all landed. */
+  submitAll: () => Promise<boolean>;
+  /** Writes the type's empty value into a cell and commits it — Delete. */
+  clearCell: (rowId: string, columnId: string) => 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).
+   */
+  addRow: () => 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.
+   */
+  deleteRow: (rowId: string) => void;
+  /** Whether delete chrome makes sense — the lane's trash gate. */
+  canDeleteRows: () => boolean;
+};
+/**
+ * `meta.validate` normalised to the object TanStack Form's `validators`
+ * option takes — a bare schema or function is shorthand for `{ onChange }`.
+ */
+declare function normalizeFieldValidate(validate: TMDataGridFieldValidate | undefined): Record<string, unknown> | undefined;
+//#endregion
 //#region .types-tmp/core/labels.d.ts
 /**
  * Every user-facing string in the grid — menu items, panels, tooltips, the
@@ -210,10 +497,25 @@ type TMDataGridLabels = {
   columnsNoMatch: (search: string) => string;
   columnsShowHideAll: string;
   columnsReset: string;
+  /** Tooltip on the reset button, stating everything the reset covers. */
+  columnsResetHint: string;
+  /** Menu/panel name of the generated row-number gutter. */
+  rowNumberColumnLabel: string;
+  /**
+   * The truly-empty message — no data and no filters. Filtered-empty says
+   * {@link noResults} instead; only one of the two is the user's own doing.
+   */
+  noRows: string;
   filterColumn: string;
   filterOperator: string;
   filterValue: string;
   filterValuePlaceholder: string;
+  /** The lower bound of a `between` filter. */
+  filterFrom: string;
+  /** The upper bound of a `between` filter. */
+  filterTo: string;
+  /** `DgTriStateFilter`'s no-filter segment. */
+  filterAll: string;
   /** What a boolean column's `true` reads as — its filter choice and cell text. */
   booleanTrue: string;
   booleanFalse: string;
@@ -252,6 +554,34 @@ type TMDataGridLabels = {
   nextPage: string;
   noResults: string;
   loading: string;
+  /** `aria-label` of an open cell editor's input. */
+  editCell: (column: string) => string;
+  /** cellConfirm's ✓ beside the input. */
+  confirmEdit: string;
+  /** cellConfirm's ✕ beside the input. */
+  cancelEdit: string;
+  /** The generated edit lane's name in the column manager. */
+  editColumnLabel: string;
+  /** The lane's pencil. */
+  editRow: string;
+  /** The lane's ✓ while a row edit is open. */
+  saveRow: string;
+  /** The lane's ✕ while a row edit is open. */
+  cancelRowEdit: string;
+  /** Save tooltip when field errors block the row, with no row message. */
+  editRowErrors: string;
+  /** `EditActions`' Save, with the dirty-row count. */
+  saveAllEdits: (rows: number) => string;
+  /** `EditActions`' Discard. */
+  discardAllEdits: 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). */
+  restoreRow: string;
   cellCount: (count: number) => string;
   copy: string;
   exportCsv: string;
@@ -282,6 +612,61 @@ declare const TMDATAGRID_LABELS_EN: TMDataGridLabels;
 /** A partial override folded over the English defaults. */
 declare function mergeLabels(override?: TMDataGridLabelsOverride): TMDataGridLabels;
 //#endregion
+//#region .types-tmp/core/filterControls.d.ts
+/**
+ * What a filter control is handed — the value slot of one filter-panel row.
+ *
+ * The contract is value-only: the control reads `operator` to shape itself
+ * (a `between` pair renders two ends, an `equals` a single input) and calls
+ * `onChange` with the bare value; the grid composes the operator-aware
+ * `TMDataGridFilterValue` around it. A control never builds that wrapper and
+ * never writes the operator — `table` is the escape hatch for the rare
+ * control that must.
+ */
+type TMDataGridFilterControlArgs = {
+  column: Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
+  table: TMDataGridTable<TMDataGridRowData>;
+  /** The row's currently selected operator. Read-only for the control. */
+  operator: TMDataGridFilterOperator;
+  /** The bare filter value — never the `{ operator, value }` wrapper. */
+  value: string | ReadonlyArray<string>;
+  /** Writes the bare value; the grid pairs it with the current operator. */
+  onChange: (next: string | ReadonlyArray<string>) => void;
+  /**
+   * The column's options through `resolveColumnOptions`, pre-resolved for a
+   * column that declares `meta.options` or is select-shaped. Empty otherwise —
+   * a control wanting faceted values on other columns resolves them itself.
+   */
+  options: ReadonlyArray<TMDataGridOption>;
+  size: TMDataGridSize;
+  labels: TMDataGridLabels;
+};
+/**
+ * `meta.filterControl` — replaces the built-in value control for this column.
+ * Rendered as JSX, never invoked as a bare function, so hooks are legal
+ * inside. Define it at module scope so its identity is stable across renders.
+ */
+type TMDataGridFilterControlComponent = ComponentType<TMDataGridFilterControlArgs>;
+//#endregion
+//#region .types-tmp/core/quickSearch.d.ts
+/** How the quick search matches — see `quickSearchMode` on the hook options. */
+type TMDataGridQuickSearchMode = "fuzzy" | "contains";
+/** What {@link fuzzyGlobalFilterFn} records per column via `addMeta`. */
+type FuzzyFilterMeta = {
+  fuzzyRank: RankingInfo;
+};
+/**
+ * Match-sorter ranking as the global filter: a row passes when a globally
+ * filterable column ranks above match-sorter's threshold — typos and skipped
+ * characters forgiven — and the rank is recorded for the ordering to read.
+ *
+ * TanStack stops probing a row's columns at the first passing one, so the
+ * recorded ranks cover the columns up to and including it; the best of those
+ * stands for the row. Good enough for a quick search: the first passing
+ * column is almost always the one the user is looking at.
+ */
+declare function fuzzyGlobalFilterFn<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown, addMeta?: (meta: FuzzyFilterMeta) => void): boolean;
+//#endregion
 //#region .types-tmp/core/persistence.d.ts
 type GridState = TableState<TMDataGridFeatures>;
 /**
@@ -332,6 +717,15 @@ type TMDataGridPersistence = {
   /** Parses a stored payload. Defaults to `JSON.parse`. */
   deserialize?: (value: string) => unknown;
 };
+/**
+ * Version stamped into every stored payload, under a key no state slice can
+ * collide with. A payload whose version does not match is dropped whole: a
+ * migration would be guessing at a shape this code no longer knows, and the
+ * cost of dropping is one lost layout. Payloads written before versioning
+ * existed (≤0.4.0) have no stamp and are dropped the same way — the 1.0
+ * wave's one-time break, named in its changeset.
+ */
+declare const PERSIST_PAYLOAD_VERSION = 1;
 //#endregion
 //#region .types-tmp/core/capabilities.d.ts
 /**
@@ -442,8 +836,27 @@ type TMDataGridFeatureFlags = {
    * its own grouping can still say `enableGrouping: true` to override.
    */
   grouping: boolean;
+  /** Whether cells can be edited at all — `editMode` was set. */
+  editing: boolean;
+  /** The commit policy, or `null` while editing is off. */
+  editMode: TMDataGridEditMode | null;
+  /** The generated row-number gutter — `enableRowNumbers`. Off by default. */
+  rowNumbers: boolean;
+  /**
+   * Whether rows can be pinned to the top or bottom edge — `enableRowPinning`,
+   * boolean or per-row predicate. Off by default: pinning has no built-in
+   * gesture, so a grid that never calls `row.pin()` has nothing to gain from
+   * the body watching the state.
+   */
+  rowPinning: boolean;
+  /**
+   * Whether cells highlight the matched text while a contains-family filter
+   * or the quick search is active — `enableMatchHighlighting`. Off by
+   * default, so a grid that has not asked pays nothing per cell.
+   */
+  matchHighlighting: boolean;
 };
-declare function readFeatureFlags<TData extends RowData>(options: Pick<UseTMDataGridOptions<TData>, "enableSorting" | "enableColumnFilters" | "enableGlobalFilter" | "enableHiding" | "enableColumnPinning" | "enableColumnResizing" | "enableColumnOrdering" | "enableRowSelection" | "enableMultiRowSelection" | "selectionMode" | "showSelectedBackground" | "cellSelection" | "enablePagination" | "manualPagination" | "enableGrouping">): TMDataGridFeatureFlags;
+declare function readFeatureFlags<TData extends RowData>(options: Pick<UseTMDataGridOptions<TData>, "enableSorting" | "enableColumnFilters" | "enableGlobalFilter" | "enableHiding" | "enableColumnPinning" | "enableColumnResizing" | "enableColumnOrdering" | "enableRowSelection" | "enableMultiRowSelection" | "selectionMode" | "showSelectedBackground" | "cellSelection" | "enablePagination" | "manualPagination" | "enableGrouping" | "editMode" | "enableRowNumbers" | "enableRowPinning" | "enableMatchHighlighting">): TMDataGridFeatureFlags;
 /**
  * What one column's header may offer.
  *
@@ -628,6 +1041,51 @@ type TMDataGridColumnMeta = {
    * so its switch lives here rather than on the column definition.
    */
   enableOrdering?: boolean;
+  /**
+   * The operator a fresh filter on this column starts with, instead of the
+   * type's default — a salary column can open on `"between"`. Must be one of
+   * the type's own operators.
+   */
+  defaultFilterOperator?: TMDataGridFilterOperator;
+  /**
+   * Replaces the built-in value control in this column's filter-panel row. A
+   * component rendered as JSX — hooks are legal inside — receiving the
+   * value-only contract: it reads the current operator, writes the bare
+   * value, and the grid composes the stored filter around it. Define it at
+   * module scope. See {@link TMDataGridFilterControlArgs}.
+   */
+  filterControl?: TMDataGridFilterControlComponent;
+  /**
+   * Whether this column's cells take edits, once `editMode` is on. `false`
+   * switches the column off outright; a predicate decides per row. Defaults
+   * to editable for any column that maps to a field — see {@link editField}.
+   */
+  editable?: boolean | ((row: Row<TMDataGridFeatures, TMDataGridRowData>) => boolean);
+  /**
+   * The data path this column edits, when it is not the `accessorKey` — the
+   * only way a column built on `accessorFn` becomes editable. Dot paths reach
+   * into nested records: `"address.city"`.
+   */
+  editField?: string;
+  /**
+   * Field-level validators, in TanStack Form's own vocabulary. A bare Zod
+   * schema (or any Standard Schema, or a plain function) means
+   * `{ onChange: it }`; the object form takes every trigger Form defines.
+   *
+   * ```tsx
+   * meta: { validate: z.string().min(2, "Too short") }
+   * meta: { validate: { onBlur: z.string().email() } }
+   * ```
+   */
+  validate?: TMDataGridFieldValidate;
+  /**
+   * Replaces the built-in editor for this column. A component rendered as
+   * JSX — hooks are legal inside — receiving the live TanStack Form `field`
+   * API plus the table context, the same contract the built-ins fill. Define
+   * it at module scope so its identity is stable across renders. See
+   * {@link TMDataGridEditorArgs}.
+   */
+  editor?: TMDataGridEditorComponent;
 };
 /** Grid-wide configuration passed through `options.meta`. */
 type TMDataGridTableMeta = {
@@ -659,6 +1117,7 @@ declare const tmDataGridFeatures: {
   columnFacetingFeature: import("@tanstack/table-core").TableFeature;
   columnGroupingFeature: import("@tanstack/table-core").TableFeature;
   rowExpandingFeature: import("@tanstack/table-core").TableFeature;
+  rowPinningFeature: import("@tanstack/table-core").TableFeature;
   filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   groupedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
@@ -704,6 +1163,7 @@ declare const tmDataGridFeatures: {
       autoRemove: (val: any) => boolean;
     };
     tmDataGrid: typeof tmDataGridFilterFn;
+    tmDataGridFuzzy: typeof fuzzyGlobalFilterFn;
   };
   sortFns: {
     alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
@@ -743,6 +1203,7 @@ declare function createTMDataGridColumnHelper<TData extends RowData>(): import("
   columnFacetingFeature: import("@tanstack/table-core").TableFeature;
   columnGroupingFeature: import("@tanstack/table-core").TableFeature;
   rowExpandingFeature: import("@tanstack/table-core").TableFeature;
+  rowPinningFeature: import("@tanstack/table-core").TableFeature;
   filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   groupedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
@@ -788,6 +1249,7 @@ declare function createTMDataGridColumnHelper<TData extends RowData>(): import("
       autoRemove: (val: any) => boolean;
     };
     tmDataGrid: typeof tmDataGridFilterFn;
+    tmDataGridFuzzy: typeof fuzzyGlobalFilterFn;
   };
   sortFns: {
     alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => number;
@@ -895,10 +1357,27 @@ type TMDataGridUiActions = {
   setCellRange: (range: TMDataGridCellRange | null) => void;
 };
 type TMDataGridUiStore = Store<TMDataGridUiState, TMDataGridUiActions>;
+/** Where a scrolled-to row lands in the viewport. TanStack's own alignments. */
+type TMDataGridScrollAlign = "auto" | "start" | "center" | "end";
+type TMDataGridScrollToRowArgs = {
+  /** The row's id, as `getRowId` produced it. */
+  rowId: string;
+  /** Defaults to `"auto"` — the nearest edge, leaving a visible row alone. */
+  align?: TMDataGridScrollAlign;
+};
+/** @internal The body's scroll implementation. See `scrollToRow`. */
+type TMDataGridScroller = (args: TMDataGridScrollToRowArgs) => boolean;
 /** What `useTMDataGrid` returns — spread straight onto `<TMDataGrid />`. */
 type TMDataGridApi<TData extends RowData> = {
   table: TMDataGridTable<TData>;
   ui: TMDataGridUiStore;
+  /**
+   * The edit engine — open forms, dirty/error projections, and the verbs
+   * (`begin`, `commit`, `cancel`, `submitAll`). `edit.getForm(rowId)` hands
+   * out the same TanStack Form the inline editors write through, so a drawer
+   * or detail panel can share a row's draft. Inert until `editMode` is set.
+   */
+  edit: TMDataGridEditApi;
   /** Table-level feature switches, re-read from options on every render. */
   features: TMDataGridFeatureFlags;
   /** Every string the chrome renders, `labels` merged over the English defaults. */
@@ -909,8 +1388,144 @@ type TMDataGridApi<TData extends RowData> = {
   renderDetailsEstHeight: number;
   /** Virtualizer overscan: the option, or {@link DEFAULT_OVERSCAN}. */
   overscan: number;
+  /**
+   * Puts the settings state — visibility, order, widths, pinning, grouping —
+   * back to what a first visit with clean storage would have shown: the
+   * consumer's `initialState` plus the structural lanes. With persistence
+   * configured the reset writes through to storage like any other change.
+   *
+   * This, not TanStack's `resetColumnX()` family, is the reset for a
+   * persisted grid: those reset to `initialState`, and the grid bakes the
+   * restored payload into `initialState` at mount — they would "reset" to
+   * the very layout being discarded.
+   */
+  resetSettings: () => void;
+  /**
+   * Scrolls a row into view. The grid is always virtualized, so a row far down
+   * the list has no element to scroll to — this moves the virtualizer instead,
+   * which is the only thing that can put one there.
+   *
+   * ```ts
+   * grid.scrollToRow({ rowId: "42", align: "center" });
+   * ```
+   *
+   * Answers whether the row could be reached. `false` means it is not in the
+   * current view at all — filtered out, on another page, or an id that matches
+   * no row — and nothing scrolled. A pinned row answers `true` without
+   * scrolling: it is already parked at an edge.
+   *
+   * Identity is stable, so it is safe in a dependency array.
+   */
+  scrollToRow: (args: TMDataGridScrollToRowArgs) => boolean;
+  /**
+   * @internal Wiring for `TMDataGrid.Table`, which owns the virtualizer and
+   * fills this in. Not part of the supported surface.
+   */
+  scrollerRef: MutableRefObject<TMDataGridScroller>;
 };
-type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridFeatures, TData>, "features"> & {
+/** The editing callbacks every mode shares. See {@link TMDataGridEditingOptions}. */
+type TMDataGridEditingCallbacks<TData extends RowData> = {
+  /**
+   * `getRowId` stops being optional once editing is on: the forms are keyed
+   * by row id and live outside the DOM, and the index fallback points at a
+   * different record after any sort.
+   */
+  getRowId: NonNullable<TableOptions<TMDataGridFeatures, TData>["getRowId"]>;
+  /**
+   * Form-level validators for the whole editing row — where cross-field
+   * rules live. TanStack Form's own vocabulary, Standard Schema included:
+   *
+   * ```tsx
+   * rowValidators: {
+   *   onSubmit: z.object({ salary: z.number().positive() })
+   *     .refine((r) => r.status !== "Terminated" || r.salary === 0, {
+   *       message: "A terminated employee has no salary",
+   *     }),
+   * }
+   * ```
+   *
+   * Pathed issues land on the matching columns; pathless ones on the row.
+   */
+  rowValidators?: TMDataGridRowValidators;
+  /** Rows the pencil skips — `false` keeps a row read-only in every mode. */
+  isRowEditable?: (row: Row<TMDataGridFeatures, TData>) => boolean;
+  /**
+   * Called when an edit commits. The grid never mutates `data`: apply the
+   * change and let the new data arrive back through `data` as always. The
+   * engine drops the draft only when this resolves — a slow save keeps the
+   * draft visible with a busy marker — and a rejection keeps the form open
+   * with the error on the row.
+   *
+   * `changes` is the per-field diff (one entry in cell mode) for consumers
+   * who PATCH; `value` is the whole edited row for those who save records.
+   */
+  onEditCommit?: (args: TMDataGridEditCommitArgs<TData>) => void | Promise<void>;
+  /**
+   * Seed values for `edit.addRow()` — the entry row's starting point. A
+   * function is called per added row (fresh timestamps, empty arrays).
+   */
+  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.
+   */
+  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.
+   */
+  onRowDelete?: (args: TMDataGridRowDeleteArgs<TData>) => void | Promise<void>;
+};
+/**
+ * The editing options travel together, and the type states it: without
+ * `editMode` none of them has anything to act on, so passing one is a
+ * compile error rather than a dead option; with it, `getRowId` becomes
+ * required; and `onEditCommitBatch` exists only under `"batch"` — the one
+ * mode whose `submitAll` calls it.
+ *
+ * `editMode` itself turns cell editing on and picks how commits happen. Off
+ * by default.
+ *
+ * | 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()` |
+ *
+ * One TanStack Form per editing row; drafts survive scrolling because the
+ * forms live outside the DOM, keyed by row id. Which columns edit, and with
+ * what, is declared per column: `meta.type` picks the built-in editor,
+ * `meta.validate` its validators, `meta.editable` / `meta.editor` the
+ * overrides.
+ */
+type TMDataGridEditingOptions<TData extends RowData> = (TMDataGridEditingCallbacks<TData> & {
+  editMode: "batch";
+  /**
+   * 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.onEditCommit} loop. Rows failing
+   * validation stay open either way; a rejection keeps every draft.
+   */
+  onEditCommitBatch?: (args: TMDataGridEditCommitBatchArgs<TData>) => void | Promise<void>;
+}) | (TMDataGridEditingCallbacks<TData> & {
+  editMode: Exclude<TMDataGridEditMode, "batch">;
+  /** Only `"batch"`'s `submitAll` ever calls it — see the other branch. */
+  onEditCommitBatch?: never;
+}) | {
+  editMode?: never;
+  rowValidators?: never;
+  isRowEditable?: never;
+  onEditCommit?: never;
+  onEditCommitBatch?: never;
+  newRowDefaults?: never;
+  onRowAdd?: never;
+  onRowDelete?: never;
+};
+type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridFeatures, TData>, "features"> & TMDataGridEditingOptions<TData> & {
   /**
    * Restore and persist table state across mounts. Two keys, because the two
    * kinds of state have different lifetimes — see {@link TMDataGridPersistence}.
@@ -952,6 +1567,28 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
    * no extra flag.
    */
   enablePagination?: boolean;
+  /**
+   * The row-number gutter: a generated lane, outermost left, numbering the
+   * rows of the current view — sorted, filtered, continuing across pages,
+   * with group rows unnumbered. Off by default.
+   */
+  enableRowNumbers?: boolean;
+  /**
+   * How the quick search (`TMDataGrid.Search`) matches. `"fuzzy"` — the
+   * default — forgives typos and skipped characters, and while it is the
+   * only thing narrowing the grid (no sort, no grouping) the rows order by
+   * match quality, best first. `"contains"` is plain substring matching.
+   * An explicit `globalFilterFn` overrides both.
+   */
+  quickSearchMode?: TMDataGridQuickSearchMode;
+  /**
+   * Highlights the matched text in cells while a contains-family column
+   * filter or the quick search is active. Default-rendered cells only — a
+   * column with its own `cell` renderer opts out by existing; a fuzzy
+   * typo-match with no contiguous occurrence shows no highlight. Off by
+   * default.
+   */
+  enableMatchHighlighting?: boolean;
   /**
    * How rows are selected. Defaults to `"checkbox"`.
    *
@@ -1134,7 +1771,7 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
  * flag on, so `<TMDataGrid.Footer />` renders its pager without further
  * options.
  */
-declare function useTMDataGrid<TData extends RowData>({ persist, labels: labelsOverride, enableColumnOrdering, enablePagination, selectionMode, showSelectedBackground, defaultHighlightedRowId, onHighlightedRowChange, cellSelection, onFocusedCellChange, renderDetails, renderDetailsEstHeight, overscan, ...options }: UseTMDataGridOptions<TData>): TMDataGridApi<TData>;
+declare function useTMDataGrid<TData extends RowData>({ persist, labels: labelsOverride, enableColumnOrdering, enablePagination, enableRowNumbers, selectionMode, showSelectedBackground, defaultHighlightedRowId, onHighlightedRowChange, cellSelection, onFocusedCellChange, editMode, rowValidators, isRowEditable, onEditCommit, onEditCommitBatch, newRowDefaults, onRowAdd, onRowDelete, renderDetails, renderDetailsEstHeight, overscan, ...options }: UseTMDataGridOptions<TData>): TMDataGridApi<TData>;
 /**
  * Opens the filter panel for a column, seeding an empty filter row when the
  * column has none yet — mirrors "Filter" in the column header menu.
@@ -1443,12 +2080,93 @@ type TMDataGridRowContextMenuArgs<TData extends RowData> = {
  * its `Menu.Dropdown`; this fills the dropdown.
  */
 type TMDataGridRowContextMenu<TData extends RowData> = (args: TMDataGridRowContextMenuArgs<TData>) => ReactNode;
+/**
+ * What the `onCellClick` family receives — the cell with its row and column,
+ * in the consumer's own row type, plus the pointer event.
+ */
+type TMDataGridCellEventArgs<TData extends RowData> = {
+  cell: Cell<TMDataGridFeatures, TData, unknown>;
+  row: Row<TMDataGridFeatures, TData>;
+  column: Column<TMDataGridFeatures, TData, unknown>;
+  event: MouseEvent<HTMLElement>;
+};
+/**
+ * Inline styles for a row. Widened to accept CSS variables, because setting
+ * `--row-bg` is the supported way to colour a row — see {@link
+ * TMDataGridTableProps.rowStyle}.
+ */
+type TMDataGridRowStyle = CSSProperties | (CSSProperties & Record<`--${string}`, string | number>);
 type TMDataGridTableProps<TData extends RowData> = {
   /**
    * Called when a body row is clicked. Runs in addition to row selection under
    * `selectionMode: "row"`, not instead of it.
    */
   onRowClick?: (row: Row<TMDataGridFeatures, TData>) => void;
+  /**
+   * Called when a body cell is clicked. Composes, never suppresses: whatever
+   * the click already does — selecting, highlighting, moving the cell cursor
+   * — still happens. Group rows sit out the cell handlers the way they sit
+   * out `onRowClick`, and for the same reason.
+   */
+  onCellClick?: (args: TMDataGridCellEventArgs<TData>) => void;
+  /** As {@link onCellClick}; a double-click that opens an editor still does. */
+  onCellDoubleClick?: (args: TMDataGridCellEventArgs<TData>) => void;
+  /**
+   * As {@link onCellClick}; `rowContextMenu` and the cell-selection menu still
+   * open. To suppress the browser's own menu on a grid with neither, call
+   * `event.preventDefault()` here.
+   */
+  onCellContextMenu?: (args: TMDataGridCellEventArgs<TData>) => void;
+  /**
+   * Class for a body row — a string, or a function of the row (group rows
+   * included; test `row.getIsGrouped()` to skip them). Added after the grid's
+   * own row class.
+   */
+  rowClassName?: string | ((row: Row<TMDataGridFeatures, TData>) => string | undefined);
+  /**
+   * Inline style for a body row. To colour a row, set `--row-bg` rather than
+   * `background`: the row's own background, its sticky pinned cells and the
+   * cell-range tint all read that variable, and hover/selection/highlight
+   * keep working on top of it — a raw `background` bypasses all of them.
+   *
+   * ```tsx
+   * rowStyle={(row) =>
+   *   row.original.overdue ? { "--row-bg": "var(--mantine-color-red-0)" } : undefined
+   * }
+   * ```
+   */
+  rowStyle?: TMDataGridRowStyle | ((row: Row<TMDataGridFeatures, TData>) => TMDataGridRowStyle | undefined);
+  /**
+   * Every second row takes `--dg-row-striped-bg`. Computed from the row's
+   * position in the view — sorting and filtering restripe, and the stripes
+   * stay put while the virtualizer mounts and unmounts rows.
+   */
+  striped?: boolean;
+  /**
+   * Called when the scroll *arrives* at an edge — once per arrival, not per
+   * scroll event, and not on mount (the grid starts at the top-left edge).
+   * For loading more rows as the end approaches, `onReachEnd` is the better
+   * hook: it fires rows-early and latches per row count.
+   */
+  onScrollToTop?: () => void;
+  /** As {@link onScrollToTop}, for the bottom edge. */
+  onScrollToBottom?: () => void;
+  /** As {@link onScrollToTop}, for the left edge. */
+  onScrollToLeft?: () => void;
+  /** As {@link onScrollToTop}, for the right edge. */
+  onScrollToRight?: () => void;
+  /**
+   * Rendered centred in the body when the view is empty — the branded blank
+   * slate. It takes over states 3 and 4 of the empty matrix (see the docs):
+   * loading still shows the loader, and open entry rows still show only
+   * themselves. `hasActiveFilters` says which emptiness this is — a filter
+   * that matched nothing wants a "clear filters" invitation, a grid with no
+   * data wants a "create the first one".
+   */
+  renderEmptyState?: (args: {
+    hasActiveFilters: boolean;
+    table: Table<TMDataGridFeatures, TData>;
+  }) => ReactNode;
   /**
    * Contents of the menu a right-click on a row opens, at the pointer. Return
    * `null` to leave a row without one — the browser's own menu stays suppressed
@@ -1503,6 +2221,14 @@ type TMDataGridTableProps<TData extends RowData> = {
    * How many rows before the end {@link onReachEnd} fires at. Defaults to 10.
    */
   reachEndThreshold?: number;
+  /**
+   * Accessible name for the grid — what a screen reader announces on entry,
+   * and what `getByRole("grid", { name })` matches. Worth setting on any page
+   * holding more than one grid; without it they are all just "grid".
+   */
+  "aria-label"?: string;
+  /** As {@link "aria-label"}, pointing at an element that already names it. */
+  "aria-labelledby"?: string;
 };
 /**
  * The scrollable grid surface. Always virtualized: only the rows inside the
@@ -1510,7 +2236,7 @@ type TMDataGridTableProps<TData extends RowData> = {
  * no-pagination mode viable at any row count. Pagination is opt-in via
  * `enablePagination` (or implied by `manualPagination`).
  */
-declare function TMDataGridTable$1<TData extends RowData = TMDataGridRowData>({ onRowClick, rowContextMenu, rowContextMenuProps, cellExport, onReachEnd, reachEndThreshold }: TMDataGridTableProps<TData>): import("react").JSX.Element;
+declare function TMDataGridTable$1<TData extends RowData = TMDataGridRowData>({ onRowClick, onCellClick, onCellDoubleClick, onCellContextMenu, rowClassName, rowStyle, striped, onScrollToTop, onScrollToBottom, onScrollToLeft, onScrollToRight, renderEmptyState, rowContextMenu, rowContextMenuProps, cellExport, onReachEnd, reachEndThreshold, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy }: TMDataGridTableProps<TData>): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/TMDataGridToolbar.d.ts
 /** Row above the grid. Compose it from the pieces below, or anything else. */
@@ -1570,6 +2296,20 @@ type TMDataGridProps<TData extends RowData> = TMDataGridApi<TData> & {
    * background. Plain `CSSProperties` rejects `--*` keys.
    */
   style?: CSSProperties & Record<`--${string}`, string | number>;
+  /** Set on the root element. */
+  id?: string;
+  /**
+   * Names this grid for tests. The grid names its own pieces with
+   * `data-dg-part` rather than minting test ids, and those repeat across
+   * grids — scope through this one and they stop colliding:
+   *
+   * ```ts
+   * page.getByTestId("orders").locator('[data-dg-part="row"][data-row-id="42"]')
+   * ```
+   *
+   * See the Testing docs page for the full attribute contract.
+   */
+  "data-testid"?: string;
 };
 /**
  * Root of the grid. Takes the object returned by `useTMDataGrid` — spread it —
@@ -1589,13 +2329,14 @@ type TMDataGridProps<TData extends RowData> = TMDataGridApi<TData> & {
  * </TMDataGrid>
  * ```
  */
-declare function TMDataGridRoot<TData extends RowData>({ table, ui, features, labels, renderDetails, renderDetailsEstHeight, overscan, size, children, className, style }: TMDataGridProps<TData>): import("react").JSX.Element;
+declare function TMDataGridRoot<TData extends RowData>({ table, ui, edit, features, labels, renderDetails, renderDetailsEstHeight, overscan, resetSettings, scrollToRow, scrollerRef, size, children, className, style, id, "data-testid": testId }: TMDataGridProps<TData>): import("react").JSX.Element;
 declare const TMDataGrid: typeof TMDataGridRoot & {
   Toolbar: typeof TMDataGridToolbar;
   Spacer: typeof TMDataGridToolbarSpacer;
   SummaryCount: typeof TMDataGridSummaryCount;
   LoadingIndicator: typeof TMDataGridLoadingIndicator;
   Search: typeof TMDataGridSearch;
+  EditActions: typeof TMDataGridEditActions;
   ColumnsButton: typeof TMDataGridColumnsButton;
   FilterButton: typeof TMDataGridFilterButton;
   Table: typeof TMDataGridTable$1;
@@ -1617,6 +2358,12 @@ declare const SELECT_COLUMN_ID = "__select__";
 //#region .types-tmp/components/TMDataGridDetailsColumn.d.ts
 declare const DETAILS_COLUMN_ID = "__details__";
 //#endregion
+//#region .types-tmp/components/TMDataGridEditColumn.d.ts
+declare const EDIT_COLUMN_ID = "__edit__";
+//#endregion
+//#region .types-tmp/components/TMDataGridRowNumberColumn.d.ts
+declare const ROW_NUMBER_COLUMN_ID = "__rowNumber__";
+//#endregion
 //#region .types-tmp/components/TMDataGridGroupColumn.d.ts
 declare const GROUP_COLUMN_ID = "__group__";
 /**
@@ -1628,6 +2375,91 @@ declare const GROUP_COLUMN_ID = "__group__";
  */
 declare function formatGroupValue(value: unknown, blankLabel?: string): string;
 //#endregion
+//#region .types-tmp/components/filters/TMDataGridFilterValueInput.d.ts
+/**
+ * The built-in value control of a filter-panel row — what renders when a
+ * column declares no `meta.filterControl`. Shaped by the operator: a
+ * multi-select for the set operators, a From/To pair for `between`, a Yes/No
+ * dropdown for booleans, a typed input otherwise.
+ *
+ * Exported so a custom control can fall back to it for the operators it does
+ * not care about, instead of rebuilding them.
+ */
+declare function TMDataGridFilterValueInput({ column, operator, value, onChange, options, size, labels }: TMDataGridFilterControlArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/filters/DgRangeSliderFilter.d.ts
+/**
+ * A built-in `meta.filterControl` for `number` columns: a range slider whose
+ * bounds are seeded from the values present in the data, writing the
+ * `between` pair. Pair it with `meta.defaultFilterOperator: "between"` so
+ * the filter opens on it; any non-range operator falls back to the standard
+ * input.
+ */
+declare function DgRangeSliderFilter(args: TMDataGridFilterControlArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/filters/DgDateRangeFilter.d.ts
+/**
+ * A built-in `meta.filterControl` for `date` columns: a From/To pair of
+ * native date inputs writing the `between` pair — no `@mantine/dates`
+ * involved, like the built-in date editor. Pair it with
+ * `meta.defaultFilterOperator: "between"`; any non-range operator falls back
+ * to the standard input.
+ */
+declare function DgDateRangeFilter(args: TMDataGridFilterControlArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/filters/DgAutocompleteFilter.d.ts
+/**
+ * A built-in `meta.filterControl` for text-shaped columns: a free-text input
+ * that also offers the values present in the data (or the column's declared
+ * `meta.options`) as suggestions. Set or range operators fall back to the
+ * standard input.
+ */
+declare function DgAutocompleteFilter(args: TMDataGridFilterControlArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/filters/DgTriStateFilter.d.ts
+/**
+ * A built-in `meta.filterControl` for `boolean` columns: an All / Yes / No
+ * segmented control — All clears the value, which deactivates the filter.
+ * Set or range operators fall back to the standard input.
+ */
+declare function DgTriStateFilter(args: TMDataGridFilterControlArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/editors/TMDataGridStringEditor.d.ts
+/** The built-in editor for `meta.type: "string"` (and the default). */
+declare function TMDataGridStringEditor({ field, autoFocus, column, size }: TMDataGridEditorArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/editors/TMDataGridNumberEditor.d.ts
+/** The built-in editor for `meta.type: "number"`. */
+declare function TMDataGridNumberEditor({ field, autoFocus, column, size }: TMDataGridEditorArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/editors/TMDataGridBooleanEditor.d.ts
+/** The built-in editor for `meta.type: "boolean"` — a focused checkbox. */
+declare function TMDataGridBooleanEditor({ field, autoFocus, column, size }: TMDataGridEditorArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/editors/TMDataGridDateEditor.d.ts
+/**
+ * The built-in editor for `meta.type: "date"` — the native
+ * `<input type="date">` styled by Mantine, no `@mantine/dates` involved. A
+ * consumer wanting a real picker plugs one in through `meta.editor`.
+ */
+declare function TMDataGridDateEditor({ field, autoFocus, column, size }: TMDataGridEditorArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/editors/TMDataGridSelectEditor.d.ts
+/**
+ * The built-in editor for `meta.type: "select"`. Options come from the same
+ * `meta.options` the filter panel reads — with the row in hand, so a
+ * function source can depend on the record being edited.
+ */
+declare function TMDataGridSelectEditor({ field, autoFocus, column, row, table, size, commit }: TMDataGridEditorArgs): import("react").JSX.Element;
+//#endregion
+//#region .types-tmp/components/editors/TMDataGridMultiSelectEditor.d.ts
+/**
+ * The built-in editor for `meta.type: "multiSelect"` — cells holding string
+ * arrays. Never commits on pick: building a set takes several, so the commit
+ * stays on Enter/blur like a text edit.
+ */
+declare function TMDataGridMultiSelectEditor({ field, autoFocus, column, row, table, size }: TMDataGridEditorArgs): import("react").JSX.Element;
+//#endregion
 //#region .types-tmp/core/labelsSv.d.ts
 /**
  * The complete Swedish dictionary. Typed as {@link TMDataGridLabels} rather
@@ -1660,13 +2492,19 @@ type ColumnLike = {
 declare function getColumnLabel(column: ColumnLike): string;
 declare function getColumnType(column: ColumnLike): TMDataGridColumnType;
 /**
- * A generated lane holding one control at a fixed width — the checkbox and the
- * details chevron.
+ * The operator a fresh filter on this column starts with —
+ * `meta.defaultFilterOperator`, else the type's default.
+ */
+declare function getColumnDefaultOperator(column: ColumnLike): TMDataGridFilterOperator;
+/**
+ * A generated lane holding one fixed-width thing — the checkbox, the details
+ * chevron, the row number.
  *
  * They are laid out differently from every other column: cell padding is sized
  * for text and grows with the scale, which at `xl` squeezed a 16px checkbox out
- * of its track, so these lanes centre their control in an unpadded cell.
- * Their headers are controls too, and carry no column menu.
+ * of its track, so these lanes centre their content in an unpadded cell.
+ * Their headers carry no column menu, and none of them is ever exported —
+ * they hold chrome, not values.
  *
  * The tree column is deliberately not one of them: it holds a label as well as a
  * chevron, and wants the padding.
@@ -1854,6 +2692,10 @@ declare function moveColumnByStep({ table, columnId, direction }: ColumnStepArgs
  * is the right list for a range: it is what the user can see, and a range that
  * swept collapsed rows would select things off screen. What a group row in the
  * range contributes is decided by {@link getSelectableRowIds}.
+ *
+ * Rows pinned to an edge leave this list — they render in their own sticky
+ * blocks, outside the scrolling order a shift-click range or the virtualizer
+ * walks. See `readPinnedRows`.
  */
 declare function getDisplayedRows<TData extends RowData>(table: TMDataGridTable<TData>, features: TMDataGridFeatureFlags): Array<Row<TMDataGridFeatures, TData>>;
 /**
@@ -1937,4 +2779,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, FILTER_OPERATOR_LABELS, GROUP_COLUMN_ID, type MoveColumnArgs, 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, type TMDataGridCapabilities, type TMDataGridCellCoords, type TMDataGridCellExportOptions, type TMDataGridCellMatrix, type TMDataGridCellNav, type TMDataGridCellPosition, type TMDataGridCellRange, type TMDataGridCellSelectionMode, type TMDataGridColumnCapabilities, type TMDataGridColumnLayout, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnType, type TMDataGridContextValue, type TMDataGridDataSlice, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, type TMDataGridDropSide, type TMDataGridExpandAllArgs, type TMDataGridExpandTarget, type TMDataGridFeatureFlags, type TMDataGridFeatures, type TMDataGridFilterOperator, TMDataGridFilterPills, type TMDataGridFilterPillsProps, type TMDataGridFilterValue, type TMDataGridFooterProps, type TMDataGridLabels, type TMDataGridLabelsOverride, type TMDataGridOption, type TMDataGridOptionsArgs, type TMDataGridOptionsSource, type TMDataGridPaginationApi, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridRangeBounds, type TMDataGridRowClickModifiers, type TMDataGridRowContextMenu, type TMDataGridRowContextMenuArgs, type TMDataGridRowData, TMDataGridSearch, type TMDataGridSearchProps, type TMDataGridSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridTableProps, type TMDataGridUiActions, type TMDataGridUiState, type TMDataGridUiStore, type UseTMDataGridOptions, aggregateColumn, areAllRowsExpanded, autosizeColumn, boundsCellCount, boundsEdges, buildCellMatrix, buildGridCellMatrix, createTMDataGridColumnHelper, downloadTextFile, exportGridToCsv, formatExportValue, formatFilterLabel, formatGroupValue, getColumnCapabilities, getColumnLabel, getColumnRegion, getColumnType, getDefaultOperator, getDisplayedRows, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, isColumnReorderable, isControlColumn, isFilterActive, isPagingActive, isSameCell, isWithinBounds, measureColumnContentWidth, mergeLabels, moveColumn, moveColumnByStep, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, 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 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 TMDataGridColumnLayout, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnType, type TMDataGridContextValue, type TMDataGridDataSlice, TMDataGridDateEditor, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, type TMDataGridDropSide, TMDataGridEditActions, type TMDataGridEditApi, type TMDataGridEditChange, type TMDataGridEditCommitArgs, type TMDataGridEditCommitBatchArgs, type TMDataGridEditField, type TMDataGridEditMode, type TMDataGridEditRowProjection, type TMDataGridEditState, 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 TMDataGridPaginationApi, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridQuickSearchMode, type TMDataGridRangeBounds, type TMDataGridRowAddArgs, type TMDataGridRowClickModifiers, type TMDataGridRowContextMenu, type TMDataGridRowContextMenuArgs, 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, getColumnLabel, getColumnRegion, getColumnType, getDefaultOperator, getDisplayedRows, getEditFieldName, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, isColumnReorderable, isControlColumn, isFilterActive, isPagingActive, isSameCell, isWithinBounds, measureColumnContentWidth, mergeLabels, moveColumn, moveColumnByStep, normalizeFieldValidate, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, operatorTakesRangeValue, optionsToComboboxData, readFeatureFlags, resolveCellMove, resolveColumnOptions, resolveExpandAll, resolveRangeBounds, resolveRowSelectionClick, tmDataGridFeatures, toClipboardText, toExcelCsv, useCellControlTabIndex, useTMDataGrid, useTMDataGridContext, writeClipboardText };