@jielga/tmdatagrid 0.2.0 → 0.5.0

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { Column, ColumnPinningState, Row, RowData, Table, TableFeatures, TableOptions, TableState } from "@tanstack/react-table";
+import { Cell, Column, ColumnPinningState, ExpandedState, Row, RowData, RowSelectionState, Table, TableFeatures, TableOptions, TableState, aggregationFns } from "@tanstack/react-table";
 import { CSSProperties, ReactNode } from "react";
+import { MantineSize, MenuProps } from "@mantine/core";
 import { Store } from "@tanstack/store";
-import { MantineSize } from "@mantine/core";
 //#region .types-tmp/components/TMDataGridColumnsPanel.d.ts
 /**
  * The "Manage columns" surface. Reachable from every column header menu and
@@ -19,6 +19,121 @@ declare function TMDataGridColumnsPanel(): import("react").JSX.Element;
  */
 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;
+/**
+ * Row height per size, in px.
+ *
+ * The virtualizer needs this as a number — it cannot read the CSS variable —
+ * so the scale lives here and `TMDataGrid.module.css` mirrors it. `meta.rowHeight`
+ * overrides it when a grid needs a height the scale doesn't offer.
+ */
+declare const SIZE_ROW_HEIGHT: Record<TMDataGridSize, number>;
+/** Size of the Mantine controls rendered inside the grid chrome. */
+declare const SIZE_CONTROL_SIZE: Record<TMDataGridSize, MantineSize>;
+//#endregion
+//#region .types-tmp/TMDataGridContext.d.ts
+/**
+ * Row shape the chrome components work against. They only ever touch columns,
+ * rows and cells generically, so the concrete row type is erased at the context
+ * boundary — the same trick Mantine uses for its compound components.
+ */
+type TMDataGridRowData = Record<string, unknown>;
+type TMDataGridContextValue = TMDataGridApi<TMDataGridRowData> & {
+  size: TMDataGridSize;
+  /** Row height in px, already resolved from `size` and `meta.rowHeight`. */
+  rowHeight: number;
+  /** Mantine control size that pairs with `size`. */
+  controlSize: TMDataGridSize;
+};
+declare function useTMDataGridContext(): TMDataGridContextValue;
+/**
+ * What a control inside a *body* cell should put in its `tabIndex`.
+ *
+ * `-1` once cell selection is on, and this is what makes the promise of one tab
+ * stop true. Without it the browser walks Tab into the checkbox of every
+ * mounted row — a grid showing twenty rows would be twenty tab stops, and
+ * scrolling would change how many. Enter or F2 steps into the cell instead,
+ * which reaches a `-1` control perfectly well.
+ *
+ * Header controls are not covered: the header row is not part of cell
+ * navigation, so its sort buttons and menus stay in the tab order, where they
+ * are the only way to reach them.
+ *
+ * A custom cell renderer with a control in it wants the same:
+ *
+ * ```tsx
+ * cell: ({ row }) => (
+ *   <Button tabIndex={useCellControlTabIndex()} onClick={...}>Open</Button>
+ * )
+ * ```
+ */
+declare function useCellControlTabIndex(): 0 | -1;
+//#endregion
+//#region .types-tmp/core/columnOptions.d.ts
+/**
+ * One choice of a `select` / `multiSelect` column. A bare string in any options
+ * list is shorthand for `{ value }`.
+ */
+type TMDataGridOption = {
+  value: string;
+  /** Shown in dropdowns. Defaults to the value itself. */
+  label?: string;
+  /** Mantine colour for the value's badge, where a cell renders one. */
+  color?: string;
+  disabled?: boolean;
+  /** Dropdown group heading. Ungrouped options render first. */
+  group?: string;
+};
+type TMDataGridOptionsArgs = {
+  table: TMDataGridTable<TMDataGridRowData>;
+  column: Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
+  /** The row an editor is standing on. Absent when the filter panel asks. */
+  row?: Row<TMDataGridFeatures, TMDataGridRowData>;
+  /**
+   * Source to use when the column declares none. The filter panel passes
+   * `"faceted"` so a select column with no `meta.options` still offers the
+   * values that exist, rather than an empty dropdown.
+   */
+  fallback?: TMDataGridOptionsSource;
+};
+/**
+ * Where a column's options come from — `meta.options`. One declaration feeds
+ * both the filter panel's value control and the cell editor.
+ *
+ * | Form | For |
+ * | --- | --- |
+ * | array | a known, fixed set |
+ * | `"faceted"` | low-cardinality data columns: the distinct values present, via `getFacetedUniqueValues` |
+ * | function | large or contextual sets — `row` is set when an editor asks, so options can depend on the record (city given country) |
+ */
+type TMDataGridOptionsSource = ReadonlyArray<TMDataGridOption | string> | "faceted" | ((args: TMDataGridOptionsArgs) => ReadonlyArray<TMDataGridOption | string>);
+/**
+ * A column's options as a normalised list, whatever form `meta.options` took.
+ * Empty for a column that declares none.
+ *
+ * `"faceted"` reads the distinct values actually present in the data. A
+ * multiSelect cell holds an array, so array values contribute their elements
+ * rather than the array itself.
+ */
+declare function resolveColumnOptions({ table, column, row, fallback }: TMDataGridOptionsArgs): Array<TMDataGridOption>;
+type ComboboxItem = {
+  value: string;
+  label: string;
+  disabled?: boolean;
+};
+type ComboboxData = Array<ComboboxItem | {
+  group: string;
+  items: ComboboxItem[];
+}>;
+/**
+ * The same list in the shape Mantine's `Select` / `MultiSelect` take, with
+ * `group` fields folded into Mantine's group entries. Ungrouped options come
+ * first, then the groups in first-appearance order.
+ */
+declare function optionsToComboboxData(options: ReadonlyArray<TMDataGridOption>): ComboboxData;
+//#endregion
 //#region .types-tmp/core/filterOperators.d.ts
 /**
  * The value shape stored in `columnFilters` for every TMDataGrid column.
@@ -27,20 +142,43 @@ declare function TMDataGridFilterPanel(): import("react").JSX.Element | null;
  * inside the filter *value* instead. That keeps the whole filter model plain,
  * serialisable JSON — which is what makes it portable to a server-side
  * `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.
  */
 type TMDataGridFilterValue = {
   operator: TMDataGridFilterOperator;
-  value: string;
+  value: string | ReadonlyArray<string>;
 };
-type TMDataGridColumnType = "string" | "number";
-type TMDataGridFilterOperator = "contains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "isEmpty" | "isNotEmpty";
+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";
 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;
 /**
  * A filter only narrows the row set once it has something to compare against.
  * Half-typed filters stay in state (so the panel keeps rendering their row) but
  * are treated as inactive for the funnel indicator and for row matching.
  */
 declare function isFilterActive(value: unknown): boolean;
+/**
+ * One-line description of a single filter, as shown on a filter pill.
+ *
+ * The type's default operator is left implicit — "First name: Sofia" reads the
+ * way a person would say it — while any other operator is spelled out, since
+ * that is the part a reader cannot guess.
+ */
+declare function formatFilterLabel({ label, type, filter, operatorLabels }: {
+  label: string;
+  type: TMDataGridColumnType;
+  filter: TMDataGridFilterValue;
+  /** Localized operator names — `labels.operators`. Defaults to English. */
+  operatorLabels?: Record<TMDataGridFilterOperator, string>;
+}): string;
 /**
  * The single filter function every TMDataGrid column uses. It dispatches on the
  * operator carried by the filter value, which is what lets one column offer
@@ -48,6 +186,102 @@ declare function isFilterActive(value: unknown): boolean;
  */
 declare function tmDataGridFilterFn<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown): boolean;
 //#endregion
+//#region .types-tmp/core/labels.d.ts
+/**
+ * Every user-facing string in the grid — menu items, panels, tooltips, the
+ * pager, and the `aria-label`s a screen reader speaks. One flat object, so an
+ * override is a spread rather than a deep merge; `operators` is the single
+ * nested record and {@link mergeLabels} folds it separately.
+ *
+ * Labels that carry a value are functions rather than template strings, so a
+ * language is free to put the value wherever its grammar wants it.
+ */
+type TMDataGridLabels = {
+  /** Filter operator names, as shown in the operator dropdown and on pills. */
+  operators: Record<TMDataGridFilterOperator, string>;
+  /** "Manage columns" — the burger button and the header menu item. */
+  manageColumns: string;
+  /** "Filters" — the funnel button and the filter panel's title. */
+  filters: string;
+  searchPlaceholder: string;
+  searchLabel: string;
+  clearSearch: string;
+  columnsSearchPlaceholder: string;
+  columnsNoMatch: (search: string) => string;
+  columnsShowHideAll: string;
+  columnsReset: string;
+  filterColumn: string;
+  filterOperator: string;
+  filterValue: string;
+  filterValuePlaceholder: string;
+  /** What a boolean column's `true` reads as — its filter choice and cell text. */
+  booleanTrue: string;
+  booleanFalse: string;
+  addFilter: string;
+  clearAllFilters: string;
+  closeFilters: string;
+  removeFilter: string;
+  activeFilters: string;
+  clearFilter: (column: string) => string;
+  sortAsc: string;
+  sortDesc: string;
+  filterMenuItem: string;
+  groupBy: (column: string) => string;
+  ungroup: (column: string) => string;
+  expandAllGroups: string;
+  collapseAllGroups: string;
+  pinLeft: string;
+  pinRight: string;
+  unpin: string;
+  moveLeft: string;
+  moveRight: string;
+  autosizeColumn: string;
+  hideColumn: string;
+  filterOn: (column: string) => string;
+  sortColumn: (column: string) => string;
+  columnMenu: (column: string) => string;
+  rowsPerPage: string;
+  pageRange: (args: {
+    from: number;
+    to: number;
+    total: number;
+  }) => string;
+  groupedAllRows: (total: number) => string;
+  pagingSuspendedHint: string;
+  previousPage: string;
+  nextPage: string;
+  noResults: string;
+  loading: string;
+  cellCount: (count: number) => string;
+  copy: string;
+  exportCsv: string;
+  includeHeaders: string;
+  selectColumnLabel: string;
+  selectAllRows: string;
+  selectRow: string;
+  selectGroup: string;
+  detailsColumnLabel: string;
+  showDetails: string;
+  hideDetails: string;
+  expandAllDetails: string;
+  collapseAllDetails: string;
+  groupColumnLabel: string;
+  blankGroupValue: string;
+  expandGroup: (label: string) => string;
+  collapseGroup: (label: string) => string;
+};
+/**
+ * What the `labels` option accepts: any subset, merged over the English
+ * defaults — so `{ noResults: "Inga rader" }` is a complete configuration.
+ */
+type TMDataGridLabelsOverride = Partial<Omit<TMDataGridLabels, "operators">> & {
+  operators?: Partial<Record<TMDataGridFilterOperator, string>>;
+};
+/** The built-in defaults. Also the reference for what a preset must cover. */
+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/persistence.d.ts
 type GridState = TableState<TMDataGridFeatures>;
 /**
@@ -69,12 +303,12 @@ type GridState = TableState<TMDataGridFeatures>;
  * State slices describing what the user is looking at. Derived from the data,
  * so they can go stale as it changes.
  */
-declare const DATA_STATE_SLICES: readonly ["columnFilters", "globalFilter", "sorting", "pagination"];
+declare const DATA_STATE_SLICES: readonly ["columnFilters", "globalFilter", "sorting", "pagination", "expanded"];
 /**
  * State slices describing how the user configured the grid. Independent of the
  * data, and the ones users notice losing.
  */
-declare const SETTINGS_STATE_SLICES: readonly ["columnVisibility", "columnSizing", "columnOrder", "columnPinning"];
+declare const SETTINGS_STATE_SLICES: readonly ["columnVisibility", "columnSizing", "columnOrder", "columnPinning", "grouping"];
 type TMDataGridDataSlice = (typeof DATA_STATE_SLICES)[number];
 type TMDataGridSettingsSlice = (typeof SETTINGS_STATE_SLICES)[number];
 /**
@@ -99,36 +333,6 @@ type TMDataGridPersistence = {
   deserialize?: (value: string) => unknown;
 };
 //#endregion
-//#region .types-tmp/core/sizes.d.ts
-type TMDataGridSize = MantineSize;
-declare const DEFAULT_TMDATAGRID_SIZE: TMDataGridSize;
-/**
- * Row height per size, in px.
- *
- * The virtualizer needs this as a number — it cannot read the CSS variable —
- * so the scale lives here and `TMDataGrid.module.css` mirrors it. `meta.rowHeight`
- * overrides it when a grid needs a height the scale doesn't offer.
- */
-declare const SIZE_ROW_HEIGHT: Record<TMDataGridSize, number>;
-/** Size of the Mantine controls rendered inside the grid chrome. */
-declare const SIZE_CONTROL_SIZE: Record<TMDataGridSize, MantineSize>;
-//#endregion
-//#region .types-tmp/TMDataGridContext.d.ts
-/**
- * Row shape the chrome components work against. They only ever touch columns,
- * rows and cells generically, so the concrete row type is erased at the context
- * boundary — the same trick Mantine uses for its compound components.
- */
-type TMDataGridRowData = Record<string, unknown>;
-type TMDataGridContextValue = TMDataGridApi<TMDataGridRowData> & {
-  size: TMDataGridSize;
-  /** Row height in px, already resolved from `size` and `meta.rowHeight`. */
-  rowHeight: number;
-  /** Mantine control size that pairs with `size`. */
-  controlSize: TMDataGridSize;
-};
-declare function useTMDataGridContext(): TMDataGridContextValue;
-//#endregion
 //#region .types-tmp/core/capabilities.d.ts
 /**
  * Table-level feature switches, read straight off the options object.
@@ -143,29 +347,103 @@ declare function useTMDataGridContext(): TMDataGridContextValue;
  * what applies the per-column overrides.
  */
 /**
- * How rows are selected — see `rowSelectionMode` on {@link UseTMDataGridOptions}.
+ * How rows are selected — see `selectionMode` on {@link UseTMDataGridOptions}.
+ *
+ * One axis, because the two things a config could set independently — which
+ * chrome selects, and what a bare row click does — cannot both be free: a click
+ * can either toggle a multi-selection or move the highlight, never both. Folding
+ * them into one value makes that conflict unrepresentable rather than something
+ * to warn about.
  */
-type TMDataGridRowSelectionMode = "checkbox" | "row";
+type TMDataGridSelectionMode =
+/** Checkbox column, multi-select. Clicking a row elsewhere does nothing. */
+"checkbox" |
+/** No checkbox column; row click multi-selects, with Ctrl/Shift modifiers. */
+"row" |
+/** Checkbox column multi-selects, and a row click highlights one row. */
+"checkboxAndHighlight" |
+/** No selection at all — a row click only highlights. Master-detail. */
+"highlight";
+/**
+ * How cells are selected — see `cellSelection` on {@link UseTMDataGridOptions}.
+ *
+ * A mode rather than a pair of booleans, for the reason
+ * {@link TMDataGridSelectionMode} is one: "cells can be selected" and "more
+ * than one at a time" are not independent, and a range that cannot be anchored
+ * anywhere is not a state worth being able to write down.
+ */
+type TMDataGridCellSelectionMode =
+/** No cell cursor at all. The body's tab stop stays on the row. */
+"none" |
+/** One cell takes the focus and the arrow keys move it. */
+"single" |
+/** As `"single"`, plus a rectangle: drag, Shift+click, Shift+arrows, Ctrl+C. */
+"range";
 type TMDataGridFeatureFlags = {
   sorting: boolean;
   filtering: boolean;
+  /** Whether the quick search may filter — `enableGlobalFilter`. */
+  globalFiltering: boolean;
   hiding: boolean;
   pinning: boolean;
   resizing: boolean;
   ordering: boolean;
+  /** Whether any row selection is possible. Off outright under `"highlight"`. */
   rowSelection: boolean;
-  /** Only meaningful while `rowSelection` is on. Defaults to `"checkbox"`. */
-  rowSelectionMode: TMDataGridRowSelectionMode;
+  /** Defaults to `"checkbox"`. */
+  selectionMode: TMDataGridSelectionMode;
+  /** Whether the generated checkbox column is prepended. */
+  selectColumn: boolean;
+  /** Whether a bare row click toggles the selection. Only under `"row"`. */
+  rowClickSelects: boolean;
+  /**
+   * Whether more than one row can be selected at once — TanStack's
+   * `enableMultiRowSelection`. Off, the grid drops the select-all header
+   * checkbox: TanStack's `toggleAllRowsSelected` only consults `getCanSelect`,
+   * so that control would select every row and walk straight past the limit.
+   *
+   * A per-row predicate counts as on, since some rows may still multi-select.
+   */
+  multiRowSelection: boolean;
   /** Whether a selected row takes the highlight colour. Follows the mode. */
-  highlightSelectedRows: boolean;
+  showSelectedBackground: boolean;
+  /**
+   * The single highlighted row — clicking a row highlights it, for a detail
+   * panel to follow. State of its own, not a slice of `rowSelection`, which is
+   * what lets it coexist with a checkbox multi-selection.
+   */
+  highlightRow: boolean;
+  /**
+   * Whether cells can be selected at all. Off unless `cellSelection` asks for
+   * it — it takes the body's tab stop off the row and puts it on a cell, and
+   * reports the grid to assistive technology as a `grid` rather than a `table`,
+   * which is a different promise about what the keyboard does.
+   */
+  cellSelection: boolean;
+  /** Defaults to `"none"`. */
+  cellSelectionMode: TMDataGridCellSelectionMode;
+  /** Whether a rectangle of cells can be selected. Only under `"range"`. */
+  cellRangeSelection: boolean;
   /**
    * The one default-off flag: pagination must be asked for, either with the
    * grid's `enablePagination` or implicitly by declaring `manualPagination`.
    * Off, the grid renders every filtered row and relies on virtualization.
    */
   pagination: boolean;
+  /**
+   * Row grouping: the "Group by" items in the header menu and the generated
+   * tree column. On unless `enableGrouping: false`, since an ungrouped grid
+   * looks and behaves exactly as it did before — `grouping` starts empty, and
+   * an empty grouping state passes straight through the row model.
+   *
+   * The exception is `manualPagination`, where the client holds one page rather
+   * than the whole set: grouping that page would build groups out of an
+   * arbitrary slice and quietly show wrong counts. A server-side grid that does
+   * its own grouping can still say `enableGrouping: true` to override.
+   */
+  grouping: boolean;
 };
-declare function readFeatureFlags<TData extends RowData>(options: Pick<UseTMDataGridOptions<TData>, "enableSorting" | "enableColumnFilters" | "enableHiding" | "enableColumnPinning" | "enableColumnResizing" | "enableColumnOrdering" | "enableRowSelection" | "rowSelectionMode" | "highlightSelectedRows" | "enablePagination" | "manualPagination">): 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">): TMDataGridFeatureFlags;
 /**
  * What one column's header may offer.
  *
@@ -177,6 +455,7 @@ declare function readFeatureFlags<TData extends RowData>(options: Pick<UseTMData
  * | Pin to left / right       | `enableColumnPinning` / `enablePinning` |
  * | Resize dragging           | `enableColumnResizing` / `enableResizing` |
  * | Header dragging, Move left / right | `enableColumnOrdering` / `meta.enableOrdering` |
+ * | Group by / Ungroup        | `enableGrouping` (table or column) |
  */
 type TMDataGridColumnCapabilities = {
   canSort: boolean;
@@ -185,6 +464,7 @@ type TMDataGridColumnCapabilities = {
   canPin: boolean;
   canResize: boolean;
   canReorder: boolean;
+  canGroup: boolean;
 };
 declare function getColumnCapabilities(column: Column<TMDataGridFeatures, TMDataGridRowData, unknown>, features: TMDataGridFeatureFlags): TMDataGridColumnCapabilities;
 /** The same questions, asked of the whole grid — used to hide toolbar buttons. */
@@ -194,21 +474,154 @@ type TMDataGridCapabilities = {
   canHideAny: boolean;
   canPinAny: boolean;
   canReorderAny: boolean;
+  canGroupAny: boolean;
   canSelectRows: boolean;
   canPaginate: boolean;
+  /** At least one leaf column takes part in the global quick search. */
+  canSearch: boolean;
 };
 declare function getGridCapabilities(table: TMDataGridTable<TMDataGridRowData>, features: TMDataGridFeatureFlags): TMDataGridCapabilities;
 //#endregion
+//#region .types-tmp/core/cellNavigation.d.ts
+/**
+ * Which cell has the focus, by id rather than by position.
+ *
+ * Ids, because every other thing the grid does moves cells around: sorting
+ * reorders rows, filtering removes them, dragging a header reorders columns. A
+ * coordinate pair would silently come to mean a different cell after any of
+ * them, while a pair of ids either still resolves or does not resolve at all —
+ * and "does not resolve" is a state the grid can handle honestly.
+ *
+ * Indices are what navigation is actually computed in, so they are resolved
+ * from the ids on each keystroke and turned straight back. See resolveCellMove.
+ */
+type TMDataGridCellPosition = {
+  rowId: string;
+  columnId: string;
+};
+/** Where the focused cell sits in the rows and columns on screen. */
+type TMDataGridCellCoords = {
+  rowIndex: number;
+  columnIndex: number;
+};
+type ResolveCellMoveArgs = {
+  /** `KeyboardEvent.key`. */
+  key: string;
+  /** Ctrl or Cmd — Home and End jump to the corner rather than the row end. */
+  ctrlKey: boolean;
+  from: TMDataGridCellCoords;
+  rowCount: number;
+  columnCount: number;
+  /**
+   * How far PageUp and PageDown travel: one viewport of rows. Passed in rather
+   * than assumed, since only the body knows how tall it is.
+   */
+  pageRows: number;
+};
+/**
+ * The next cell for a navigation key, or `null` when the key is not one.
+ *
+ * Moves clamp at the edges instead of wrapping. Wrapping suits a menu, where
+ * the items are a short ring; a grid is a coordinate space, and a Right at the
+ * last column that lands on the first column of the next row loses the one
+ * thing arrow keys are for — knowing where you will end up without looking.
+ *
+ * A clamped move returns the position it started from rather than `null`. The
+ * caller still needs to know the key was handled: an arrow at the last row must
+ * not fall through to the scroll container, which would scroll the body out
+ * from under a focus that did not move.
+ */
+declare function resolveCellMove({ key, ctrlKey, from, rowCount, columnCount, pageRows }: ResolveCellMoveArgs): TMDataGridCellCoords | null;
+/** Whether two positions address the same cell. `null` equals only `null`. */
+declare function isSameCell(a: TMDataGridCellPosition | null, b: TMDataGridCellPosition | null): boolean;
+//#endregion
+//#region .types-tmp/core/cellRange.d.ts
+/**
+ * A selected rectangle of cells, held as the two cells that span it.
+ *
+ * Two corners rather than a list of cells, because a range is a gesture, not a
+ * set: dragging over 40 columns of a 100k-row grid would otherwise build — and
+ * rebuild, on every mouse move — a list with millions of entries in it. Two
+ * positions describe the same thing and cost nothing to extend.
+ *
+ * `anchor` is where the gesture started and stays put; `focus` is the end that
+ * moves. Which of the two is top-left depends on the direction it was dragged,
+ * so nothing here assumes an order — see {@link resolveRangeBounds}.
+ */
+type TMDataGridCellRange = {
+  anchor: TMDataGridCellPosition;
+  focus: TMDataGridCellPosition;
+};
+/** The rectangle a range covers, in row and column indices, both ends included. */
+type TMDataGridRangeBounds = {
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+};
+type ResolveRangeBoundsArgs = {
+  range: TMDataGridCellRange | null;
+  /** Index of a row id among the rows on screen, or `-1`. */
+  rowIndexOf: (rowId: string) => number;
+  columnIndexOf: (columnId: string) => number;
+};
+/**
+ * Turns a range into the rectangle to paint and copy, or `null` when either
+ * corner no longer exists.
+ *
+ * A corner goes missing whenever a filter drops its row or a column is hidden,
+ * and the honest answer then is that there is no rectangle — better than
+ * guessing at a replacement corner and quietly copying cells the user never
+ * selected. The range itself is left alone: clearing it here would throw away
+ * a selection that comes straight back when the filter is lifted.
+ */
+declare function resolveRangeBounds({ range, rowIndexOf, columnIndexOf }: ResolveRangeBoundsArgs): TMDataGridRangeBounds | null;
+/** Whether a cell is inside the rectangle. */
+declare function isWithinBounds(bounds: TMDataGridRangeBounds | null, rowIndex: number, columnIndex: number): boolean;
+/** How many cells the rectangle covers. `0` for no range at all. */
+declare function boundsCellCount(bounds: TMDataGridRangeBounds | null): number;
+/**
+ * Which edges of the rectangle a cell sits on, for the outline.
+ *
+ * The border is drawn per cell rather than as one box over the top, because the
+ * body is a scrolling CSS grid with sticky columns in it: an overlay would have
+ * to be positioned against a moving target and would still be wrong the moment
+ * a pinned lane slid over it. Four booleans per cell need no positioning at all.
+ */
+declare function boundsEdges(bounds: TMDataGridRangeBounds | null, rowIndex: number, columnIndex: number): {
+  top: boolean;
+  bottom: boolean;
+  left: boolean;
+  right: boolean;
+} | null;
+//#endregion
 //#region .types-tmp/useTMDataGrid.d.ts
 /** Per-column configuration the TMDataGrid chrome reads. */
 type TMDataGridColumnMeta = {
   /** Name shown in menus and the column manager. Falls back to a string header. */
   label?: string;
-  /** Drives which filter operators are offered. Defaults to `"string"`. */
+  /**
+   * Drives which filter operators are offered and, once editing is on, which
+   * editor the cell opens. Defaults to `"string"`.
+   */
   type?: TMDataGridColumnType;
+  /**
+   * The choices of a `select` / `multiSelect` column — one declaration feeding
+   * the filter panel's value control and the cell editor alike. A static
+   * array, `"faceted"` (the distinct values present in the data), or a
+   * function of the table, column and — for editors — the row. See
+   * {@link TMDataGridOptionsSource}.
+   */
+  options?: TMDataGridOptionsSource;
   /** Share of the leftover width this column claims. Defaults to `1`. */
   flex?: number;
   align?: "left" | "right" | "center";
+  /**
+   * Size the column to its widest mounted content once, after the first rows
+   * render — unless a persisted or user-set width already covers it. The same
+   * measurement as double-clicking the resize divider; see `autosizeColumn`.
+   */
+  autoSize?: boolean;
   /**
    * `false` keeps the column where it is: no header dragging, no move items.
    * Column ordering is the one feature TanStack defines no column option for,
@@ -244,57 +657,72 @@ declare const tmDataGridFeatures: {
   columnSizingFeature: import("@tanstack/table-core").TableFeature;
   columnResizingFeature: import("@tanstack/table-core").TableFeature;
   columnFacetingFeature: import("@tanstack/table-core").TableFeature;
+  columnGroupingFeature: import("@tanstack/table-core").TableFeature;
+  rowExpandingFeature: import("@tanstack/table-core").TableFeature;
   filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  groupedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  expandedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   paginatedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   facetedRowModel: (table: Table<any, any>, columnId: string) => () => import("@tanstack/table-core").RowModel<any, any>;
   facetedMinMaxValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => undefined | [number, number];
   facetedUniqueValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => Map<any, number>;
   filterFns: {
-    arrIncludes: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
+    arrIncludes: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
+    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean;
-    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
+    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean;
+    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
+    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
+    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
+    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
+    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: [number, number]) => boolean) & {
+    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: [number, number]) => boolean) & {
       resolveFilterValue: (val: [any, any]) => readonly [number, number];
       autoRemove: (val: any) => boolean;
     };
-    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
+    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
+    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
+    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
     tmDataGrid: typeof tmDataGridFilterFn;
   };
   sortFns: {
-    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData>, rowB: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string) => number;
-    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData>, rowB: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string) => number;
-    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData>, rowB: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData>, rowB: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData>, rowB: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData>, rowB: import("@tanstack/table-core").Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
+    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+  };
+  aggregationFns: {
+    sum: typeof import("@tanstack/table-core").aggregationFn_sum;
+    min: typeof import("@tanstack/table-core").aggregationFn_min;
+    max: typeof import("@tanstack/table-core").aggregationFn_max;
+    extent: typeof import("@tanstack/table-core").aggregationFn_extent;
+    mean: typeof import("@tanstack/table-core").aggregationFn_mean;
+    median: typeof import("@tanstack/table-core").aggregationFn_median;
+    unique: typeof import("@tanstack/table-core").aggregationFn_unique;
+    uniqueCount: typeof import("@tanstack/table-core").aggregationFn_uniqueCount;
+    count: typeof import("@tanstack/table-core").aggregationFn_count;
   };
   tableMeta: TMDataGridTableMeta;
   columnMeta: TMDataGridColumnMeta;
@@ -313,61 +741,83 @@ declare function createTMDataGridColumnHelper<TData extends RowData>(): import("
   columnSizingFeature: import("@tanstack/table-core").TableFeature;
   columnResizingFeature: import("@tanstack/table-core").TableFeature;
   columnFacetingFeature: import("@tanstack/table-core").TableFeature;
+  columnGroupingFeature: import("@tanstack/table-core").TableFeature;
+  rowExpandingFeature: import("@tanstack/table-core").TableFeature;
   filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  groupedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  expandedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   paginatedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
   facetedRowModel: (table: Table<any, any>, columnId: string) => () => import("@tanstack/table-core").RowModel<any, any>;
   facetedMinMaxValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => undefined | [number, number];
   facetedUniqueValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => Map<any, number>;
   filterFns: {
-    arrIncludes: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
+    arrIncludes: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
+    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean;
-    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
+    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean;
+    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
+    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
+    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
+    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
+    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: [number, number]) => boolean) & {
+    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: [number, number]) => boolean) & {
       resolveFilterValue: (val: [any, any]) => readonly [number, number];
       autoRemove: (val: any) => boolean;
     };
-    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
+    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
+    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
-    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
+    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
       autoRemove: (val: any) => boolean;
     };
     tmDataGrid: typeof tmDataGridFilterFn;
   };
   sortFns: {
-    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData_1>, rowB: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string) => number;
-    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData_1>, rowB: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string) => number;
-    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData_1>, rowB: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData_1>, rowB: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData_1>, rowB: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: import("@tanstack/table-core").Row<TFeatures, TData_1>, rowB: import("@tanstack/table-core").Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
+    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => number;
+    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => number;
+    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
+    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
+    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
+    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
+  };
+  aggregationFns: {
+    sum: typeof import("@tanstack/table-core").aggregationFn_sum;
+    min: typeof import("@tanstack/table-core").aggregationFn_min;
+    max: typeof import("@tanstack/table-core").aggregationFn_max;
+    extent: typeof import("@tanstack/table-core").aggregationFn_extent;
+    mean: typeof import("@tanstack/table-core").aggregationFn_mean;
+    median: typeof import("@tanstack/table-core").aggregationFn_median;
+    unique: typeof import("@tanstack/table-core").aggregationFn_unique;
+    uniqueCount: typeof import("@tanstack/table-core").aggregationFn_uniqueCount;
+    count: typeof import("@tanstack/table-core").aggregationFn_count;
   };
   tableMeta: TMDataGridTableMeta;
   columnMeta: TMDataGridColumnMeta;
 }, TData>;
+/** What the `renderDetails` render prop is handed for an expanded row. */
+type TMDataGridDetailsArgs<TData extends RowData> = {
+  row: Row<TMDataGridFeatures, TData>;
+  table: TMDataGridTable<TData>;
+};
+/** Builds the panel shown underneath an expanded row. See `renderDetails`. */
+type TMDataGridDetailsRenderer<TData extends RowData> = (args: TMDataGridDetailsArgs<TData>) => ReactNode;
 /**
  * Chrome state that is *not* table state: which panels are open, and which
  * column opened the filter panel. Kept in a TanStack Store so consumers can
@@ -383,6 +833,39 @@ type TMDataGridUiState = {
    * `dataTransfer`, which browsers keep unreadable until the drop.
    */
   draggedColumnId: string | null;
+  /**
+   * The single highlighted row — the one a detail panel would be showing. Its
+   * own concept, not a slice of `rowSelection`: under
+   * `selectionMode: "checkboxAndHighlight"` the two coexist, and TanStack's one
+   * selection map cannot hold both.
+   *
+   * Not pruned when the row is filtered out, paged away or dropped from `data`,
+   * matching how TanStack treats `rowSelection` — nothing there resets it
+   * either. The row simply renders unhighlighted, and highlights again if it
+   * comes back.
+   */
+  highlightedRowId: string | null;
+  /** The pivot a shift-click extends from. See resolveRowSelectionClick. */
+  selectionAnchorRowId: string | null;
+  /**
+   * The cell the keyboard is on, under `enableCellSelection`. `null` until the
+   * grid is first entered — and again whenever a consumer clears it.
+   *
+   * The state is the source of truth and DOM focus follows it, not the other
+   * way around: under virtualization the cell it names is often not mounted,
+   * which is exactly what a coordinate has to survive. Held as ids for the
+   * same reason — see {@link TMDataGridCellPosition}.
+   */
+  focusedCell: TMDataGridCellPosition | null;
+  /**
+   * The selected rectangle, under `cellSelection: "range"`. Held as the two
+   * cells that span it — see {@link TMDataGridCellRange}.
+   *
+   * Always covers the focused cell: every gesture that moves the focus either
+   * extends the rectangle or collapses it onto the new cell, so the two never
+   * describe different places.
+   */
+  cellRange: TMDataGridCellRange | null;
 };
 type TMDataGridUiActions = {
   openFilterPanel: (columnId?: string | null) => void;
@@ -391,6 +874,25 @@ type TMDataGridUiActions = {
   toggleColumnsPanel: () => void;
   startColumnDrag: (columnId: string) => void;
   endColumnDrag: () => void;
+  /**
+   * Moves the active row, or clears it with `null` — which is how a consumer
+   * closing its detail panel puts the grid back in step.
+   */
+  setHighlightedRow: (rowId: string | null) => void;
+  setSelectionAnchor: (rowId: string | null) => void;
+  /**
+   * Moves the focused cell, or clears it with `null`. DOM focus follows while
+   * the grid holds it — so this both moves the keyboard and, when the row is
+   * off screen, scrolls it into view. Called for every arrow key, and available
+   * for a consumer putting the keyboard somewhere itself.
+   */
+  setFocusedCell: (cell: TMDataGridCellPosition | null) => void;
+  /**
+   * Sets the selected rectangle, or clears it with `null`. Does not move the
+   * focused cell — the two are set together by the gestures that change both,
+   * which is what keeps "extend the selection" and "move the cursor" separable.
+   */
+  setCellRange: (range: TMDataGridCellRange | null) => void;
 };
 type TMDataGridUiStore = Store<TMDataGridUiState, TMDataGridUiActions>;
 /** What `useTMDataGrid` returns — spread straight onto `<TMDataGrid />`. */
@@ -399,6 +901,14 @@ type TMDataGridApi<TData extends RowData> = {
   ui: TMDataGridUiStore;
   /** Table-level feature switches, re-read from options on every render. */
   features: TMDataGridFeatureFlags;
+  /** Every string the chrome renders, `labels` merged over the English defaults. */
+  labels: TMDataGridLabels;
+  /** The detail renderer, when row details are on. See `renderDetails`. */
+  renderDetails?: TMDataGridDetailsRenderer<TData>;
+  /** Detail estimate in px: the option, or {@link DEFAULT_DETAILS_EST_HEIGHT}. */
+  renderDetailsEstHeight: number;
+  /** Virtualizer overscan: the option, or {@link DEFAULT_OVERSCAN}. */
+  overscan: number;
 };
 type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridFeatures, TData>, "features"> & {
   /**
@@ -409,6 +919,20 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
    * dependency of the subscription that writes back.
    */
   persist?: TMDataGridPersistence;
+  /**
+   * Overrides for the grid's strings — menu items, panels, the pager, and
+   * every `aria-label`. Any subset, merged over the English defaults; a full
+   * Swedish dictionary ships as `TMDATAGRID_LABELS_SV`.
+   *
+   * ```tsx
+   * useTMDataGrid({ data, columns, labels: TMDATAGRID_LABELS_SV });
+   * useTMDataGrid({ data, columns, labels: { noResults: "Inga rader" } });
+   * ```
+   *
+   * Keep the object referentially stable (module scope or `useMemo`) — the
+   * chrome re-renders when its identity changes.
+   */
+  labels?: TMDataGridLabelsOverride;
   /**
    * Header drag-and-drop and the move items in the column menu. Defaults to
    * `true`.
@@ -431,18 +955,29 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
   /**
    * How rows are selected. Defaults to `"checkbox"`.
    *
-   * - `"checkbox"` — the generated checkbox column selects; clicking a row
-   *   elsewhere does not.
-   * - `"row"` — no checkbox column; clicking a row toggles it. Other rows keep
-   *   their state, so a click never clears the rest of the selection.
+   * | Mode | Checkbox column | Row click |
+   * | ---- | --------------- | --------- |
+   * | `"checkbox"` | yes, multi-select | nothing |
+   * | `"row"` | no | multi-selects, Ctrl/Shift modifiers |
+   * | `"checkboxAndHighlight"` | yes, multi-select | highlights one row |
+   * | `"highlight"` | no | highlights one row, no selection at all |
+   *
+   * One option rather than two, so the combination that cannot work — a click
+   * that both toggles a multi-selection and moves the highlight — is not
+   * expressible.
    *
-   * Ignored when `enableRowSelection` is `false`. Both modes write to the same
-   * `rowSelection` state.
+   * The first two write to TanStack's `rowSelection`. The highlight is separate
+   * state, which is what lets `"checkboxAndHighlight"` run both at once: tick
+   * rows for a bulk action, click one to open its detail panel. See
+   * `defaultHighlightedRowId` / `onHighlightedRowChange`.
+   *
+   * `enableRowSelection` still gates the selection half, predicate form
+   * included; under `"highlight"` there is nothing for it to gate.
    */
-  rowSelectionMode?: TMDataGridRowSelectionMode;
+  selectionMode?: TMDataGridSelectionMode;
   /**
    * Give selected rows the highlight background. Defaults to `true` under
-   * `rowSelectionMode: "row"`, where the highlight is the only feedback a click
+   * `selectionMode: "row"`, where the highlight is the only feedback a click
    * gives, and `false` under `"checkbox"`, where the box already shows it.
    *
    * The colour is the `--dg-row-selected-bg` CSS variable, so it can be changed
@@ -455,7 +990,138 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
    * />
    * ```
    */
-  highlightSelectedRows?: boolean;
+  showSelectedBackground?: boolean;
+  /**
+   * The row that starts out highlighted, under a `selectionMode` that has a
+   * highlight. Read once on mount, like `initialState`.
+   *
+   * The grid never persists the highlighted row. Pair this with
+   * {@link onHighlightedRowChange} and keep it wherever it belongs — for a
+   * detail panel that is usually the route, which gets you a shareable link and
+   * a working back button as well as surviving a reload:
+   *
+   * ```tsx
+   * const { rowId } = useParams();
+   * useTMDataGrid({
+   *   selectionMode: "highlight",
+   *   defaultHighlightedRowId: rowId,
+   *   onHighlightedRowChange: (id) => navigate(id ? `/employees/${id}` : "/employees"),
+   * });
+   * ```
+   */
+  defaultHighlightedRowId?: string | null;
+  /**
+   * Called with the newly highlighted row id, or `null` when it is cleared.
+   * Fires for `ui.actions.setHighlightedRow` too, not only for clicks.
+   */
+  onHighlightedRowChange?: (rowId: string | null) => void;
+  /**
+   * How cells are selected. Defaults to `"none"`.
+   *
+   * | Mode | What it gives |
+   * | ---- | ------------- |
+   * | `"none"` | nothing; the body's tab stop stays on the row |
+   * | `"single"` | one focused cell, moved with the arrow keys |
+   * | `"range"` | as `"single"`, plus a rectangle of cells |
+   *
+   * Under either live mode:
+   *
+   * | Key | Moves to |
+   * | --- | --- |
+   * | Arrows | the neighbouring cell, clamped at the edges |
+   * | PageUp / PageDown | one viewport of rows |
+   * | Home / End | first / last cell of the row |
+   * | Ctrl+Home / Ctrl+End | first / last cell of the grid |
+   * | Enter or F2 | into the cell — the checkbox, link or button it holds |
+   * | Escape | back out to the cell |
+   * | Space | selects the row, as it does in row-selection mode |
+   *
+   * And under `"range"`, additionally:
+   *
+   * | Gesture | Does |
+   * | ------- | ---- |
+   * | Drag across cells | selects the rectangle they span |
+   * | Shift+click, Shift+arrows | extends the rectangle from its anchor |
+   * | Ctrl+C | copies it as tab-separated text — paste lands in Excel's cells |
+   * | Right-click inside it | offers the CSV export, headers optional |
+   *
+   * Off, nothing about the body changes. On, three things do: the body's tab
+   * stop moves from the row to a cell, so the whole grid is one Tab stop; the
+   * grid reports itself as a `grid` of `gridcell`s rather than a `table` of
+   * `cell`s, which is what tells a screen reader the arrow keys are live; and
+   * the cells take `data-focused` / `data-selected` for the ring and the tint.
+   *
+   * The state is `ui.state.focusedCell` and `ui.state.cellRange`, and moving it
+   * is `ui.actions.setFocusedCell` / `setCellRange` — so a consumer can put the
+   * keyboard on a cell, or follow it:
+   *
+   * ```tsx
+   * const grid = useTMDataGrid({
+   *   data,
+   *   columns,
+   *   cellSelection: "range",
+   *   onFocusedCellChange: (cell) => setStatus(cell?.columnId ?? ""),
+   * });
+   * ```
+   *
+   * Ids rather than a row/column index pair, so sorting, filtering and column
+   * reordering move the selection with the cells instead of leaving it over
+   * whatever slid into those positions.
+   */
+  cellSelection?: TMDataGridCellSelectionMode;
+  /**
+   * Called with the newly focused cell, or `null` when it is cleared. Fires for
+   * `ui.actions.setFocusedCell` too, not only for keys and clicks.
+   */
+  onFocusedCellChange?: (cell: TMDataGridCellPosition | null) => void;
+  /**
+   * Renders a panel underneath an expanded row, spanning every column. Setting
+   * it is what turns row details on.
+   *
+   * Which rows are open is TanStack's own `expanded` state, so opening one is
+   * `row.toggleExpanded()` from wherever suits — a chevron in a cell, a button
+   * in the context menu, a double-click:
+   *
+   * ```tsx
+   * const grid = useTMDataGrid({
+   *   data,
+   *   columns,
+   *   renderDetails: ({ row }) => <EmployeeCard employee={row.original} />,
+   * });
+   * ```
+   *
+   * The panel is as tall as what it renders — see {@link renderDetailsEstHeight}
+   * for what the virtualizer assumes before it has measured one.
+   *
+   * Group rows are left out: expanding one opens its children, and a panel there
+   * would be about an arbitrary one of them. The same reason they sit out
+   * `onRowClick`.
+   *
+   * Row details and `selectionMode: "highlight"` are two answers to the same
+   * question. Details keep the record in place and in context, which suits a few
+   * fields or an action strip; a highlight-driven side panel has room for more
+   * and survives scrolling. Nothing stops a grid from doing both.
+   */
+  renderDetails?: TMDataGridDetailsRenderer<TData>;
+  /**
+   * What the virtualizer assumes an unmeasured detail panel is worth, in px.
+   * Defaults to 160.
+   *
+   * An estimate, not a height: every mounted row is measured, so the real one
+   * takes over as soon as the panel is on screen. It keeps the scrollbar honest
+   * for panels that open off screen — restored `expanded` state, say — and being
+   * roughly right is enough.
+   */
+  renderDetailsEstHeight?: number;
+  /**
+   * Rows the virtualizer keeps mounted above and below the viewport. Defaults
+   * to 6.
+   *
+   * Raise it to trade memory for a scroll that stays painted — fast wheel or
+   * touch flings can outrun the virtualizer and flash blank rows, and a larger
+   * buffer covers the gap. Lower it when rows are expensive to render.
+   */
+  overscan?: number;
 };
 /**
  * Builds a TMDataGrid table plus its chrome store.
@@ -468,13 +1134,50 @@ 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, enableColumnOrdering, enablePagination, rowSelectionMode, highlightSelectedRows, ...options }: UseTMDataGridOptions<TData>): TMDataGridApi<TData>;
+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>;
 /**
  * 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.
  */
 declare function openColumnFilter<TData extends RowData>(api: TMDataGridApi<TData>, columnId: string): void;
 //#endregion
+//#region .types-tmp/components/TMDataGridFilterPills.d.ts
+type TMDataGridFilterPillsProps<TData extends RowData> = {
+  /** The object returned by `useTMDataGrid`. */
+  api: TMDataGridApi<TData>;
+  /** Mantine size of the pills. Defaults to `"sm"`. */
+  size?: TMDataGridSize;
+  /** "Clear all" button, shown once two filters are active. Defaults to `true`. */
+  showClearAll?: boolean;
+  /**
+   * Replaces what a click on a pill's label does. The default opens the grid's
+   * filter panel on that column.
+   */
+  onPillClick?: (columnId: string) => void;
+  className?: string;
+};
+/**
+ * One pill per active filter — `First name: Sofia ✕` — with the ✕ clearing that
+ * filter and a click on the label opening the filter panel on its column.
+ *
+ * The one grid component that takes the api as a prop instead of reading
+ * context, so it can live anywhere: a page header, a card title, a breadcrumb
+ * row. Renders nothing while no filter is active.
+ *
+ * ```tsx
+ * const grid = useTMDataGrid({ data, columns });
+ *
+ * <Group>
+ *   <Title order={3}>Employees</Title>
+ *   <TMDataGridFilterPills api={grid} />
+ * </Group>
+ * ```
+ *
+ * Half-typed filters are left out: a filter that is not narrowing the rows yet
+ * has nothing to report, which is the same rule the funnel indicator uses.
+ */
+declare function TMDataGridFilterPills<TData extends RowData>({ api, size, showClearAll, onPillClick, className }: TMDataGridFilterPillsProps<TData>): import("react").JSX.Element | null;
+//#endregion
 //#region .types-tmp/components/TMDataGridFooter.d.ts
 /** Distilled pagination state and actions for building a custom pager. */
 type TMDataGridPaginationApi = {
@@ -515,6 +1218,171 @@ type TMDataGridFooterProps = {
  */
 declare function TMDataGridFooter({ pageSizeOptions, pagination }: TMDataGridFooterProps): import("react").JSX.Element | null;
 //#endregion
+//#region .types-tmp/components/TMDataGridSearch.d.ts
+type TMDataGridSearchProps = {
+  /** Defaults to `labels.searchPlaceholder`. */
+  placeholder?: string;
+  /**
+   * How long typing pauses before the filter is applied, in ms. Defaults to
+   * 250. `0` writes on every keystroke — what the tests use, and fine for
+   * small client-side data sets.
+   */
+  debounce?: number;
+  /** Width of the input. Defaults to 220. */
+  w?: number | string;
+};
+/**
+ * Quick search over every column — a debounced input writing the table's
+ * `globalFilter` state through the `"includesString"` filter the grid
+ * configures by default.
+ *
+ * ```tsx
+ * <TMDataGrid.Toolbar>
+ *   <TMDataGrid.Search />
+ *   <TMDataGrid.Spacer />
+ *   <TMDataGrid.FilterButton />
+ * </TMDataGrid.Toolbar>
+ * ```
+ *
+ * Renders nothing under `enableGlobalFilter: false`. Columns opt out with
+ * their own `enableGlobalFilter: false` — the generated lanes already do.
+ *
+ * The state is TanStack's `globalFilter`, so everything around it comes free:
+ * `manualFiltering` grids forward it to the server, and it is one of the
+ * persisted `data` slices. A grid that wants its own input entirely writes
+ * `table.setGlobalFilter` itself — this component is only the built-in one.
+ */
+declare function TMDataGridSearch({ placeholder, debounce, w }: TMDataGridSearchProps): import("react").JSX.Element | null;
+//#endregion
+//#region .types-tmp/core/cellExport.d.ts
+/** The selected block, flattened to text. One inner array per row. */
+type TMDataGridCellMatrix = Array<Array<string>>;
+/**
+ * How values are written out.
+ *
+ * The defaults are the Nordic ones, because they are the ones that need
+ * choosing: an Excel running a Swedish, Norwegian, Danish or Finnish locale
+ * reads `;` as its list separator and `,` as its decimal mark, and a file
+ * written the other way opens as one column of text. Both are settable for a
+ * grid whose users run something else.
+ */
+type TMDataGridCellExportOptions = {
+  /** CSV field separator. Defaults to `";"`. */
+  separator?: string;
+  /** Write numbers as `1,5` rather than `1.5`. Defaults to `true`. */
+  decimalComma?: boolean;
+  /** Column labels as the first row. Defaults to `true`. */
+  includeHeaders?: boolean;
+  /** Without extension. Defaults to `"export"`. */
+  fileName?: string;
+};
+type ResolvedExportOptions = Required<TMDataGridCellExportOptions>;
+declare const DEFAULT_CELL_EXPORT_OPTIONS: ResolvedExportOptions;
+/**
+ * One value as text.
+ *
+ * Deliberately not the rendered cell: what a cell renders is React, and often a
+ * badge, a link or an icon rather than the value. The value is what a
+ * spreadsheet wants, and it is the one thing every column is guaranteed to
+ * have.
+ */
+declare function formatExportValue(value: unknown, { decimalComma }: {
+  decimalComma: boolean;
+}): string;
+type BuildCellMatrixArgs = {
+  rows: ReadonlyArray<Row<TMDataGridFeatures, TMDataGridRowData>>;
+  /** Every visible column, in render order — the same list the bounds index into. */
+  columns: ReadonlyArray<Column<TMDataGridFeatures, TMDataGridRowData, unknown>>;
+  bounds: TMDataGridRangeBounds;
+  includeHeaders: boolean;
+  decimalComma: boolean;
+};
+/**
+ * The selected rectangle as rows of text.
+ *
+ * The generated lanes — the checkbox, the tree chevron, the details chevron —
+ * are dropped even when the rectangle covers them. They hold controls rather
+ * than data, so a column of empty strings is all they could contribute, and
+ * pasting one into a spreadsheet only shifts everything to its right.
+ */
+declare function buildCellMatrix({ rows, columns, bounds, includeHeaders, decimalComma }: BuildCellMatrixArgs): TMDataGridCellMatrix;
+/**
+ * The whole grid as rows of text: every filtered and sorted data row — all
+ * pages, not the one on screen — by every visible non-control column, in
+ * render order.
+ *
+ * The values are the same ones a cell-range export writes; only the bounds
+ * differ. Group rows are left out (their records are the rows themselves),
+ * and hidden columns are not exported — what you see is what you get, minus
+ * paging.
+ */
+declare function buildGridCellMatrix<TData extends RowData>({ table, includeHeaders, decimalComma }: {
+  table: TMDataGridTable<TData>;
+  includeHeaders?: boolean;
+  decimalComma?: boolean;
+}): TMDataGridCellMatrix;
+/**
+ * Downloads the whole grid as a CSV for Excel — {@link buildGridCellMatrix}
+ * through {@link toExcelCsv}, with the same Nordic defaults and overrides as
+ * the cell-range export.
+ *
+ * No built-in button: wire it to your own toolbar.
+ *
+ * ```tsx
+ * <Button onClick={() => exportGridToCsv({ table: grid.table })}>Export</Button>
+ * ```
+ */
+declare function exportGridToCsv<TData extends RowData>({ table, options }: {
+  table: TMDataGridTable<TData>;
+  options?: TMDataGridCellExportOptions;
+}): void;
+/**
+ * The clipboard format spreadsheets read: tab between cells, CRLF between rows.
+ *
+ * Tabs rather than commas because that is what Excel, Sheets and Numbers all
+ * put on the clipboard themselves — paste it and the cells land in cells. A
+ * comma-separated string pastes into a single column, which is the thing this
+ * exists to avoid.
+ */
+declare function toClipboardText(matrix: TMDataGridCellMatrix): string;
+/**
+ * A CSV that opens straight into columns in Excel.
+ *
+ * Three things make that true, and all three are needed:
+ *
+ * | Part | Why |
+ * | ---- | --- |
+ * | `sep=;` first line | Excel's own directive — it stops guessing and uses this |
+ * | UTF-8 BOM | without it Excel reads the file as ANSI, and å ä ö arrive broken |
+ * | CRLF line endings | what Excel writes, and what its importer is happiest with |
+ *
+ * The `sep=` line is Excel's alone; other readers show it as a first row. That
+ * is the trade this makes — the file is for Excel, and "it just opens" is worth
+ * more than being a well-behaved CSV nobody was going to feed to a parser.
+ */
+declare function toExcelCsv(matrix: TMDataGridCellMatrix, { separator }: {
+  separator: string;
+}): string;
+/**
+ * Puts text on the clipboard, reporting whether it landed.
+ *
+ * The async clipboard API only resolves for a document that has the focus and a
+ * user gesture behind it — both true when this runs off Ctrl+C or a menu item.
+ * It is still allowed to reject (a permissions policy, a page that lost focus
+ * mid-copy), so the result is a boolean rather than a promise nobody checks.
+ */
+declare function writeClipboardText(text: string): Promise<boolean>;
+/**
+ * Downloads text as a file, through the one mechanism a library can use: an
+ * anchor with an object URL behind it, clicked. Revoked on the next frame —
+ * immediately would race the browser's own read of it.
+ */
+declare function downloadTextFile({ fileName, text, mimeType }: {
+  fileName: string;
+  text: string;
+  mimeType?: string;
+}): void;
+//#endregion
 //#region .types-tmp/components/TMDataGridTable.d.ts
 /** Where a column sits relative to the pinned regions, resolved once per render. */
 type TMDataGridColumnLayout = {
@@ -524,12 +1392,117 @@ type TMDataGridColumnLayout = {
   /** Last left-pinned / first right-pinned column — the one that casts the edge. */
   isBoundary: boolean;
 };
+/**
+ * What a cell needs to take part in cell selection, or `undefined` while the
+ * feature is off — which is what keeps a plain grid's cells exactly as they
+ * were: no tab stop, no `gridcell` role, no coordinates in the DOM.
+ *
+ * The coordinates are there for the delegated key handler, which reads them off
+ * `event.target` rather than closing over per-cell state, and for the effect
+ * that puts DOM focus where {@link TMDataGridUiState.focusedCell} says.
+ */
+type TMDataGridCellNav = {
+  rowId: string;
+  /** 1-based, for `aria-colindex`. */
+  columnIndex: number;
+  focused: boolean;
+  /** The roving tab stop: `0` on exactly one mounted cell, `-1` on the rest. */
+  tabIndex: 0 | -1;
+  /** Inside the selected rectangle. Always `false` under `"single"`. */
+  selected: boolean;
+  /**
+   * Which sides of the rectangle this cell is on, or `null` when it is not in
+   * one. The outline is drawn per cell — see {@link boundsEdges}.
+   */
+  edges: {
+    top: boolean;
+    bottom: boolean;
+    left: boolean;
+    right: boolean;
+  } | null;
+};
+/** What a `rowContextMenu` render prop is handed for the right-clicked row. */
+type TMDataGridRowContextMenuArgs<TData extends RowData> = {
+  table: Table<TMDataGridFeatures, TData>;
+  row: Row<TMDataGridFeatures, TData>;
+  /**
+   * The cell under the pointer. `null` only when the right-click landed on the
+   * row but on no cell — which a custom cell renderer that stops propagation
+   * can cause.
+   */
+  cell: Cell<TMDataGridFeatures, TData, unknown> | null;
+  /**
+   * Closes the menu. `Menu.Item` already closes on click (Mantine's
+   * `closeOnItemClick`), so this is for content that isn't a menu item.
+   */
+  close: () => void;
+};
+/**
+ * Builds the contents of a row's context menu — `Menu.Item`, `Menu.Label`,
+ * `Menu.Divider`, `Menu.Sub`, or any other node. The grid owns the `Menu` and
+ * its `Menu.Dropdown`; this fills the dropdown.
+ */
+type TMDataGridRowContextMenu<TData extends RowData> = (args: TMDataGridRowContextMenuArgs<TData>) => ReactNode;
 type TMDataGridTableProps<TData extends RowData> = {
   /**
    * Called when a body row is clicked. Runs in addition to row selection under
-   * `rowSelectionMode: "row"`, not instead of it.
+   * `selectionMode: "row"`, not instead of it.
    */
   onRowClick?: (row: Row<TMDataGridFeatures, TData>) => void;
+  /**
+   * 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
+   * either way.
+   *
+   * ```tsx
+   * <TMDataGrid.Table<Employee>
+   *   rowContextMenu={({ row, close }) => (
+   *     <>
+   *       <Menu.Label>{row.original.firstName}</Menu.Label>
+   *       <Menu.Item onClick={() => open(row.original.id)}>Open</Menu.Item>
+   *       <Menu.Divider />
+   *       <Menu.Item color="red" onClick={() => remove(row.original.id)}>
+   *         Delete
+   *       </Menu.Item>
+   *     </>
+   *   )}
+   * />
+   * ```
+   *
+   * Called during render, and only for the row whose menu is open — so it stays
+   * a pure function of the row, and cost per row does not matter.
+   */
+  rowContextMenu?: TMDataGridRowContextMenu<TData>;
+  /**
+   * Passed to the Mantine `Menu` the grid wraps the row in — `width`, `shadow`,
+   * `position`, `transitionProps` and the rest. Its open state is the grid's.
+   */
+  rowContextMenuProps?: Omit<MenuProps, "opened" | "onChange" | "children">;
+  /**
+   * How Ctrl+C and the export item write values, under
+   * `cellSelection: "range"`. Defaults to the Nordic Excel conventions — see
+   * {@link TMDataGridCellExportOptions}.
+   */
+  cellExport?: TMDataGridCellExportOptions;
+  /**
+   * Called when the scroll approaches the last row — the infinite-scroll
+   * hook-in. Append the next page to `data` and the virtualizer keeps its
+   * position; fires once per row count, so a pending fetch is not asked
+   * again until it lands.
+   *
+   * ```tsx
+   * <TMDataGrid.Table onReachEnd={() => query.fetchNextPage()} />
+   * ```
+   *
+   * Sorting and filtering must be server-side (`manual*`) on a grid that
+   * loads this way — the client only ever holds a prefix of the data. Not
+   * compatible with `enablePagination`, which slices the same scroll.
+   */
+  onReachEnd?: () => void;
+  /**
+   * How many rows before the end {@link onReachEnd} fires at. Defaults to 10.
+   */
+  reachEndThreshold?: number;
 };
 /**
  * The scrollable grid surface. Always virtualized: only the rows inside the
@@ -537,7 +1510,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 }: TMDataGridTableProps<TData>): import("react").JSX.Element;
+declare function TMDataGridTable$1<TData extends RowData = TMDataGridRowData>({ onRowClick, rowContextMenu, rowContextMenuProps, cellExport, onReachEnd, reachEndThreshold }: 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. */
@@ -546,6 +1519,24 @@ declare function TMDataGridToolbar({ children }: {
 }): import("react").JSX.Element;
 /** Pushes the following toolbar items to the right. */
 declare function TMDataGridToolbarSpacer(): import("react").JSX.Element;
+/**
+ * A small spinner shown while `meta.loading` is true, and nothing otherwise.
+ *
+ * The body only shows its loading state while the grid is *empty* — a
+ * server-driven grid refetching with rows on screen keeps showing them, which
+ * is right, but leaves nothing saying a fetch is running. This is that signal,
+ * and the consumer decides where it sits by placing it in the toolbar:
+ *
+ * ```tsx
+ * <TMDataGrid.Toolbar>
+ *   <TMDataGrid.SummaryCount />
+ *   <TMDataGrid.Spacer />
+ *   <TMDataGrid.LoadingIndicator />
+ *   <TMDataGrid.FilterButton />
+ * </TMDataGrid.Toolbar>
+ * ```
+ */
+declare function TMDataGridLoadingIndicator(): import("react").JSX.Element | null;
 /**
  * Visible rows over total rows. On a server-driven grid, set
  * `meta.totalRowCount` for the denominator — the client never sees every row.
@@ -598,17 +1589,24 @@ type TMDataGridProps<TData extends RowData> = TMDataGridApi<TData> & {
  * </TMDataGrid>
  * ```
  */
-declare function TMDataGridRoot<TData extends RowData>({ table, ui, features, size, children, className, style }: TMDataGridProps<TData>): import("react").JSX.Element;
+declare function TMDataGridRoot<TData extends RowData>({ table, ui, features, labels, renderDetails, renderDetailsEstHeight, overscan, size, children, className, style }: 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;
   ColumnsButton: typeof TMDataGridColumnsButton;
   FilterButton: typeof TMDataGridFilterButton;
   Table: typeof TMDataGridTable$1;
   Footer: typeof TMDataGridFooter;
   /** Rendered by `TMDataGrid.Table`; exported for custom layouts. */
   FilterPanel: typeof TMDataGridFilterPanel;
+  /**
+   * Takes the grid as an `api` prop rather than from context, so it can be
+   * rendered outside `<TMDataGrid>` — a page header, for instance.
+   */
+  FilterPills: typeof TMDataGridFilterPills;
   /** Rendered by `TMDataGrid.ColumnsButton`; exported for custom layouts. */
   ColumnsPanel: typeof TMDataGridColumnsPanel;
 };
@@ -616,6 +1614,33 @@ declare const TMDataGrid: typeof TMDataGridRoot & {
 //#region .types-tmp/components/TMDataGridSelectColumn.d.ts
 declare const SELECT_COLUMN_ID = "__select__";
 //#endregion
+//#region .types-tmp/components/TMDataGridDetailsColumn.d.ts
+declare const DETAILS_COLUMN_ID = "__details__";
+//#endregion
+//#region .types-tmp/components/TMDataGridGroupColumn.d.ts
+declare const GROUP_COLUMN_ID = "__group__";
+/**
+ * How a grouping value is written into the tree cell.
+ *
+ * Deliberately not the grouped column's own `cell` renderer: that renderer is
+ * written for a data row and is free to reach into `row.original`, which on a
+ * group row is the first leaf's record rather than anything about the group.
+ */
+declare function formatGroupValue(value: unknown, blankLabel?: string): string;
+//#endregion
+//#region .types-tmp/core/labelsSv.d.ts
+/**
+ * The complete Swedish dictionary. Typed as {@link TMDataGridLabels} rather
+ * than as an override, so a label added to the grid without a Swedish
+ * translation is a compile error here instead of English quietly leaking
+ * through.
+ *
+ * ```tsx
+ * useTMDataGrid({ data, columns, labels: TMDATAGRID_LABELS_SV });
+ * ```
+ */
+declare const TMDATAGRID_LABELS_SV: TMDataGridLabels;
+//#endregion
 //#region .types-tmp/core/columnUtils.d.ts
 /**
  * Structural shape of the column bits the chrome reads. Kept minimal so these
@@ -634,6 +1659,19 @@ type ColumnLike = {
 /** Menu- and panel-facing column name. */
 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.
+ *
+ * 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.
+ *
+ * The tree column is deliberately not one of them: it holds a label as well as a
+ * chevron, and wants the padding.
+ */
+declare function isControlColumn(columnId: string): boolean;
 /**
  * Whether a column may be moved. Ordering is the one column feature TanStack
  * has no column option for, so the switch lives in `meta.enableOrdering`.
@@ -644,6 +1682,116 @@ declare function getColumnType(column: ColumnLike): TMDataGridColumnType;
  */
 declare function isColumnReorderable(column: ColumnLike): boolean;
 //#endregion
+//#region .types-tmp/core/grouping.d.ts
+/**
+ * The data rows under a group row, at any depth.
+ *
+ * Not `row.getLeafRows()`, despite the name: that flattens the whole subtree
+ * and keeps the branches, so a group nested two deep reports its sub-groups
+ * alongside the records. Grouping `city` then `name` would have Stockholm
+ * counting four rows and three names as seven, and one tick on it selecting
+ * ids that hold no record.
+ *
+ * A row with no subRows is a data row, which also makes this the identity on an
+ * ungrouped grid.
+ */
+declare function getGroupDataRows<TData extends RowData>(row: Row<TMDataGridFeatures, TData>): Array<Row<TMDataGridFeatures, TData>>;
+//#endregion
+//#region .types-tmp/core/summary.d.ts
+/** The registered aggregation names — the same set `aggregationFn` accepts. */
+type TMDataGridAggregationName = keyof typeof aggregationFns;
+/**
+ * One column aggregated over every filtered row — the number a summary-row
+ * `footer` wants:
+ *
+ * ```tsx
+ * columnHelper.accessor("salary", {
+ *   footer: ({ table }) => sek(Number(aggregateColumn({ table, columnId: "salary" }))),
+ * });
+ * ```
+ *
+ * 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"`.
+ */
+declare function aggregateColumn<TData extends RowData>({ table, columnId, fn }: {
+  table: TMDataGridTable<TData>;
+  columnId: string;
+  fn?: TMDataGridAggregationName;
+}): unknown;
+//#endregion
+//#region .types-tmp/core/autosize.d.ts
+/**
+ * Widest rendered content of one column, in px, measured from the DOM.
+ *
+ * Mounted cells only: under virtualization the unmounted rows do not exist to
+ * be measured, so this reads the visible window plus overscan — the same
+ * trade AG Grid's autosize makes by default.
+ */
+declare function measureColumnContentWidth({ container, columnId }: {
+  /** The grid's scroll container — anything enclosing the column's cells. */
+  container: HTMLElement;
+  columnId: string;
+}): number;
+/**
+ * Sizes a column to its widest mounted content — what double-clicking the
+ * resize divider does, exported so a menu item or consumer code can trigger
+ * the same thing.
+ *
+ * The width lands in `columnSizing`, so it persists with the other widths and
+ * a later resize drag takes over from it. Clamped to the column's
+ * `minSize`/`maxSize`; a no-op (returning `false`) for a column that cannot
+ * be resized or has nothing mounted to measure.
+ */
+declare function autosizeColumn<TData extends RowData>({ table, columnId, container }: {
+  table: TMDataGridTable<TData>;
+  columnId: string;
+  container: HTMLElement;
+}): boolean;
+//#endregion
+//#region .types-tmp/core/expanding.d.ts
+/**
+ * Which rows an expand-all control is about.
+ *
+ * TanStack keeps one `expanded` state, and the grid opens two unrelated things
+ * out of it: a group row opens into its children, a data row opens into its
+ * detail panel. So `toggleAllRowsExpanded` — which writes the state's
+ * whole-table form — is the wrong verb for either control. "Expand all groups"
+ * in the tree menu would open every panel in the grid, and the details lane's
+ * chevron would unfold the whole tree.
+ *
+ * These helpers narrow both to the rows their control is for, and leave the
+ * other kind exactly as it was.
+ */
+type TMDataGridExpandTarget = "groups" | "details";
+type TMDataGridExpandAllArgs<TData extends RowData> = {
+  /**
+   * Every row in the model, groups and records alike — `flatRows` off any of
+   * them. A grouped model lists its leaves both under their group and in the
+   * flat list, so this may repeat rows; both helpers are written so that a
+   * repeat costs nothing.
+   */
+  rows: ReadonlyArray<Row<TMDataGridFeatures, TData>>;
+  expanded: ExpandedState;
+  target: TMDataGridExpandTarget;
+};
+/**
+ * Whether every row of this kind is open — what the control shows, and what a
+ * bare toggle inverts.
+ *
+ * `false` when there are none of them, matching TanStack's own
+ * `getIsAllRowsExpanded()` on an empty state: an empty set is nothing to
+ * collapse.
+ */
+declare function areAllRowsExpanded<TData extends RowData>({ rows, expanded, target }: TMDataGridExpandAllArgs<TData>): boolean;
+/**
+ * The next `expanded` state after an expand-all or collapse-all on one kind of
+ * row. Rows of the other kind keep whatever they had.
+ */
+declare function resolveExpandAll<TData extends RowData>({ rows, expanded, target, expand }: TMDataGridExpandAllArgs<TData> & {
+  expand: boolean;
+}): ExpandedState;
+//#endregion
 //#region .types-tmp/core/columnOrdering.d.ts
 type GridColumn = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
 type GridTable = TMDataGridTable<TMDataGridRowData>;
@@ -694,4 +1842,99 @@ declare function getStepTargetColumn({ table, columnId, direction }: ColumnStepA
 /** Moves a column one position within its lane. Hidden columns are stepped over. */
 declare function moveColumnByStep({ table, columnId, direction }: ColumnStepArgs): void;
 //#endregion
-export { type ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_TMDATAGRID_SIZE, FILTER_OPERATOR_LABELS, type MoveColumnArgs, SELECT_COLUMN_ID, SETTINGS_STATE_SLICES, SIZE_CONTROL_SIZE, SIZE_ROW_HEIGHT, TMDataGrid, type TMDataGridApi, type TMDataGridCapabilities, type TMDataGridColumnCapabilities, type TMDataGridColumnLayout, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnType, type TMDataGridContextValue, type TMDataGridDataSlice, type TMDataGridDropSide, type TMDataGridFeatureFlags, type TMDataGridFeatures, type TMDataGridFilterOperator, type TMDataGridFilterValue, type TMDataGridFooterProps, type TMDataGridPaginationApi, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridRowData, type TMDataGridRowSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridUiActions, type TMDataGridUiState, type TMDataGridUiStore, type UseTMDataGridOptions, createTMDataGridColumnHelper, getColumnCapabilities, getColumnLabel, getColumnRegion, getColumnType, getGridCapabilities, getStepTargetColumn, getTMDataGridPaginationApi, isColumnReorderable, isFilterActive, moveColumn, moveColumnByStep, openColumnFilter, readFeatureFlags, tmDataGridFeatures, useTMDataGrid, useTMDataGridContext };
+//#region .types-tmp/core/rowSelection.d.ts
+/**
+ * Rows in the order they are displayed, which is the order a shift-click range
+ * is measured over — so a range follows the active sort and skips filtered-out
+ * rows. Under pagination it is the current page, so a range cannot cross a page
+ * boundary.
+ *
+ * Once a column is grouped this includes the group rows, and only the leaves of
+ * groups that are open — and paging is suspended, so it is the whole tree. That
+ * 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}.
+ */
+declare function getDisplayedRows<TData extends RowData>(table: TMDataGridTable<TData>, features: TMDataGridFeatureFlags): Array<Row<TMDataGridFeatures, TData>>;
+/**
+ * Whether the built-in pager is actually slicing anything.
+ *
+ * Grouping suspends it. A page can only count one kind of thing, and once the
+ * rows are a tree neither answer works: counting every row splits a group
+ * across a page boundary and strands the rest of the tree on pages the user has
+ * to go looking for, and counting only the top-level rows quietly redefines
+ * "rows per page" as groups per page, so a page of 25 can hold thousands of
+ * rows. Rather than pick, the grid renders the whole tree and leans on the
+ * virtualizer — which is its default mode anyway, pagination being opt-in.
+ *
+ * `TMDataGrid.Footer` reads this too, and greys the pager out rather than
+ * hiding it, so the pager going quiet is visible instead of mysterious.
+ */
+declare function isPagingActive<TData extends RowData>(table: TMDataGridTable<TData>, features: TMDataGridFeatureFlags): boolean;
+/**
+ * Which modifiers were held. Named for what they mean rather than for the keys,
+ * because the keys differ per platform — `toggle` is Ctrl on Windows/Linux and
+ * Cmd on macOS.
+ */
+type TMDataGridRowClickModifiers = {
+  toggle: boolean;
+  extend: boolean;
+};
+type ResolveRowSelectionClickArgs<TData extends RowData> = {
+  /** Displayed order — see {@link getDisplayedRows}. */
+  rows: ReadonlyArray<Row<TMDataGridFeatures, TData>>;
+  rowId: string;
+  /** The pivot a shift-click extends from. */
+  anchorRowId: string | null;
+  modifiers: TMDataGridRowClickModifiers;
+  selection: RowSelectionState;
+  /**
+   * Whether this gesture is allowed to clear rows it did not touch.
+   *
+   * `true` for a bare row click, where replacing is the whole point. `false` for
+   * a checkbox, which is only ever additive — ticking one box has never cleared
+   * the others, and shift-clicking one adds the range rather than becoming it.
+   */
+  canReplaceSelection: boolean;
+};
+type ResolvedRowSelection = {
+  selection: RowSelectionState;
+  anchorRowId: string | null;
+};
+/**
+ * The row ids one gesture on this row selects.
+ *
+ * A group row is never selected itself: it holds no record, and TanStack
+ * derives its checked state from its descendants. So ticking a group means
+ * ticking every selectable leaf under it, which is also what makes the group's
+ * own box light up.
+ *
+ * Leaves rather than direct children, so one click on a top-level group takes
+ * the whole subtree however deeply it nests.
+ */
+declare function getSelectableRowIds<TData extends RowData>(row: Row<TMDataGridFeatures, TData>): Array<string>;
+/**
+ * Turns one click into the next selection, following the convention every
+ * desktop list uses:
+ *
+ * | Gesture | Effect |
+ * | ------- | ------ |
+ * | Click | selection becomes only this row |
+ * | Ctrl/Cmd + click | toggle this row, leave the rest |
+ * | Shift + click | selection becomes the range anchor → this row |
+ * | Ctrl/Cmd + Shift + click | add that range to the selection |
+ *
+ * The anchor is a *pivot*, not "the last row touched": only a plain or
+ * Ctrl-click moves it, which is what lets a run of shift-clicks grow and shrink
+ * the same range from a fixed point.
+ *
+ * Selection state is rebuilt here and handed to `setRowSelection` wholesale
+ * rather than going through `row.toggleSelected()` per row, which would publish
+ * one state update each. That skips TanStack's sub-row cascade, so the cascade
+ * is done here instead: every row in the gesture is expanded through
+ * {@link getSelectableRowIds} before it reaches the map. Under grouping that is
+ * what makes one tick on a group select all of it.
+ */
+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 };