@jielga/tmdatagrid 2.0.0-beta.13 → 2.0.0-beta.15

package/dist/index.d.ts

@@ -1,62 +1,9 @@
-import { MantineSize, MenuProps } from "@mantine/core";
+import { BoxProps, MantineSize, MenuProps } from "@mantine/core";
 import { CSSProperties, ComponentType, MouseEvent, MutableRefObject, ReactNode } from "react";
 import { Cell, Column, ColumnFiltersState, ColumnPinningState, ExpandedState, Header, Row, RowData, RowSelectionState, Table, TableFeatures, TableOptions, TableState, aggregationFns } from "@tanstack/react-table";
 import { Store } from "@tanstack/store";
 import { AnyFieldApi, AnyFormApi, StandardSchemaV1 } from "@tanstack/react-form";
 import { RankingInfo } from "@tanstack/match-sorter-utils";
-//#region .types-tmp/components/TMDataGridMenu.d.ts
-type TMDataGridMenuProps = Omit<MenuProps, "children"> & {
-  /** The dropdown's content: Mantine `Menu.Item`s and the `TMDataGrid.Menu.*` items. */
-  children: ReactNode;
-  /** Replaces the burger icon on the trigger. */
-  icon?: ReactNode;
-  /** Tooltip and `aria-label` of the trigger. Default `labels.menuButton`. */
-  label?: string;
-};
-type TMDataGridMenuColumnsProps = {
-  /** Renders a `Menu.Search` above the toggles. Default `true`. Use `false` inside a `Menu.Sub`. */
-  searchable?: boolean;
-};
-/**
- * The whole column chooser as menu items: a search box, one checkbox item per
- * hideable column, show/hide all, and Reset layout. Renders nothing when no
- * column can be hidden.
- *
- * `searchable` is only for a block at the top level of a dropdown.
- * `Menu.Search` registers on the root menu context (`hasSearch`), which
- * switches off type-ahead and the arrow-key handling of every dropdown of that
- * menu, so a search inside a `Menu.Sub` breaks the parent menu's keyboard
- * behaviour.
- */
-declare function TMDataGridMenuColumns({ searchable }: TMDataGridMenuColumnsProps): import("react").JSX.Element | null;
-/**
- * One checkbox item per hideable column, narrowed to `search` when one is
- * given. Renders nothing when no column can be hidden.
- */
-declare function TMDataGridMenuColumnToggles({ search }: {
-  search?: string;
-}): import("react").JSX.Element | null;
-/**
- * Shows or hides every listed column at once. Renders nothing when no column
- * can be hidden.
- */
-declare function TMDataGridMenuShowHideAll(): import("react").JSX.Element | null;
-/**
- * Resets the whole layout, not only visibility: order, widths, pinning and
- * grouping go back too. Not `table.resetColumnVisibility()`, which resets to
- * `initialState` - and under persistence the mount built that *from* the
- * persisted payload.
- */
-declare function TMDataGridMenuResetLayout(): import("react").JSX.Element;
-//#endregion
-//#region .types-tmp/components/TMDataGridColumnsPanel.d.ts
-/**
- * The "Manage columns" surface as plain controls, for a host that is not a
- * menu - a Popover, a Drawer, an inline layout. `TMDataGrid.Menu.Columns` is
- * the same chooser as menu items.
- */
-declare function TMDataGridColumnsPanel(): import("react").JSX.Element;
-//#endregion
 //#region .types-tmp/core/sizes.d.ts
 type TMDataGridSize = MantineSize;
 declare const DEFAULT_TMDATAGRID_SIZE: TMDataGridSize;
@@ -150,100 +97,6 @@ type ComboboxData = Array<ComboboxItem | {
  */
 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.
- *
- * TanStack resolves `filterFn` statically per column, so the operator travels
- * inside the filter *value* instead. That keeps the filter model plain,
- * serialisable JSON, so a server-side `manualFiltering` table can forward
- * `columnFilters` to the API unchanged.
- *
- * `value` is a string array under `isAnyOf` / `isNoneOf` (the set the cell is
- * tested against), a `[min, max]` pair under `between` (an empty string means
- * that end is open), and a single string everywhere else - dates travel as
- * ISO `YYYY-MM-DD` strings, booleans as `"true"` / `"false"`. Still plain
- * JSON.
- */
-type TMDataGridFilterValue = {
-  operator: TMDataGridFilterOperator;
-  value: string | ReadonlyArray<string>;
-};
-type TMDataGridColumnType = "string" | "number" | "boolean" | "date" | "select" | "multiSelect";
-type TMDataGridFilterOperator = "contains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "between" | "before" | "after" | "onOrBefore" | "onOrAfter" | "isAnyOf" | "isNoneOf" | "isEmpty" | "isNotEmpty";
-declare const FILTER_OPERATOR_LABELS: Record<TMDataGridFilterOperator, string>;
-declare function getOperatorsForType(type: TMDataGridColumnType): readonly TMDataGridFilterOperator[];
-declare function getDefaultOperator(type: TMDataGridColumnType): TMDataGridFilterOperator;
-declare function operatorNeedsValue(operator: TMDataGridFilterOperator): boolean;
-/** Whether the operator's value is a string array - `isAnyOf` / `isNoneOf`. */
-declare function operatorTakesArrayValue(operator: TMDataGridFilterOperator): boolean;
-/** Whether the operator's value is a `[min, max]` pair - `between`. */
-declare function operatorTakesRangeValue(operator: TMDataGridFilterOperator): boolean;
-/** The untouched value a fresh filter starts with - the operator's shape, empty. */
-declare function emptyValueForOperator(operator: TMDataGridFilterOperator): string | ReadonlyArray<string>;
-/**
- * The three value shapes an operator can take. A set is not a range, even
- * though both are arrays.
- */
-type TMDataGridFilterValueShape = "scalar" | "set" | "range";
-/**
- * Which shape an operator's value takes. A typed value survives an operator or
- * column change only within its shape, which is the rule both the panel and
- * the header controls use when the operator changes.
- */
-declare function filterValueShape(operator: TMDataGridFilterOperator): TMDataGridFilterValueShape;
-/**
- * A filter only narrows the row set once it has something to compare against.
- * Half-typed filters stay in state (so the panel keeps rendering their row) but
- * are treated as inactive for the funnel indicator and for row matching.
- */
-declare function isFilterActive(value: unknown): boolean;
-/** One column's filter, typed - what `columnFilters` holds per entry. */
-type TMDataGridColumnFilter = {
-  id: string;
-  value: TMDataGridFilterValue;
-};
-/**
- * The column filters that are actually narrowing the grid, typed.
- *
- * `ColumnFiltersState` types `value` as `unknown`, so the first line of a
- * server-side mapping layer is otherwise a cast back to the shape the grid
- * itself wrote, wrapped in the same "drop the half-typed ones" filter every
- * consumer writes:
- *
- * ```ts
- * const predicates = activeColumnFilters(table).map((filter) =>
- *   toPredicate(filter.id, filter.value),
- * );
- * ```
- *
- * Takes the table, or a `columnFilters` array where the consumer owns the
- * slice. Reading it from the table reads the current value and does not
- * subscribe; inside a component, subscribe to `columnFilters` the way the
- * grid's own chrome does.
- */
-declare function activeColumnFilters<TData extends RowData>(source: TMDataGridTable<TData> | ColumnFiltersState): Array<TMDataGridColumnFilter>;
-/**
- * One-line description of a single filter, as shown on a filter pill.
- *
- * The type's default operator is left implicit - "First name: Sofia" reads the
- * way a person would say it - while any other operator is spelled out, since
- * that is the part a reader cannot guess.
- */
-declare function formatFilterLabel({ label, type, filter, operatorLabels }: {
-  label: string;
-  type: TMDataGridColumnType;
-  filter: TMDataGridFilterValue;
-  /** Localized operator names - `labels.operators`. Defaults to English. */
-  operatorLabels?: Record<TMDataGridFilterOperator, string>;
-}): string;
-/**
- * The single filter function every TMDataGrid column uses. It dispatches on the
- * operator carried by the filter value, which is what lets one column offer
- * "contains" / "does not equal" / "is empty" without redefining the column.
- */
-declare function tmDataGridFilterFn<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown): boolean;
-//#endregion
 //#region .types-tmp/core/editEngine.d.ts
 /**
  * What counts as a commit - one axis, each mode a thin policy over the same
@@ -451,8 +304,8 @@ type TMDataGridEditState = {
   /** The draft store's delete slice: rows marked deleted, awaiting the save. */
   deletedRowIds: ReadonlyArray<string>;
 };
-type ErasedRow = Row<TMDataGridFeatures, TMDataGridRowData>;
-type ErasedColumn = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
+type ErasedRow$1 = Row<TMDataGridFeatures, TMDataGridRowData>;
+type ErasedColumn$1 = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
 /**
  * What a cell editor is handed - deliberately both vocabularies at once. The
  * form side is TanStack Form's real `field` API (`field.state.value`,
@@ -470,8 +323,8 @@ type TMDataGridEditorArgs = {
   /** The whole row form, for the rare editor that reads sibling fields. */
   form: TMDataGridRowEditForm;
   cell: Cell<TMDataGridFeatures, TMDataGridRowData, unknown>;
-  row: ErasedRow;
-  column: ErasedColumn;
+  row: ErasedRow$1;
+  column: ErasedColumn$1;
   table: TMDataGridTable<TMDataGridRowData>;
   /** What Enter would do - commit the edit. For the editor's own UI. */
   commit: () => Promise<boolean>;
@@ -496,8 +349,8 @@ type TMDataGridEditValueMapArgs = {
   value: unknown;
   /** What the field held before this write - for length-aware masks. */
   previous: unknown;
-  row: ErasedRow;
-  column: ErasedColumn;
+  row: ErasedRow$1;
+  column: ErasedColumn$1;
   table: TMDataGridTable<TMDataGridRowData>;
 };
 /**
@@ -696,16 +549,16 @@ type TMDataGridEditApi<TData extends RowData = TMDataGridRowData> = {
    * Whether this cell may open an editor: the column maps to a field, nothing
    * switched it off, and the row takes edits at all.
    */
-  canEditCell: (row: ErasedRow, column: ErasedColumn) => boolean;
+  canEditCell: (row: ErasedRow$1, column: ErasedColumn$1) => boolean;
   /** Whether the row takes edits at all - the edit lane's pencil gate. */
-  canEditRow: (row: ErasedRow) => boolean;
+  canEditRow: (row: ErasedRow$1) => boolean;
   /**
    * Whether the column takes edits at all, with no row in hand: it maps to a
    * field, `editing.columns` lists it if that option is set, and
    * `meta.edit.enabled` is not `false`. A per-row `enabled` predicate is the
    * row's half of the question - `canEditCell` asks both.
    */
-  isColumnEditable: (column: ErasedColumn) => boolean;
+  isColumnEditable: (column: ErasedColumn$1) => boolean;
   /**
    * Opens an editor. In row mode the whole row opens either way and `columnId`
    * only says which cell takes the caret; `null` (the lane's pencil) leaves it
@@ -964,8 +817,24 @@ type TMDataGridLabels = {
   rowStateDeleted: string;
   cellCount: (count: number) => string;
   copy: string;
-  exportCsv: string;
+  exportCells: string;
+  /** @deprecated Use `exportCells`. Read as its fallback for one beta. */
+  exportCsv?: string;
   includeHeaders: string;
+  exportAll: string;
+  exportSelected: (count: number) => string;
+  /** Title of the column picker `columns="custom"` opens; `format` is the file extension in upper case, "CSV". */
+  exportPickerTitle: (format: string) => string;
+  /** The line under the title; `selected` is the selected row count, or `null` for an export of all rows. */
+  exportPickerHint: (selected: number | null) => string;
+  exportPickerConfirm: string;
+  exportPickerCancel: string;
+  /** The select-all row over the picker's list. */
+  exportPickerSelectAll: string;
+  /** The "3 of 12" count beside it. */
+  exportPickerCount: (checked: number, total: number) => string;
+  /** Marks a column the grid hides at the moment. */
+  exportPickerHidden: string;
   selectColumnLabel: string;
   selectAllRows: string;
   selectRow: string;
@@ -1064,10 +933,19 @@ type TMDataGridFilterControlComponent = ComponentType<TMDataGridFilterControlArg
  * declaration of each feeds the filter panel and the cell editor alike.
  */
 type TMDataGridColumnFilterOptions = {
+  /**
+   * The operators this column offers, a subset of the type's own. For a
+   * column backed by an endpoint that answers only some of them - `contains`
+   * and `equals`, say - so the panel and the header funnel never offer an
+   * operator the query cannot express. Kept in the type's order; one the type
+   * does not offer is ignored, and a list that leaves nothing falls back to
+   * the type's full set.
+   */
+  operators?: readonly TMDataGridFilterOperator[];
   /**
    * The operator a fresh filter on this column starts with, instead of the
    * type's default - a salary column can open on `"between"`. Must be one of
-   * the type's own operators.
+   * the operators the column offers.
    */
   defaultOperator?: TMDataGridFilterOperator;
   /**
@@ -1528,174 +1406,513 @@ declare function boundsEdges(bounds: TMDataGridRangeBounds | null, rowIndex: num
   right: boolean;
 } | null;
 //#endregion
-//#region .types-tmp/useTMDataGrid.d.ts
+//#region .types-tmp/core/export.d.ts
+type ErasedRow = Row<TMDataGridFeatures, TMDataGridRowData>;
+type ErasedColumn = Column<TMDataGridFeatures, TMDataGridRowData, unknown>;
 /**
- * Per-column configuration the grid's own components read.
+ * What an export writes: the exported columns in render order, their labels,
+ * and one array of raw values per row.
  *
- * The filter and edit stages each get a namespace, `filter` and `edit`,
- * mirroring the feature's runtime API. What the column *is* stays flat:
- * `label`, `type`, `options`, `align`, `flex`, `autoSize`, `enableOrdering`.
- * `type` and `options` are read by both stages, so one declaration of each
- * feeds the filter panel and the cell editor, which is why they sit outside
- * both namespaces.
+ * Raw values rather than text, so a format decides how a number, a date or an
+ * array is written - JSON keeps a number a number, and a spreadsheet format
+ * can write a typed cell.
  */
-type TMDataGridColumnMeta = {
-  /** Name shown in menus and the column manager. Falls back to a string header. */
-  label?: string;
-  /**
-   * 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,
-   * so its switch lives here rather than on the column definition.
-   */
-  enableOrdering?: boolean;
-  /**
-   * How this column filters: the operator a fresh filter starts with, and the
-   * value control the filter panel renders for it.
-   *
-   * ```tsx
-   * meta: {
-   *   type: "number",
-   *   filter: { defaultOperator: "between", control: DgRangeSliderFilter },
-   * }
-   * ```
-   *
-   * See {@link TMDataGridColumnFilterOptions}.
-   */
-  filter?: TMDataGridColumnFilterOptions;
-  /**
-   * How this column is edited: whether it takes edits, which field they write
-   * to, which editor opens, what validates the field and what maps the value
-   * on its way in.
-   *
-   * ```tsx
-   * meta: {
-   *   type: "string",
-   *   edit: { validate: z.string().min(2, "Too short") },
-   * }
-   * ```
-   *
-   * See {@link TMDataGridColumnEditOptions}.
-   */
-  edit?: TMDataGridColumnEditOptions;
+type TMDataGridExportData = {
+  columnIds: Array<string>;
+  /** `getColumnLabel` per column: `meta.label`, a string header, or the id. */
+  headers: Array<string>;
+  rows: Array<Array<unknown>>;
 };
-/** Grid-wide configuration passed through `options.meta`. */
-type TMDataGridTableMeta = {
-  loading?: boolean;
-  noResultsLabel?: string;
-  /** Row height used by the virtualizer. Defaults to `52`. */
-  rowHeight?: number;
+type TMDataGridExportWriteOptions = {
+  /** Whether the format writes the column labels as its first row. */
+  includeHeaders: boolean;
+};
+/**
+ * A file format an export can be written in.
+ *
+ * The grid ships `csvExcelFormat`, `csvFormat`, `tsvFormat` and `jsonFormat`;
+ * an addon package or your own code adds one by implementing this shape.
+ * `write` may be async and may answer a `Blob`, which is what a binary format
+ * such as xlsx needs.
+ */
+type TMDataGridExportFormat = {
+  /** Identifies the format, for a menu or a test. */
+  id: string;
+  /** File extension without the dot, appended to the file name. */
+  extension: string;
+  /** The `Blob` type the download is served under. */
+  mimeType: string;
   /**
-   * Unfiltered row total. Only needed for server-driven grids, where the client
-   * never holds the full data set - `TMDataGrid.SummaryCount` uses it as denominator.
+   * The decimal mark this format writes, when it writes text. Ctrl+C follows
+   * it, so what is copied matches what is exported. Unset means the Nordic
+   * default, a comma.
    */
-  totalRowCount?: number;
+  decimalComma?: boolean;
+  write: (data: TMDataGridExportData, options: TMDataGridExportWriteOptions) => string | Blob | Promise<string | Blob>;
 };
 /**
- * Every feature the TMDataGrid chrome can drive. Defined at module scope so the
- * reference stays stable across renders (see the TanStack table-state skill).
+ * Which columns an export takes: the visible ones, every exportable column
+ * hidden or not, or a list of column ids. The generated lanes and columns
+ * with `meta.enableExport: false` are never taken, whatever is asked for.
  */
-declare const tmDataGridFeatures: {
-  columnFilteringFeature: import("@tanstack/table-core").TableFeature;
-  globalFilteringFeature: import("@tanstack/table-core").TableFeature;
-  rowSortingFeature: import("@tanstack/table-core").TableFeature;
-  rowPaginationFeature: import("@tanstack/table-core").TableFeature;
-  rowSelectionFeature: import("@tanstack/table-core").TableFeature;
-  columnPinningFeature: import("@tanstack/table-core").TableFeature;
-  columnVisibilityFeature: import("@tanstack/table-core").TableFeature;
-  columnOrderingFeature: import("@tanstack/table-core").TableFeature;
-  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;
-  rowPinningFeature: import("@tanstack/table-core").TableFeature;
-  filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
-  groupedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
-  sortedRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+type TMDataGridExportColumns = "visible" | "all" | ReadonlyArray<string>;
+/** How the grid exports: the format, the file name and whether headers go in. */
+type TMDataGridExportOptions = {
+  /** Defaults to `csvExcelFormat()`. */
+  format?: TMDataGridExportFormat;
+  /** Without extension. Defaults to `"export"`. */
+  fileName?: string;
+  /** Column labels as the first row. Defaults to `true`. */
+  includeHeaders?: boolean;
+  /** Defaults to `"visible"`. See {@link TMDataGridExportColumns}. */
+  columns?: TMDataGridExportColumns;
+};
+/**
+ * What the column picker was opened for: which rows, and the options of the
+ * item that opened it. Held in `ui.state.exportPicker` while it is open.
+ */
+type TMDataGridExportPickerRequest = {
+  rows: "all" | "selected";
+  options: TMDataGridExportOptions;
+};
+/** `TMDataGridExportOptions` with every default filled in. */
+type TMDataGridExportSettings = Required<TMDataGridExportOptions>;
+/**
+ * The value written for a cell, in place of `row.getValue(column.id)`. See
+ * `meta.exportValue`.
+ */
+type TMDataGridExportValueGetter = (args: {
+  value: unknown;
+  row: ErasedRow;
+  column: ErasedColumn;
+}) => unknown;
+/**
+ * Which rows an export takes: every filtered and sorted row across all pages,
+ * the selected ones among those, or a list of your own.
+ */
+type TMDataGridExportRows<TData extends RowData> = "all" | "selected" | ReadonlyArray<Row<TMDataGridFeatures, TData>>;
+/**
+ * One value as text.
+ *
+ * Deliberately not the rendered cell: what a cell renders is React, and often a
+ * badge, a link or an icon rather than the value. The value is what a
+ * spreadsheet wants, and it is the one thing every column is guaranteed to
+ * have. `meta.exportValue` is where a column substitutes something else.
+ */
+declare function formatExportValue(value: unknown, { decimalComma }: {
+  decimalComma: boolean;
+}): string;
+/**
+ * Keeps a spreadsheet from running a cell as a formula.
+ *
+ * Excel and Sheets evaluate a cell that starts with `=`, `+`, `-` or `@`, so a
+ * value one user typed into the grid would run in another user's spreadsheet
+ * when the file is opened. The defence is the standard one: a leading
+ * apostrophe, which every spreadsheet reads as "text follows".
+ *
+ * Text that parses as a number is left alone - `-5` and `+4670123456` are
+ * numbers to the spreadsheet too, and an apostrophe would turn them into text.
+ * A phone number written with spaces (`+46 70 123 45 67`) does not parse and
+ * is prefixed; `escapeFormulas: false` on the format is the way out for a grid
+ * whose data is trusted.
+ */
+declare function guardFormula(text: string): string;
+type TMDataGridCsvFormatOptions = {
+  /** Between fields. `csvExcelFormat` defaults to `";"`, `csvFormat` to `","`. */
+  separator?: string;
+  /** Write numbers as `1,5` rather than `1.5`. `csvExcelFormat` defaults to `true`, `csvFormat` to `false`. */
+  decimalComma?: boolean;
+  /** Prefix text that a spreadsheet would run as a formula. Defaults to `true`. See {@link guardFormula}. */
+  escapeFormulas?: boolean;
+};
+/**
+ * A CSV that opens straight into columns in Excel.
+ *
+ * Three things make that true, and all three are needed:
+ *
+ * | Part | Why |
+ * | ---- | --- |
+ * | `sep=;` first line | Excel's own directive - it stops guessing and uses this |
+ * | UTF-8 BOM | without it Excel reads the file as ANSI, and å ä ö arrive broken |
+ * | CRLF line endings | what Excel writes, and what its importer is happiest with |
+ *
+ * The defaults are the Nordic ones, because they are the ones that need
+ * choosing: an Excel running a Swedish, Norwegian, Danish or Finnish locale
+ * reads `;` as its list separator and `,` as its decimal mark, and a file
+ * written the other way opens as one column of text.
+ *
+ * The `sep=` line is Excel's alone; Sheets and Numbers show it as a first row.
+ * `csvFormat` is the one for them.
+ */
+declare function csvExcelFormat({ separator, decimalComma, escapeFormulas }?: TMDataGridCsvFormatOptions): TMDataGridExportFormat;
+/**
+ * Plain CSV as RFC 4180 has it: commas, a dot as the decimal mark, CRLF, and a
+ * UTF-8 BOM so that Excel too reads it as UTF-8. No `sep=` line, so Google
+ * Sheets, Numbers and every tool that reads CSV take it as is.
+ */
+declare function csvFormat({ separator, decimalComma, escapeFormulas }?: TMDataGridCsvFormatOptions): TMDataGridExportFormat;
+type TMDataGridTsvFormatOptions = Omit<TMDataGridCsvFormatOptions, "separator">;
+/**
+ * Tab-separated text, the clipboard shape as a file: tabs between fields, CRLF
+ * between rows, a UTF-8 BOM. Every spreadsheet opens it into columns without
+ * a separator to guess.
+ */
+declare function tsvFormat({ decimalComma, escapeFormulas }?: TMDataGridTsvFormatOptions): TMDataGridExportFormat;
+type TMDataGridJsonFormatOptions = {
+  /** Indentation passed to `JSON.stringify`. Defaults to `2`. */
+  space?: number;
+};
+/**
+ * An array with one object per row, keyed by the column labels, values as the
+ * data holds them. Two columns with the same label collapse into one key, the
+ * later column winning. `includeHeaders` has no meaning here and is ignored.
+ */
+declare function jsonFormat({ space }?: TMDataGridJsonFormatOptions): TMDataGridExportFormat;
+declare const DEFAULT_EXPORT_OPTIONS: TMDataGridExportSettings;
+/**
+ * The defaults with each override folded over them in turn. Field by field,
+ * so an override that spells a field as `undefined` leaves the earlier value
+ * rather than blanking it.
+ */
+declare function resolveExportOptions(...overrides: Array<TMDataGridExportOptions | undefined>): TMDataGridExportSettings;
+/**
+ * Every column an export could take, in render order: the data columns minus
+ * the generated lanes and `meta.enableExport: false`, hidden ones included.
+ * What the column picker lists; `column.getIsVisible()` says which of them a
+ * `"visible"` export would take.
+ */
+declare function getExportableColumns<TData extends RowData>(table: TMDataGridTable<TData>): Array<Column<TMDataGridFeatures, TData, unknown>>;
+/**
+ * How many rows `rows: "selected"` would export: the ticked rows of the
+ * current view. Not the size of the selection map, which keeps rows the
+ * filters have since hidden. Free while nothing is selected.
+ */
+declare function countSelectedExportRows<TData extends RowData>(table: TMDataGridTable<TData>): number;
+type BuildExportDataArgs<TData extends RowData> = {
+  table: TMDataGridTable<TData>;
+  /** Defaults to `"all"`. */
+  rows?: TMDataGridExportRows<TData>;
+  /** Defaults to `"visible"`. Ignored under `bounds`. */
+  columns?: TMDataGridExportColumns;
+  /**
+   * A rectangle over `rows` and the visible columns, both by index - the
+   * cell-range path. `rows` is then the list the indices refer to, usually
+   * the displayed rows.
+   */
+  bounds?: TMDataGridRangeBounds;
+};
+/**
+ * What an export writes, before any format touches it.
+ *
+ * Columns are `"visible"` (the data columns on screen, in render order),
+ * `"all"` (every exportable column, hidden or not) or a list of ids; the
+ * generated lanes and any column with `meta.enableExport: false` are left out
+ * whichever is asked for. Rows are `"all"` (every filtered and sorted row
+ * across every page, group rows flattened to their records), `"selected"`
+ * (those of them the user has ticked, in the same order - the selection map
+ * is walked through the row list rather than the other way round, because
+ * TanStack's selected row models ignore filtering and sorting), or a list of
+ * your own.
+ */
+declare function buildExportData<TData extends RowData>({ table, rows, columns: which, bounds }: BuildExportDataArgs<TData>): TMDataGridExportData;
+/**
+ * Writes `data` in the format and downloads it. Awaits the format, since a
+ * binary format builds its file asynchronously.
+ */
+declare function writeExportFile(data: TMDataGridExportData, { format, fileName, includeHeaders }: TMDataGridExportSettings): Promise<void>;
+type ExportGridArgs<TData extends RowData> = {
+  table: TMDataGridTable<TData>;
+  /** Defaults to `"all"`. See {@link TMDataGridExportRows}. */
+  rows?: TMDataGridExportRows<TData>;
+  /** Merged over `DEFAULT_EXPORT_OPTIONS`. */
+  options?: TMDataGridExportOptions;
+};
+/**
+ * Downloads the grid as a file: {@link buildExportData} through the format's
+ * `write` and a download.
+ *
+ * Inside the grid, `useTMDataGridExport` and the `TMDataGrid.Menu.Export*`
+ * items call this with the grid's own `exportOptions`; this is the entry point
+ * for code that holds the table and nothing else.
+ *
+ * Nothing is downloaded when no column is exportable. A grid with no rows
+ * still downloads its header row, since an empty file is the honest answer to
+ * an empty view.
+ *
+ * Async because a format may be. Safari refuses a download that starts after
+ * the click gesture has ended, which a format that takes long enough to build
+ * can run into; the text formats resolve synchronously and never do.
+ */
+declare function exportGrid<TData extends RowData>({ table, rows, options }: ExportGridArgs<TData>): Promise<void>;
+type TMDataGridClipboardTextOptions = {
+  /** Defaults to `true`, the Nordic mark. */
+  decimalComma?: boolean;
+  /** Defaults to `true`. See {@link guardFormula}. */
+  escapeFormulas?: boolean;
+};
+/**
+ * The clipboard format spreadsheets read: tab between cells, CRLF between rows,
+ * values only.
+ *
+ * Tabs rather than commas because that is what Excel, Sheets and Numbers all
+ * put on the clipboard themselves - paste it and the cells land in cells. A
+ * comma-separated string pastes into a single column, which is the thing this
+ * exists to avoid. No header row: Excel's own copy carries none either, and a
+ * header pasted into the middle of a sheet is a row of text where numbers
+ * were expected.
+ *
+ * Also accepts an already-formatted string matrix, for callers of the
+ * deprecated `buildCellMatrix`.
+ */
+declare function toClipboardText(data: TMDataGridExportData | TMDataGridCellMatrix, { decimalComma, escapeFormulas }?: TMDataGridClipboardTextOptions): string;
+/**
+ * Puts text on the clipboard, reporting whether it landed.
+ *
+ * The async clipboard API only resolves for a document that has the focus and a
+ * user gesture behind it - both true when this runs off Ctrl+C or a menu item.
+ * It is still allowed to reject (a permissions policy, a page that lost focus
+ * mid-copy), so the result is a boolean the caller can act on.
+ */
+declare function writeClipboardText(text: string): Promise<boolean>;
+/**
+ * Downloads a file, through the one mechanism a library can use: an anchor
+ * with an object URL behind it, clicked. Revoked on the next frame -
+ * immediately would race the browser's own read of it.
+ */
+declare function downloadFile({ fileName, content, mimeType }: {
+  fileName: string;
+  content: string | Blob;
+  mimeType: string;
+}): void;
+/** @deprecated Use {@link TMDataGridExportData}; the matrix is text, the data holds values. */
+type TMDataGridCellMatrix = Array<Array<string>>;
+/** @deprecated Use {@link TMDataGridExportOptions} with `csvExcelFormat({ separator, decimalComma })`. */
+type TMDataGridCellExportOptions = {
+  /** CSV field separator. Defaults to `";"`. */
+  separator?: string;
+  /** Write numbers as `1,5` rather than `1.5`. Defaults to `true`. */
+  decimalComma?: boolean;
+  /** Column labels as the first row. Defaults to `true`. */
+  includeHeaders?: boolean;
+  /** Without extension. Defaults to `"export"`. */
+  fileName?: string;
+};
+/** @deprecated Use {@link DEFAULT_EXPORT_OPTIONS}. */
+declare const DEFAULT_CELL_EXPORT_OPTIONS: Required<TMDataGridCellExportOptions>;
+/**
+ * The old options as the new: separator and decimal mark become a
+ * `csvExcelFormat`, the rest carries over. Shared by the deprecated
+ * `cellExport` Table prop and {@link exportGridToCsv}.
+ *
+ * @deprecated Write {@link TMDataGridExportOptions} directly.
+ */
+declare function fromCellExportOptions(options: TMDataGridCellExportOptions): TMDataGridExportOptions;
+/** @deprecated Use {@link BuildExportDataArgs}. */
+type BuildCellMatrixArgs = {
+  rows: ReadonlyArray<ErasedRow>;
+  /** Every visible column, in render order - the same list the bounds index into. */
+  columns: ReadonlyArray<ErasedColumn>;
+  bounds: TMDataGridRangeBounds;
+  includeHeaders: boolean;
+  decimalComma: boolean;
+};
+/** @deprecated Use {@link buildExportData} with `bounds`, and a format to write it. */
+declare function buildCellMatrix({ rows, columns, bounds, includeHeaders, decimalComma }: BuildCellMatrixArgs): TMDataGridCellMatrix;
+/** @deprecated Use {@link buildExportData}. */
+declare function buildGridCellMatrix<TData extends RowData>({ table, includeHeaders, decimalComma }: {
+  table: TMDataGridTable<TData>;
+  includeHeaders?: boolean;
+  decimalComma?: boolean;
+}): TMDataGridCellMatrix;
+/** @deprecated Use {@link csvExcelFormat} - its `write` is this over export data. */
+declare function toExcelCsv(matrix: TMDataGridCellMatrix, { separator }: {
+  separator: string;
+}): string;
+/** @deprecated Use {@link exportGrid}. */
+declare function exportGridToCsv<TData extends RowData>({ table, options }: {
+  table: TMDataGridTable<TData>;
+  options?: TMDataGridCellExportOptions;
+}): void;
+/** @deprecated Use {@link downloadFile}. */
+declare function downloadTextFile({ fileName, text, mimeType }: {
+  fileName: string;
+  text: string;
+  mimeType?: string;
+}): void;
+//#endregion
+//#region .types-tmp/useTMDataGrid.d.ts
+/**
+ * Per-column configuration the grid's own components read.
+ *
+ * The filter and edit stages each get a namespace, `filter` and `edit`,
+ * mirroring the feature's runtime API. What the column *is* stays flat:
+ * `label`, `type`, `options`, `align`, `flex`, `autoSize`, `enableOrdering`.
+ * `type` and `options` are read by both stages, so one declaration of each
+ * feeds the filter panel and the cell editor, which is why they sit outside
+ * both namespaces.
+ */
+type TMDataGridColumnMeta = {
+  /** Name shown in menus and the column manager. Falls back to a string header. */
+  label?: string;
+  /**
+   * Drives which filter operators are offered and, once editing is on, which
+   * editor the cell opens. Defaults to `"string"`.
+   */
+  type?: TMDataGridColumnType;
+  /**
+   * The choices of a `select` / `multiSelect` column - one declaration feeding
+   * the filter panel's value control and the cell editor alike. A static
+   * array, `"faceted"` (the distinct values present in the data), or a
+   * function of the table, column and, for editors, the row. See
+   * {@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,
+   * so its switch lives here rather than on the column definition.
+   */
+  enableOrdering?: boolean;
+  /**
+   * How this column filters: which operators it offers, the operator a fresh
+   * filter starts with, and the value control the filter panel renders for it.
+   *
+   * ```tsx
+   * meta: {
+   *   type: "number",
+   *   filter: { defaultOperator: "between", control: DgRangeSliderFilter },
+   * }
+   * ```
+   *
+   * See {@link TMDataGridColumnFilterOptions}.
+   */
+  filter?: TMDataGridColumnFilterOptions;
+  /**
+   * How this column is edited: whether it takes edits, which field they write
+   * to, which editor opens, what validates the field and what maps the value
+   * on its way in.
+   *
+   * ```tsx
+   * meta: {
+   *   type: "string",
+   *   edit: { validate: z.string().min(2, "Too short") },
+   * }
+   * ```
+   *
+   * See {@link TMDataGridColumnEditOptions}.
+   */
+  edit?: TMDataGridColumnEditOptions;
+  /**
+   * `false` leaves the column out of every export and out of Ctrl+C - for a
+   * column of buttons, or one whose value means nothing outside the grid.
+   * Defaults to `true`.
+   */
+  enableExport?: boolean;
+  /**
+   * The value an export writes for this column, in place of
+   * `row.getValue(column.id)`. The export otherwise writes the value, never
+   * what the cell renders, so this is where a status code becomes its label
+   * or a nested object becomes one field.
+   *
+   * ```tsx
+   * meta: {
+   *   exportValue: ({ value }) => STATUS_LABELS[value as Status],
+   * }
+   * ```
+   */
+  exportValue?: TMDataGridExportValueGetter;
+};
+/** Grid-wide configuration passed through `options.meta`. */
+type TMDataGridTableMeta = {
+  loading?: boolean;
+  noResultsLabel?: string;
+  /** Row height used by the virtualizer. Defaults to `52`. */
+  rowHeight?: number;
+  /**
+   * Unfiltered row total. Only needed for server-driven grids, where the client
+   * never holds the full data set - `TMDataGrid.SummaryCount` uses it as denominator.
+   */
+  totalRowCount?: number;
+};
+/**
+ * Every feature the TMDataGrid chrome can drive. Defined at module scope so the
+ * reference stays stable across renders (see the TanStack table-state skill).
+ */
+declare const tmDataGridFeatures: {
+  columnFilteringFeature: import("@tanstack/table-core").TableFeature;
+  globalFilteringFeature: import("@tanstack/table-core").TableFeature;
+  rowSortingFeature: import("@tanstack/table-core").TableFeature;
+  rowPaginationFeature: import("@tanstack/table-core").TableFeature;
+  rowSelectionFeature: import("@tanstack/table-core").TableFeature;
+  columnPinningFeature: import("@tanstack/table-core").TableFeature;
+  columnVisibilityFeature: import("@tanstack/table-core").TableFeature;
+  columnOrderingFeature: import("@tanstack/table-core").TableFeature;
+  columnSizingFeature: import("@tanstack/table-core").TableFeature;
+  columnResizingFeature: import("@tanstack/table-core").TableFeature;
+  columnFacetingFeature: import("@tanstack/table-core").TableFeature;
+  columnGroupingFeature: import("@tanstack/table-core").TableFeature;
+  rowAggregationFeature: import("@tanstack/table-core").TableFeature;
+  rowExpandingFeature: import("@tanstack/table-core").TableFeature;
+  rowPinningFeature: import("@tanstack/table-core").TableFeature;
+  filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
+  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: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean;
-    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: [number, number]) => boolean) & {
-      resolveFilterValue: (val: [any, any]) => readonly [number, number];
-      autoRemove: (val: any) => boolean;
-    };
-    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
+    arrIncludes: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrIncludesAll: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrHas: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrIncludesSome: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    between: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    betweenInclusive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    empty: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    endsWith: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equals: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equalsString: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equalsStringSensitive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    inDateRange: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    inNumberRange: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    includesString: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    includesStringSensitive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    notEmpty: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    startsWith: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    weakEquals: import("@tanstack/table-core").CreatedFilterFn<any, any>;
     tmDataGrid: typeof tmDataGridFilterFn;
     tmDataGridFuzzy: typeof fuzzyGlobalFilterFn;
   };
   sortFns: {
-    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => number;
-    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
-    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData extends RowData>(rowA: Row<TFeatures, TData>, rowB: Row<TFeatures, TData>, columnId: string) => 0 | 1 | -1;
+    alphanumeric: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    basic: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    text: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/table-core").CreatedSortFn<any, any>;
   };
   aggregationFns: {
-    sum: typeof import("@tanstack/table-core").aggregationFn_sum;
-    min: typeof import("@tanstack/table-core").aggregationFn_min;
-    max: typeof import("@tanstack/table-core").aggregationFn_max;
-    extent: typeof import("@tanstack/table-core").aggregationFn_extent;
-    mean: typeof import("@tanstack/table-core").aggregationFn_mean;
-    median: typeof import("@tanstack/table-core").aggregationFn_median;
-    unique: typeof import("@tanstack/table-core").aggregationFn_unique;
-    uniqueCount: typeof import("@tanstack/table-core").aggregationFn_uniqueCount;
-    count: typeof import("@tanstack/table-core").aggregationFn_count;
+    sum: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    min: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    max: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    extent: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, [(number | Date) | undefined, (number | Date) | undefined]>;
+    mean: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+    median: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+    unique: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown[]>;
+    uniqueCount: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    count: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    first: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown>;
+    last: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown>;
   };
   tableMeta: TMDataGridTableMeta;
   columnMeta: TMDataGridColumnMeta;
@@ -1715,6 +1932,7 @@ declare function createTMDataGridColumnHelper<TData extends RowData>(): import("
   columnResizingFeature: import("@tanstack/table-core").TableFeature;
   columnFacetingFeature: import("@tanstack/table-core").TableFeature;
   columnGroupingFeature: import("@tanstack/table-core").TableFeature;
+  rowAggregationFeature: import("@tanstack/table-core").TableFeature;
   rowExpandingFeature: import("@tanstack/table-core").TableFeature;
   rowPinningFeature: import("@tanstack/table-core").TableFeature;
   filteredRowModel: (table: Table<any, any>) => () => import("@tanstack/table-core").RowModel<any, any>;
@@ -1726,62 +1944,47 @@ declare function createTMDataGridColumnHelper<TData extends RowData>(): import("
   facetedMinMaxValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => undefined | [number, number];
   facetedUniqueValues: (table: Table<import("@tanstack/table-core").TableFeatures, any>, columnId: string) => () => Map<any, number>;
   filterFns: {
-    arrIncludes: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrIncludesAll: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    arrHas: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean;
-    arrIncludesSome: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: Array<unknown>) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    between: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    betweenInclusive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValues: [unknown, unknown]) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    equalsString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    inNumberRange: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: [number, number]) => boolean) & {
-      resolveFilterValue: (val: [any, any]) => readonly [number, number];
-      autoRemove: (val: any) => boolean;
-    };
-    includesString: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    includesStringSensitive: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
-    weakEquals: (<TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(row: Row<TFeatures, TData_1>, columnId: string, filterValue: unknown) => boolean) & {
-      autoRemove: (val: any) => boolean;
-    };
+    arrIncludes: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrIncludesAll: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrHas: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    arrIncludesSome: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    between: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    betweenInclusive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    empty: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    endsWith: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equals: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equalsString: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    equalsStringSensitive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    inDateRange: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    inNumberRange: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    includesString: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    includesStringSensitive: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    notEmpty: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    startsWith: import("@tanstack/table-core").CreatedFilterFn<any, any>;
+    weakEquals: import("@tanstack/table-core").CreatedFilterFn<any, any>;
     tmDataGrid: typeof tmDataGridFilterFn;
     tmDataGridFuzzy: typeof fuzzyGlobalFilterFn;
   };
   sortFns: {
-    alphanumeric: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => number;
-    alphanumericCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => number;
-    basic: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    datetime: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    text: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
-    textCaseSensitive: <TFeatures extends import("@tanstack/table-core").TableFeatures, TData_1 extends RowData>(rowA: Row<TFeatures, TData_1>, rowB: Row<TFeatures, TData_1>, columnId: string) => 0 | 1 | -1;
+    alphanumeric: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    basic: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    text: import("@tanstack/table-core").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/table-core").CreatedSortFn<any, any>;
   };
   aggregationFns: {
-    sum: typeof import("@tanstack/table-core").aggregationFn_sum;
-    min: typeof import("@tanstack/table-core").aggregationFn_min;
-    max: typeof import("@tanstack/table-core").aggregationFn_max;
-    extent: typeof import("@tanstack/table-core").aggregationFn_extent;
-    mean: typeof import("@tanstack/table-core").aggregationFn_mean;
-    median: typeof import("@tanstack/table-core").aggregationFn_median;
-    unique: typeof import("@tanstack/table-core").aggregationFn_unique;
-    uniqueCount: typeof import("@tanstack/table-core").aggregationFn_uniqueCount;
-    count: typeof import("@tanstack/table-core").aggregationFn_count;
+    sum: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    min: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    max: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    extent: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, [(number | Date) | undefined, (number | Date) | undefined]>;
+    mean: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+    median: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number | undefined>;
+    unique: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown[]>;
+    uniqueCount: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    count: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, number>;
+    first: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown>;
+    last: import("@tanstack/table-core").AggregationFnDef<any, any, unknown, unknown>;
   };
   tableMeta: TMDataGridTableMeta;
   columnMeta: TMDataGridColumnMeta;
@@ -1852,10 +2055,20 @@ type TMDataGridUiState = {
    * describe different places.
    */
   cellRange: TMDataGridCellRange | null;
+  /**
+   * The export column picker, while it is open: which rows it exports and the
+   * options of the item that opened it. `null` while closed. Held here rather
+   * than in the menu item, which unmounts with the dropdown the moment it is
+   * clicked.
+   */
+  exportPicker: TMDataGridExportPickerRequest | null;
 };
 type TMDataGridUiActions = {
   openFilterPanel: (columnId?: string | null) => void;
   closeFilterPanel: () => void;
+  /** Opens the export column picker for `request`. See `TMDataGrid.Menu.Export`'s `columns="custom"`. */
+  openExportPicker: (request: TMDataGridExportPickerRequest) => void;
+  closeExportPicker: () => void;
   /**
    * Points at a column's row in the filter panel without opening anything.
    * `openFilterPanel` does this as well as opening; this is the half a panel
@@ -1921,6 +2134,12 @@ type TMDataGridApi<TData extends RowData> = {
    * table about which surface is on.
    */
   filters: TMDataGridFiltersSettings;
+  /**
+   * How the grid exports, the `exportOptions` option with its defaults filled
+   * in. Read by `useTMDataGridExport`, the `TMDataGrid.Menu.Export*` items and
+   * the cell-range menu, so every export of the grid agrees on the format.
+   */
+  exportOptions: TMDataGridExportSettings;
   /** Every string the chrome renders, `labels` merged over the English defaults. */
   labels: TMDataGridLabels;
   /** The detail renderer, when row details are on. See `renderDetails`. */
@@ -2220,6 +2439,20 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
    * `persist`, this one does not have to be referentially stable.
    */
   filters?: TMDataGridFiltersOptions;
+  /**
+   * How the grid exports: the file format, the file name and whether the
+   * column labels go in as the first row. Defaults to `csvExcelFormat()`,
+   * `"export"` and `true`. See {@link TMDataGridExportOptions}.
+   *
+   * ```tsx
+   * useTMDataGrid({ data, columns, exportOptions: { format: csvFormat(), fileName: "employees" } });
+   * ```
+   *
+   * Read field by field like `filters`, so a literal is fine. A `format`
+   * built inline is rebuilt every render, which costs nothing but a small
+   * object; keep it at module scope when that bothers you.
+   */
+  exportOptions?: TMDataGridExportOptions;
   /**
    * How the quick search (`TMDataGrid.Search`) matches. `"fuzzy"` - the
    * default - forgives typos and skipped characters, and while it is the
@@ -2388,48 +2621,317 @@ type UseTMDataGridOptions<TData extends RowData> = Omit<TableOptions<TMDataGridF
    */
   renderDetails?: TMDataGridDetailsRenderer<TData>;
   /**
-   * What the virtualizer assumes an unmeasured detail panel is worth, in px.
-   * Defaults to 160.
-   *
-   * An estimate, not a height: every mounted row is measured, so the real one
-   * takes over as soon as the panel is on screen. It keeps the scrollbar
-   * accurate for panels that open off screen, such as restored `expanded`
-   * state. An approximate value is enough.
+   * What the virtualizer assumes an unmeasured detail panel is worth, in px.
+   * Defaults to 160.
+   *
+   * An estimate, not a height: every mounted row is measured, so the real one
+   * takes over as soon as the panel is on screen. It keeps the scrollbar
+   * accurate for panels that open off screen, such as restored `expanded`
+   * state. An approximate value is enough.
+   */
+  renderDetailsEstHeight?: number;
+  /**
+   * Rows the virtualizer keeps mounted above and below the viewport. Defaults
+   * to 6.
+   *
+   * Raise it to trade memory for a scroll that stays painted - fast wheel or
+   * touch flings can outrun the virtualizer and flash blank rows, and a larger
+   * buffer covers the gap. Lower it when rows are expensive to render.
+   */
+  overscan?: number;
+};
+/**
+ * Builds a TMDataGrid table plus its chrome store.
+ *
+ * Every `TableOptions` field passes straight through, so a server-driven grid
+ * only needs `manualPagination` / `manualFiltering` / `manualSorting`,
+ * `rowCount` and the matching `onXChange` callbacks - the chrome reads
+ * `getRowCount()` / `getPageCount()` / `getPaginatedRowModel()`, all of which
+ * already respect manual mode. `manualPagination` also switches the pagination
+ * flag on, so `<TMDataGrid.Footer />` renders its pager without further
+ * options.
+ */
+declare function useTMDataGrid<TData extends RowData>({ persist, labels: labelsOverride, enableColumnOrdering, enablePagination, resetPageOnQueryChange, enableRowNumbers, selectionMode, showSelectedBackground, defaultHighlightedRowId, onHighlightedRowChange, cellSelection, onFocusedCellChange, filters: filterOptions, exportOptions: exportOptionsOverride, editing, renderDetails, renderDetailsEstHeight, overscan, ...options }: UseTMDataGridOptions<TData>): TMDataGridApi<TData>;
+/**
+ * Sends the user to a column's filter control, seeding an empty filter when
+ * the column has none yet - what "Filter" in the column menu and a click on a
+ * filter pill both do.
+ *
+ * Which control that is follows the grid's `filters` option. Under
+ * `inHeader` it is the column's header control, which is already on screen, so
+ * the call focuses it and leaves the popup or sidebar closed. Otherwise it is
+ * the panel's row for that column, and the call opens the surface on it.
+ */
+declare function openColumnFilter<TData extends RowData>(api: TMDataGridApi<TData>, columnId: string): void;
+//#endregion
+//#region .types-tmp/core/filterOperators.d.ts
+/**
+ * The value shape stored in `columnFilters` for every TMDataGrid column.
+ *
+ * TanStack resolves `filterFn` statically per column, so the operator travels
+ * inside the filter *value* instead. That keeps the filter model plain,
+ * serialisable JSON, so a server-side `manualFiltering` table can forward
+ * `columnFilters` to the API unchanged.
+ *
+ * `value` is a string array under `isAnyOf` / `isNoneOf` (the set the cell is
+ * tested against), a `[min, max]` pair under `between` (an empty string means
+ * that end is open), and a single string everywhere else - dates travel as
+ * ISO `YYYY-MM-DD` strings, booleans as `"true"` / `"false"`. Still plain
+ * JSON.
+ */
+type TMDataGridFilterValue = {
+  operator: TMDataGridFilterOperator;
+  value: string | ReadonlyArray<string>;
+};
+type TMDataGridColumnType = "string" | "number" | "boolean" | "date" | "select" | "multiSelect";
+type TMDataGridFilterOperator = "contains" | "equals" | "notEquals" | "startsWith" | "endsWith" | "greaterThan" | "greaterThanOrEqual" | "lessThan" | "lessThanOrEqual" | "between" | "before" | "after" | "onOrBefore" | "onOrAfter" | "isAnyOf" | "isNoneOf" | "isEmpty" | "isNotEmpty";
+declare const FILTER_OPERATOR_LABELS: Record<TMDataGridFilterOperator, string>;
+declare function getOperatorsForType(type: TMDataGridColumnType): readonly TMDataGridFilterOperator[];
+declare function getDefaultOperator(type: TMDataGridColumnType): TMDataGridFilterOperator;
+declare function operatorNeedsValue(operator: TMDataGridFilterOperator): boolean;
+/** Whether the operator's value is a string array - `isAnyOf` / `isNoneOf`. */
+declare function operatorTakesArrayValue(operator: TMDataGridFilterOperator): boolean;
+/** Whether the operator's value is a `[min, max]` pair - `between`. */
+declare function operatorTakesRangeValue(operator: TMDataGridFilterOperator): boolean;
+/** The untouched value a fresh filter starts with - the operator's shape, empty. */
+declare function emptyValueForOperator(operator: TMDataGridFilterOperator): string | ReadonlyArray<string>;
+/**
+ * The three value shapes an operator can take. A set is not a range, even
+ * though both are arrays.
+ */
+type TMDataGridFilterValueShape = "scalar" | "set" | "range";
+/**
+ * Which shape an operator's value takes. A typed value survives an operator or
+ * column change only within its shape, which is the rule both the panel and
+ * the header controls use when the operator changes.
+ */
+declare function filterValueShape(operator: TMDataGridFilterOperator): TMDataGridFilterValueShape;
+/**
+ * A filter only narrows the row set once it has something to compare against.
+ * Half-typed filters stay in state (so the panel keeps rendering their row) but
+ * are treated as inactive for the funnel indicator and for row matching.
+ */
+declare function isFilterActive(value: unknown): boolean;
+/** One column's filter, typed - what `columnFilters` holds per entry. */
+type TMDataGridColumnFilter = {
+  id: string;
+  value: TMDataGridFilterValue;
+};
+/**
+ * The column filters that are actually narrowing the grid, typed.
+ *
+ * `ColumnFiltersState` types `value` as `unknown`, so the first line of a
+ * server-side mapping layer is otherwise a cast back to the shape the grid
+ * itself wrote, wrapped in the same "drop the half-typed ones" filter every
+ * consumer writes:
+ *
+ * ```ts
+ * const predicates = activeColumnFilters(table).map((filter) =>
+ *   toPredicate(filter.id, filter.value),
+ * );
+ * ```
+ *
+ * Takes the table, or a `columnFilters` array where the consumer owns the
+ * slice. Reading it from the table reads the current value and does not
+ * subscribe; inside a component, subscribe to `columnFilters` the way the
+ * grid's own chrome does.
+ */
+declare function activeColumnFilters<TData extends RowData>(source: TMDataGridTable<TData> | ColumnFiltersState): Array<TMDataGridColumnFilter>;
+/**
+ * One-line description of a single filter, as shown on a filter pill.
+ *
+ * The type's default operator is left implicit - "First name: Sofia" reads the
+ * way a person would say it - while any other operator is spelled out, since
+ * that is the part a reader cannot guess.
+ */
+declare function formatFilterLabel({ label, type, filter, operatorLabels }: {
+  label: string;
+  type: TMDataGridColumnType;
+  filter: TMDataGridFilterValue;
+  /** Localized operator names - `labels.operators`. Defaults to English. */
+  operatorLabels?: Record<TMDataGridFilterOperator, string>;
+}): string;
+/**
+ * The single filter function every TMDataGrid column uses. It dispatches on the
+ * operator carried by the filter value, which is what lets one column offer
+ * "contains" / "does not equal" / "is empty" without redefining the column.
+ */
+declare function tmDataGridFilterFn<TFeatures extends TableFeatures, TData extends RowData>(row: Row<TFeatures, TData>, columnId: string, filterValue: unknown): boolean;
+//#endregion
+//#region .types-tmp/core/columnUtils.d.ts
+/**
+ * Structural shape of the column bits the chrome reads. Kept minimal so these
+ * helpers work with any `Column`/`Header` instance without dragging generics
+ * through every call site.
+ */
+type ColumnLike = {
+  id: string;
+  columnDef: {
+    header?: unknown;
+    meta?: TMDataGridColumnMeta;
+  };
+  /** Set on a leaf that sits inside a header group. */
+  parent?: unknown;
+};
+/** Menu- and panel-facing column name. */
+declare function getColumnLabel(column: ColumnLike): string;
+declare function getColumnType(column: ColumnLike): TMDataGridColumnType;
+/**
+ * The operators this column offers: the type's list, narrowed to
+ * `meta.filter.operators` when the column declares one. The type's order is
+ * kept so the menu reads the same on every column; an operator the type does
+ * not offer is dropped, and an allowlist that leaves nothing falls back to the
+ * type's full list rather than an empty menu.
+ */
+declare function getColumnOperators(column: ColumnLike): readonly TMDataGridFilterOperator[];
+/**
+ * The operator a fresh filter on this column starts with -
+ * `meta.filter.defaultOperator`, else the type's default where the column
+ * offers it, else the first operator it does offer.
+ */
+declare function getColumnDefaultOperator(column: ColumnLike): TMDataGridFilterOperator;
+/**
+ * This column's filter-panel value control - `meta.filter.control`, or
+ * `undefined` for the built-in shape-by-operator input.
+ */
+declare function getColumnFilterControl(column: ColumnLike): TMDataGridFilterControlComponent | undefined;
+/**
+ * Whether `meta.edit.enabled` lets this column's cell on this row be edited -
+ * the switch, then the predicate.
+ *
+ * This is only the column's half of the rule. A cell also needs the column to
+ * map to a field (`getEditFieldName`) and the row to take edits at all
+ * (`isRowEditable`); `edit.canEditCell` is the whole question.
+ */
+declare function isColumnEditableForRow(column: ColumnLike, row: Row<TMDataGridFeatures, TMDataGridRowData>): boolean;
+/**
+ * A generated lane holding one fixed-width thing - the checkbox, the details
+ * chevron, the row number.
+ *
+ * They are laid out differently from every other column: cell padding is sized
+ * for text and grows with the scale, which at `xl` squeezed a 16px checkbox out
+ * of its track, so these lanes centre their content in an unpadded cell.
+ * Their headers carry no column menu, and none of them is ever exported -
+ * they hold chrome, not values.
+ *
+ * The tree column is deliberately not one of them: it holds a label as well as a
+ * chevron, and wants the padding.
+ */
+declare function isControlColumn(columnId: string): boolean;
+/**
+ * Whether the grid generated this column rather than the consumer declaring it
+ * - the four control lanes plus the tree column.
+ *
+ * These hold the grid's own chrome, and they keep the edges of the row: the
+ * generated left lanes before every consumer column, the edit lane after all of
+ * them. `isControlColumn` answers a narrower question about layout, and leaves
+ * the tree column out because it is padded like a data column.
+ */
+declare function isGeneratedColumn(columnId: string): boolean;
+/**
+ * Whether a column may be moved. Ordering is the one column feature TanStack
+ * has no column option for, so the switch lives in `meta.enableOrdering`.
+ *
+ * A leaf inside a header group is never movable: `columnOrder` sequences leaf
+ * columns, so moving one out of its group would leave the group header spanning
+ * columns that no longer belong to it.
+ */
+declare function isColumnReorderable(column: ColumnLike): boolean;
+/** `"auto"` shows the search box from `COLUMN_SEARCH_MIN` columns. */
+type TMDataGridColumnSearchable = boolean | "auto";
+//#endregion
+//#region .types-tmp/components/TMDataGridMenu.d.ts
+type TMDataGridMenuProps = Omit<MenuProps, "children"> & {
+  /** The dropdown's content: Mantine `Menu.Item`s and the `TMDataGrid.Menu.*` items. */
+  children: ReactNode;
+  /** Replaces the burger icon on the trigger. */
+  icon?: ReactNode;
+  /** Tooltip and `aria-label` of the trigger. Default `labels.menuButton`. */
+  label?: string;
+};
+type TMDataGridMenuColumnsProps = {
+  /**
+   * Renders a `Menu.Search` above the toggles: `"auto"` (the default) from
+   * six hideable columns, `true` always, `false` never. Use `false` inside a
+   * `Menu.Sub`.
+   */
+  searchable?: TMDataGridColumnSearchable;
+};
+/**
+ * The whole column chooser as menu items: a search box, one checkbox item per
+ * hideable column, show/hide all, and Reset layout. Renders nothing when no
+ * column can be hidden.
+ *
+ * `searchable` is only for a block at the top level of a dropdown.
+ * `Menu.Search` registers on the root menu context (`hasSearch`), which
+ * switches off type-ahead and the arrow-key handling of every dropdown of that
+ * menu, so a search inside a `Menu.Sub` breaks the parent menu's keyboard
+ * behaviour.
+ */
+declare function TMDataGridMenuColumns({ searchable }: TMDataGridMenuColumnsProps): import("react").JSX.Element | null;
+/**
+ * One checkbox item per hideable column, narrowed to `search` when one is
+ * given. Renders nothing when no column can be hidden.
+ */
+declare function TMDataGridMenuColumnToggles({ search }: {
+  search?: string;
+}): import("react").JSX.Element | null;
+/**
+ * Shows or hides every listed column at once. Renders nothing when no column
+ * can be hidden.
+ */
+declare function TMDataGridMenuShowHideAll(): import("react").JSX.Element | null;
+/**
+ * Resets the whole layout, not only visibility: order, widths, pinning and
+ * grouping go back too. Not `table.resetColumnVisibility()`, which resets to
+ * `initialState` - and under persistence the mount built that *from* the
+ * persisted payload.
+ */
+declare function TMDataGridMenuResetLayout(): import("react").JSX.Element;
+/** Per-item overrides of the grid's `exportOptions`, and the item's text. */
+type TMDataGridMenuExportProps = Omit<TMDataGridExportOptions, "columns"> & {
+  /**
+   * Which columns the item writes: `"visible"`, `"all"`, a list of ids, or
+   * `"custom"` - a picker listing every exportable column with the visible
+   * ones ticked, and the download on its Export button. Defaults to the grid's
+   * `exportOptions.columns`.
    */
-  renderDetailsEstHeight?: number;
+  columns?: TMDataGridExportColumns | "custom";
   /**
-   * 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.
+   * The item's text. Defaults to `labels.exportAll`, or for the selected-rows
+   * item `labels.exportSelected(count)`. Two items offering two formats need
+   * two texts, which is what this is for.
    */
-  overscan?: number;
+  label?: ReactNode;
 };
 /**
- * Builds a TMDataGrid table plus its chrome store.
- *
- * Every `TableOptions` field passes straight through, so a server-driven grid
- * only needs `manualPagination` / `manualFiltering` / `manualSorting`,
- * `rowCount` and the matching `onXChange` callbacks - the chrome reads
- * `getRowCount()` / `getPageCount()` / `getPaginatedRowModel()`, all of which
- * already respect manual mode. `manualPagination` also switches the pagination
- * flag on, so `<TMDataGrid.Footer />` renders its pager without further
- * options.
+ * Downloads every filtered and sorted row, all pages, in the grid's export
+ * format. Props override `exportOptions` for this item alone, which is how one
+ * menu offers two formats.
  */
-declare function useTMDataGrid<TData extends RowData>({ persist, labels: labelsOverride, enableColumnOrdering, enablePagination, resetPageOnQueryChange, enableRowNumbers, selectionMode, showSelectedBackground, defaultHighlightedRowId, onHighlightedRowChange, cellSelection, onFocusedCellChange, filters: filterOptions, editing, renderDetails, renderDetailsEstHeight, overscan, ...options }: UseTMDataGridOptions<TData>): TMDataGridApi<TData>;
+declare function TMDataGridMenuExport(props: TMDataGridMenuExportProps): import("react").JSX.Element;
 /**
- * Sends the user to a column's filter control, seeding an empty filter when
- * the column has none yet - what "Filter" in the column menu and a click on a
- * filter pill both do.
- *
- * Which control that is follows the grid's `filters` option. Under
- * `inHeader` it is the column's header control, which is already on screen, so
- * the call focuses it and leaves the popup or sidebar closed. Otherwise it is
- * the panel's row for that column, and the call opens the surface on it.
+ * Downloads the selected rows, in grid order. Disabled while nothing is
+ * selected; renders nothing when row selection is off, since then there is
+ * never anything for it to do.
  */
-declare function openColumnFilter<TData extends RowData>(api: TMDataGridApi<TData>, columnId: string): void;
+declare function TMDataGridMenuExportSelected(props: TMDataGridMenuExportProps): import("react").JSX.Element | null;
+//#endregion
+//#region .types-tmp/components/TMDataGridColumnsPanel.d.ts
+/**
+ * The "Manage columns" surface as plain controls, for a host that is not a
+ * menu - a Popover, a Drawer, an inline layout. `TMDataGrid.Menu.Columns` is
+ * the same chooser as menu items.
+ */
+/** Mantine's style props (`w={320}`, `p="sm"`) are set on the panel block. */
+type TMDataGridColumnsPanelProps = BoxProps & {
+  /**
+   * The search box over the list: `"auto"` (the default) from six hideable
+   * columns, `true` always, `false` never.
+   */
+  searchable?: TMDataGridColumnSearchable;
+};
+declare function TMDataGridColumnsPanel({ className, searchable, ...others }?: TMDataGridColumnsPanelProps): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/TMDataGridDraftActions.d.ts
 /** What the edit chrome is showing. */
@@ -2547,7 +3049,8 @@ type TMDataGridDraftActionsProps = {
 declare function TMDataGridDraftActions({ renderActions }?: TMDataGridDraftActionsProps): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null | undefined;
 //#endregion
 //#region .types-tmp/components/TMDataGridFilterPanel.d.ts
-type TMDataGridFilterPanelProps = {
+/** Mantine's style props (`p="md"`, `w={320}`) are set on the panel block. */
+type TMDataGridFilterPanelProps = BoxProps & {
   /**
    * How one filter row is laid out.
    *
@@ -2575,10 +3078,11 @@ type TMDataGridFilterPanelProps = {
  * `manualFiltering` grid gets the same panel for free - the state is forwarded
  * to the server instead of a row model.
  */
-declare function TMDataGridFilterPanel({ layout }?: TMDataGridFilterPanelProps): import("react").JSX.Element;
+declare function TMDataGridFilterPanel({ layout, className, ...others }?: TMDataGridFilterPanelProps): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/TMDataGridFilterPills.d.ts
-type TMDataGridFilterPillsProps<TData extends RowData> = {
+/** Mantine's style props (`mb="sm"`, `hiddenFrom="sm"`) are set on the wrapper. */
+type TMDataGridFilterPillsProps<TData extends RowData> = BoxProps & {
   /** The object returned by `useTMDataGrid`. */
   api: TMDataGridApi<TData>;
   /** Mantine size of the pills. Defaults to `"sm"`. */
@@ -2590,7 +3094,6 @@ type TMDataGridFilterPillsProps<TData extends RowData> = {
    * filter panel on that column.
    */
   onPillClick?: (columnId: string) => void;
-  className?: string;
 };
 /**
  * One pill per active filter (`First name: Sofia ✕`), with the ✕ clearing that
@@ -2612,7 +3115,7 @@ type TMDataGridFilterPillsProps<TData extends RowData> = {
  * Half-typed filters are left out: a filter that is not narrowing the rows yet
  * has nothing to report, which is the same rule the funnel indicator uses.
  */
-declare function TMDataGridFilterPills<TData extends RowData>({ api, size, showClearAll, onPillClick, className }: TMDataGridFilterPillsProps<TData>): import("react").JSX.Element | null;
+declare function TMDataGridFilterPills<TData extends RowData>({ api, size, showClearAll, onPillClick, className, ...others }: TMDataGridFilterPillsProps<TData>): import("react").JSX.Element | null;
 //#endregion
 //#region .types-tmp/components/TMDataGridFooter.d.ts
 /** What the pager is showing. The read half of {@link TMDataGridPaginationApi}. */
@@ -2688,7 +3191,8 @@ type TMDataGridPaginationSlotArgs = TMDataGridPaginationApi & {
  * this function takes only a table.
  */
 declare function getTMDataGridPaginationApi<TData extends RowData>(table: TMDataGridTable<TData>, isPaging?: boolean): TMDataGridPaginationApi;
-type TMDataGridFooterProps = {
+/** Mantine's style props (`mt="sm"`, `px="md"`) are set on the footer bar. */
+type TMDataGridFooterProps = BoxProps & {
   pageSizeOptions?: ReadonlyArray<number>;
   /**
    * Replaces the built-in pager, and is handed the pieces of it.
@@ -2717,7 +3221,7 @@ type TMDataGridFooterProps = {
  * Row totals come from `table.getRowCount()`, which prefers `options.rowCount`
  * - so a server-paged grid shows the server's total without changes here.
  */
-declare function TMDataGridFooter({ pageSizeOptions, renderPagination }: TMDataGridFooterProps): import("react").JSX.Element | null;
+declare function TMDataGridFooter({ pageSizeOptions, renderPagination, className, ...others }: TMDataGridFooterProps): import("react").JSX.Element | null;
 //#endregion
 //#region .types-tmp/components/TMDataGridSearch.d.ts
 type TMDataGridSearchProps = {
@@ -2776,135 +3280,6 @@ type TMDataGridColumnMenuItemsArgs = {
  */
 type TMDataGridColumnMenuItemsRenderer = (args: TMDataGridColumnMenuItemsArgs) => Array<ReactNode>;
 //#endregion
-//#region .types-tmp/core/cellExport.d.ts
-/** The selected block, flattened to text. One inner array per row. */
-type TMDataGridCellMatrix = Array<Array<string>>;
-/**
- * How values are written out.
- *
- * The defaults are the Nordic ones, because they are the ones that need
- * choosing: an Excel running a Swedish, Norwegian, Danish or Finnish locale
- * reads `;` as its list separator and `,` as its decimal mark, and a file
- * written the other way opens as one column of text. Both are settable for a
- * grid whose users run something else.
- */
-type TMDataGridCellExportOptions = {
-  /** CSV field separator. Defaults to `";"`. */
-  separator?: string;
-  /** Write numbers as `1,5` rather than `1.5`. Defaults to `true`. */
-  decimalComma?: boolean;
-  /** Column labels as the first row. Defaults to `true`. */
-  includeHeaders?: boolean;
-  /** Without extension. Defaults to `"export"`. */
-  fileName?: string;
-};
-type ResolvedExportOptions = Required<TMDataGridCellExportOptions>;
-declare const DEFAULT_CELL_EXPORT_OPTIONS: ResolvedExportOptions;
-/**
- * One value as text.
- *
- * Deliberately not the rendered cell: what a cell renders is React, and often a
- * badge, a link or an icon rather than the value. The value is what a
- * spreadsheet wants, and it is the one thing every column is guaranteed to
- * have.
- */
-declare function formatExportValue(value: unknown, { decimalComma }: {
-  decimalComma: boolean;
-}): string;
-type BuildCellMatrixArgs = {
-  rows: ReadonlyArray<Row<TMDataGridFeatures, TMDataGridRowData>>;
-  /** Every visible column, in render order - the same list the bounds index into. */
-  columns: ReadonlyArray<Column<TMDataGridFeatures, TMDataGridRowData, unknown>>;
-  bounds: TMDataGridRangeBounds;
-  includeHeaders: boolean;
-  decimalComma: boolean;
-};
-/**
- * The selected rectangle as rows of text.
- *
- * The generated lanes - the checkbox, the tree chevron, the details chevron -
- * are dropped even when the rectangle covers them. They hold controls rather
- * than data, so a column of empty strings is all they could contribute, and
- * pasting one into a spreadsheet only shifts everything to its right.
- */
-declare function buildCellMatrix({ rows, columns, bounds, includeHeaders, decimalComma }: BuildCellMatrixArgs): TMDataGridCellMatrix;
-/**
- * The whole grid as rows of text: every filtered and sorted data row - all
- * pages, not the one on screen - by every visible non-control column, in
- * render order.
- *
- * The values are the same ones a cell-range export writes; only the bounds
- * differ. Group rows are left out (their records are the rows themselves),
- * and hidden columns are not exported - what you see is what you get, minus
- * paging.
- */
-declare function buildGridCellMatrix<TData extends RowData>({ table, includeHeaders, decimalComma }: {
-  table: TMDataGridTable<TData>;
-  includeHeaders?: boolean;
-  decimalComma?: boolean;
-}): TMDataGridCellMatrix;
-/**
- * Downloads the whole grid as a CSV for Excel - {@link buildGridCellMatrix}
- * through {@link toExcelCsv}, with the same Nordic defaults and overrides as
- * the cell-range export.
- *
- * No built-in button: wire it to your own toolbar.
- *
- * ```tsx
- * <Button onClick={() => exportGridToCsv({ table: grid.table })}>Export</Button>
- * ```
- */
-declare function exportGridToCsv<TData extends RowData>({ table, options }: {
-  table: TMDataGridTable<TData>;
-  options?: TMDataGridCellExportOptions;
-}): void;
-/**
- * The clipboard format spreadsheets read: tab between cells, CRLF between rows.
- *
- * Tabs rather than commas because that is what Excel, Sheets and Numbers all
- * put on the clipboard themselves - paste it and the cells land in cells. A
- * comma-separated string pastes into a single column, which is the thing this
- * exists to avoid.
- */
-declare function toClipboardText(matrix: TMDataGridCellMatrix): string;
-/**
- * A CSV that opens straight into columns in Excel.
- *
- * Three things make that true, and all three are needed:
- *
- * | Part | Why |
- * | ---- | --- |
- * | `sep=;` first line | Excel's own directive - it stops guessing and uses this |
- * | UTF-8 BOM | without it Excel reads the file as ANSI, and å ä ö arrive broken |
- * | CRLF line endings | what Excel writes, and what its importer is happiest with |
- *
- * The `sep=` line is Excel's alone; other readers show it as a first row. This
- * export targets Excel, so opening correctly there takes priority over strict
- * CSV.
- */
-declare function toExcelCsv(matrix: TMDataGridCellMatrix, { separator }: {
-  separator: string;
-}): string;
-/**
- * Puts text on the clipboard, reporting whether it landed.
- *
- * The async clipboard API only resolves for a document that has the focus and a
- * user gesture behind it - both true when this runs off Ctrl+C or a menu item.
- * It is still allowed to reject (a permissions policy, a page that lost focus
- * mid-copy), so the result is a boolean the caller can act on.
- */
-declare function writeClipboardText(text: string): Promise<boolean>;
-/**
- * Downloads text as a file, through the one mechanism a library can use: an
- * anchor with an object URL behind it, clicked. Revoked on the next frame -
- * immediately would race the browser's own read of it.
- */
-declare function downloadTextFile({ fileName, text, mimeType }: {
-  fileName: string;
-  text: string;
-  mimeType?: string;
-}): void;
-//#endregion
 //#region .types-tmp/components/TMDataGridTable.d.ts
 /** Where a column sits relative to the pinned regions, resolved once per render. */
 type TMDataGridColumnLayout = {
@@ -3113,9 +3488,10 @@ type TMDataGridTableProps<TData extends RowData> = {
    */
   rowContextMenuProps?: Omit<MenuProps, "opened" | "onChange" | "children">;
   /**
-   * How Ctrl+C and the export item write values, under
-   * `cellSelection: "range"`. Defaults to the Nordic Excel conventions - see
-   * {@link TMDataGridCellExportOptions}.
+   * @deprecated Set `exportOptions` on `useTMDataGrid` instead; it covers the
+   * cell-range menu and every other export alike. Until it goes, this is
+   * converted (`separator` and `decimalComma` become a `csvExcelFormat`) and
+   * merged over `exportOptions` for the cell-range menu only.
    */
   cellExport?: TMDataGridCellExportOptions;
   /**
@@ -3155,12 +3531,22 @@ type TMDataGridTableProps<TData extends RowData> = {
 declare function TMDataGridTable$1<TData extends RowData = TMDataGridRowData>({ onRowClick, onCellClick, onCellDoubleClick, onCellContextMenu, rowClassName, rowStyle, striped, onScrollToTop, onScrollToBottom, onScrollToLeft, onScrollToRight, renderEmptyState, renderRowContextMenu, renderColumnMenuItems, rowContextMenuProps, cellExport, onReachEnd, reachEndThreshold, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy }: TMDataGridTableProps<TData>): import("react").JSX.Element;
 //#endregion
 //#region .types-tmp/components/TMDataGridToolbar.d.ts
-/** Row above the grid. Compose it from the pieces below, or anything else. */
-declare function TMDataGridToolbar({ children }: {
+type TMDataGridToolbarProps = BoxProps & {
   children?: ReactNode;
-}): import("react").JSX.Element;
-/** Pushes the following toolbar items to the right. */
-declare function TMDataGridToolbarSpacer(): import("react").JSX.Element;
+  /**
+   * Draws a 1px line under the toolbar in the theme's default border colour -
+   * the same line the header draws under itself. Defaults to `false`.
+   */
+  withBottomBorder?: boolean;
+};
+/**
+ * Row above the grid. Compose it from the pieces below, or anything else.
+ * Takes Mantine's style props (`mb="sm"`, `px="md"`, `hiddenFrom="sm"`) and
+ * sets them on the row.
+ */
+declare function TMDataGridToolbar({ children, withBottomBorder, className, mod, ...others }: TMDataGridToolbarProps): import("react").JSX.Element;
+/** Pushes the following toolbar items to the right. Takes Mantine's style props. */
+declare function TMDataGridToolbarSpacer({ className, ...others }: BoxProps): import("react").JSX.Element;
 /**
  * A small spinner shown while `meta.loading` is true, and nothing otherwise.
  *
@@ -3231,6 +3617,7 @@ type TMDataGridProps<TData extends RowData> = TMDataGridApi<TData> & {
    */
   "data-testid"?: string;
 };
+declare function TMDataGridRoot<TData extends RowData>({ table, ui, edit, features, filters, exportOptions, labels, renderDetails, renderDetailsEstHeight, overscan, resetSettings, scrollToRow, scrollerRef, size, children, className, style, id, "data-testid": testId }: TMDataGridProps<TData>): import("react").JSX.Element;
 /**
  * Root of the grid. Takes the object returned by `useTMDataGrid` - spread it -
  * and publishes it to the compound components below it:
@@ -3251,7 +3638,6 @@ type TMDataGridProps<TData extends RowData> = TMDataGridApi<TData> & {
  * </TMDataGrid>
  * ```
  */
-declare function TMDataGridRoot<TData extends RowData>({ table, ui, edit, features, filters, labels, renderDetails, renderDetailsEstHeight, overscan, resetSettings, scrollToRow, scrollerRef, size, children, className, style, id, "data-testid": testId }: TMDataGridProps<TData>): import("react").JSX.Element;
 declare const TMDataGrid: typeof TMDataGridRoot & {
   Toolbar: typeof TMDataGridToolbar;
   Spacer: typeof TMDataGridToolbarSpacer;
@@ -3264,6 +3650,8 @@ declare const TMDataGrid: typeof TMDataGridRoot & {
     ColumnToggles: typeof TMDataGridMenuColumnToggles;
     ShowHideAll: typeof TMDataGridMenuShowHideAll;
     ResetLayout: typeof TMDataGridMenuResetLayout;
+    Export: typeof TMDataGridMenuExport;
+    ExportSelected: typeof TMDataGridMenuExportSelected;
   };
   FilterButton: typeof TMDataGridFilterButton;
   Table: typeof TMDataGridTable$1;
@@ -3305,6 +3693,46 @@ declare const GROUP_COLUMN_ID = "__group__";
  */
 declare function formatGroupValue(value: unknown, blankLabel?: string): string;
 //#endregion
+//#region .types-tmp/useTMDataGridExport.d.ts
+/** What {@link useTMDataGridExport} returns. */
+type TMDataGridExportApi = {
+  /**
+   * Downloads every filtered and sorted row, all pages. `overrides` are folded
+   * over the hook's options for this one call - the column picker's chosen
+   * columns, for instance.
+   */
+  exportAll: (overrides?: TMDataGridExportOptions) => Promise<void>;
+  /**
+   * Downloads the selected rows of the current view, in grid order. Resolves
+   * without a download when none is selected.
+   */
+  exportSelected: (overrides?: TMDataGridExportOptions) => Promise<void>;
+  /** How many rows `exportSelected` would write. Subscribes to the selection. */
+  selectedCount: number;
+  /**
+   * Whether row selection is on at all - `false` under
+   * `selectionMode: "highlight"` or `enableRowSelection: false`, where a
+   * "selected rows" control has nothing to offer.
+   */
+  canExportSelected: boolean;
+};
+/**
+ * The export as click handlers, for a button of your own anywhere inside the
+ * grid. The `TMDataGrid.Menu.Export*` items are this hook behind a
+ * `Menu.Item`.
+ *
+ * ```tsx
+ * function ExportButton() {
+ *   const { exportAll } = useTMDataGridExport();
+ *   return <Button onClick={() => void exportAll()}>Export</Button>;
+ * }
+ * ```
+ *
+ * `overrides` are folded over the grid's `exportOptions` for this caller:
+ * another format, another file name, another set of columns.
+ */
+declare function useTMDataGridExport(overrides?: TMDataGridExportOptions): TMDataGridExportApi;
+//#endregion
 //#region .types-tmp/components/filters/TMDataGridFilterValueInput.d.ts
 /**
  * The built-in value control of a filter row - what renders when a column
@@ -3406,77 +3834,6 @@ declare function TMDataGridMultiSelectEditor({ field, column, row, table, size }
  */
 declare const TMDATAGRID_LABELS_SV: TMDataGridLabels;
 //#endregion
-//#region .types-tmp/core/columnUtils.d.ts
-/**
- * Structural shape of the column bits the chrome reads. Kept minimal so these
- * helpers work with any `Column`/`Header` instance without dragging generics
- * through every call site.
- */
-type ColumnLike = {
-  id: string;
-  columnDef: {
-    header?: unknown;
-    meta?: TMDataGridColumnMeta;
-  };
-  /** Set on a leaf that sits inside a header group. */
-  parent?: unknown;
-};
-/** Menu- and panel-facing column name. */
-declare function getColumnLabel(column: ColumnLike): string;
-declare function getColumnType(column: ColumnLike): TMDataGridColumnType;
-/**
- * The operator a fresh filter on this column starts with -
- * `meta.filter.defaultOperator`, else the type's default.
- */
-declare function getColumnDefaultOperator(column: ColumnLike): TMDataGridFilterOperator;
-/**
- * This column's filter-panel value control - `meta.filter.control`, or
- * `undefined` for the built-in shape-by-operator input.
- */
-declare function getColumnFilterControl(column: ColumnLike): TMDataGridFilterControlComponent | undefined;
-/**
- * Whether `meta.edit.enabled` lets this column's cell on this row be edited -
- * the switch, then the predicate.
- *
- * This is only the column's half of the rule. A cell also needs the column to
- * map to a field (`getEditFieldName`) and the row to take edits at all
- * (`isRowEditable`); `edit.canEditCell` is the whole question.
- */
-declare function isColumnEditableForRow(column: ColumnLike, row: Row<TMDataGridFeatures, TMDataGridRowData>): boolean;
-/**
- * A generated lane holding one fixed-width thing - the checkbox, the details
- * chevron, the row number.
- *
- * They are laid out differently from every other column: cell padding is sized
- * for text and grows with the scale, which at `xl` squeezed a 16px checkbox out
- * of its track, so these lanes centre their content in an unpadded cell.
- * Their headers carry no column menu, and none of them is ever exported -
- * they hold chrome, not values.
- *
- * The tree column is deliberately not one of them: it holds a label as well as a
- * chevron, and wants the padding.
- */
-declare function isControlColumn(columnId: string): boolean;
-/**
- * Whether the grid generated this column rather than the consumer declaring it
- * - the four control lanes plus the tree column.
- *
- * These hold the grid's own chrome, and they keep the edges of the row: the
- * generated left lanes before every consumer column, the edit lane after all of
- * them. `isControlColumn` answers a narrower question about layout, and leaves
- * the tree column out because it is padded like a data column.
- */
-declare function isGeneratedColumn(columnId: string): boolean;
-/**
- * Whether a column may be moved. Ordering is the one column feature TanStack
- * has no column option for, so the switch lives in `meta.enableOrdering`.
- *
- * A leaf inside a header group is never movable: `columnOrder` sequences leaf
- * columns, so moving one out of its group would leave the group header spanning
- * columns that no longer belong to it.
- */
-declare function isColumnReorderable(column: ColumnLike): boolean;
-//#endregion
 //#region .types-tmp/core/grouping.d.ts
 /**
  * The data rows under a group row, at any depth.
@@ -3600,11 +3957,11 @@ type GridTable = TMDataGridTable<TMDataGridRowData>;
  * The lane a column renders in.
  *
  * Pinning splits the grid into three, and TanStack sequences them from two
- * different state slices: `columnPinning.left` / `.right` order the pinned
+ * different state slices: `columnPinning.start` / `.end` order the pinned
  * lanes, `columnOrder` orders the centre. A move therefore always stays inside
  * one lane - moving a column into another one would be a pin, not a reorder.
  */
-type TMDataGridColumnRegion = "left" | "center" | "right";
+type TMDataGridColumnRegion = "start" | "center" | "end";
 /** Which edge of the column under the pointer a dragged column lands on. */
 type TMDataGridDropSide = "before" | "after";
 declare function getColumnRegion(columnPinning: ColumnPinningState, columnId: string): TMDataGridColumnRegion;
@@ -3630,7 +3987,7 @@ declare function moveColumn({ table, columnId, targetId, side }: MoveColumnArgs)
  * Puts the generated lanes back on the outside of both pinned lanes: the ones
  * on the left before every consumer column, the edit lane after all of them.
  *
- * `column.pin("right")` appends, so pinning a column right would otherwise drop
+ * `column.pin("end")` appends, so pinning a column right would otherwise drop
  * it outside the edit lane, so the row's Save and Delete would no longer be
  * last in the row. Pinning left appends too, which is already correct there,
  * but the same pass keeps both lanes in place whatever a consumer writes into
@@ -3756,4 +4113,4 @@ declare function getSelectableRowIds<TData extends RowData>(row: Row<TMDataGridF
  */
 declare function resolveRowSelectionClick<TData extends RowData>({ rows, rowId, anchorRowId, modifiers, selection, canReplaceSelection }: ResolveRowSelectionClickArgs<TData>): ResolvedRowSelection;
 //#endregion
-export { type BuildCellMatrixArgs, type ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_CELL_EXPORT_OPTIONS, DEFAULT_TMDATAGRID_SIZE, DETAILS_COLUMN_ID, DgAutocompleteFilter, DgDateRangeFilter, DgRangeSliderFilter, DgTriStateFilter, EDIT_COLUMN_ID, FILTER_OPERATOR_LABELS, GROUP_COLUMN_ID, type MoveColumnArgs, PERSIST_PAYLOAD_VERSION, ROW_NUMBER_COLUMN_ID, type ResolveCellMoveArgs, type ResolveRangeBoundsArgs, type ResolveRowSelectionClickArgs, type ResolvedRowSelection, SELECT_COLUMN_ID, SETTINGS_STATE_SLICES, SIZE_CONTROL_SIZE, SIZE_ROW_HEIGHT, TMDATAGRID_LABELS_EN, TMDATAGRID_LABELS_SV, TMDataGrid, type TMDataGridAddRowsOptions, type TMDataGridAddRowsResult, type TMDataGridAggregationName, type TMDataGridApi, TMDataGridBooleanEditor, type TMDataGridCapabilities, type TMDataGridCellCoords, type TMDataGridCellEventArgs, type TMDataGridCellExportOptions, type TMDataGridCellMatrix, type TMDataGridCellNav, type TMDataGridCellPosition, type TMDataGridCellRange, type TMDataGridCellSelectionMode, type TMDataGridColumnCapabilities, type TMDataGridColumnEditOptions, type TMDataGridColumnFilter, type TMDataGridColumnFilterOptions, type TMDataGridColumnLayout, type TMDataGridColumnMenuItemsArgs, type TMDataGridColumnMenuItemsRenderer, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnType, type TMDataGridContextValue, type TMDataGridDataSlice, TMDataGridDateEditor, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, TMDataGridDraftActions, type TMDataGridDraftActionsActions, type TMDataGridDraftActionsControls, type TMDataGridDraftActionsProps, type TMDataGridDraftActionsSlotArgs, type TMDataGridDraftActionsState, type TMDataGridDropSide, type TMDataGridEditApi, type TMDataGridEditChange, type TMDataGridEditCommitArgs, type TMDataGridEditCommitDraftsArgs, type TMDataGridEditField, type TMDataGridEditMode, type TMDataGridEditRowProjection, type TMDataGridEditRowSnapshot, type TMDataGridEditState, type TMDataGridEditValueMap, type TMDataGridEditValueMapArgs, type TMDataGridEditingOptions, type TMDataGridEditorArgs, type TMDataGridEditorComponent, type TMDataGridExpandAllArgs, type TMDataGridExpandTarget, type TMDataGridFeatureFlags, type TMDataGridFeatures, type TMDataGridFieldValidate, type TMDataGridFilterControlArgs, type TMDataGridFilterControlComponent, type TMDataGridFilterControlLayout, type TMDataGridFilterOperator, type TMDataGridFilterPanelLayout, type TMDataGridFilterPanelProps, TMDataGridFilterPills, type TMDataGridFilterPillsProps, type TMDataGridFilterSidebarSide, type TMDataGridFilterSurface, type TMDataGridFilterValue, TMDataGridFilterValueInput, type TMDataGridFilterValueShape, type TMDataGridFiltersOptions, type TMDataGridFiltersSettings, type TMDataGridFooterProps, type TMDataGridLabels, type TMDataGridLabelsOverride, type TMDataGridMenuColumnsProps, type TMDataGridMenuProps, TMDataGridMultiSelectEditor, TMDataGridNumberEditor, type TMDataGridOption, type TMDataGridOptionsArgs, type TMDataGridOptionsSource, type TMDataGridPaginationActions, type TMDataGridPaginationApi, type TMDataGridPaginationControls, type TMDataGridPaginationSlotArgs, type TMDataGridPaginationState, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridQuickSearchMode, type TMDataGridRangeBounds, type TMDataGridRowAddArgs, type TMDataGridRowClickModifiers, type TMDataGridRowContextMenuArgs, type TMDataGridRowContextMenuRenderer, type TMDataGridRowData, type TMDataGridRowDeleteArgs, type TMDataGridRowEditForm, type TMDataGridRowStyle, type TMDataGridRowValidators, type TMDataGridSaveDraftsArgs, type TMDataGridSaveDraftsResult, type TMDataGridSaveOutcomes, type TMDataGridScrollAlign, type TMDataGridScrollToRowArgs, TMDataGridSearch, type TMDataGridSearchProps, TMDataGridSelectEditor, type TMDataGridSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, TMDataGridStringEditor, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridTableProps, type TMDataGridTableValidateArgs, type TMDataGridTableValidators, type TMDataGridUiActions, type TMDataGridUiState, type TMDataGridUiStore, type UseTMDataGridOptions, activeColumnFilters, aggregateColumn, areAllRowsExpanded, autosizeColumn, boundsCellCount, boundsEdges, buildCellMatrix, buildGridCellMatrix, clearedValueForType, createTMDataGridColumnHelper, downloadTextFile, emptyValueForOperator, exportGridToCsv, filterValueShape, formatExportValue, formatFilterLabel, formatGroupValue, fuzzyGlobalFilterFn, getColumnCapabilities, getColumnDefaultOperator, getColumnFilterControl, getColumnLabel, getColumnRegion, getColumnType, getDefaultOperator, getDisplayedRows, getEditFieldName, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, isColumnEditableForRow, isColumnReorderable, isControlColumn, isFilterActive, isGeneratedColumn, isPagingActive, isSameCell, isWithinBounds, keepGeneratedColumnsOutermost, measureColumnContentWidth, mergeLabels, moveColumn, moveColumnByStep, normalizeFieldValidate, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, operatorTakesRangeValue, optionsToComboboxData, readFeatureFlags, resolveCellMove, resolveColumnOptions, resolveExpandAll, resolveRangeBounds, resolveRowSelectionClick, tmDataGridFeatures, toClipboardText, toExcelCsv, useTMDataGrid, useTMDataGridContext, writeClipboardText };
+export { type BuildCellMatrixArgs, type BuildExportDataArgs, type ColumnStepArgs, DATA_STATE_SLICES, DEFAULT_CELL_EXPORT_OPTIONS, DEFAULT_EXPORT_OPTIONS, DEFAULT_TMDATAGRID_SIZE, DETAILS_COLUMN_ID, DgAutocompleteFilter, DgDateRangeFilter, DgRangeSliderFilter, DgTriStateFilter, EDIT_COLUMN_ID, type ExportGridArgs, FILTER_OPERATOR_LABELS, GROUP_COLUMN_ID, type MoveColumnArgs, PERSIST_PAYLOAD_VERSION, ROW_NUMBER_COLUMN_ID, type ResolveCellMoveArgs, type ResolveRangeBoundsArgs, type ResolveRowSelectionClickArgs, type ResolvedRowSelection, SELECT_COLUMN_ID, SETTINGS_STATE_SLICES, SIZE_CONTROL_SIZE, SIZE_ROW_HEIGHT, TMDATAGRID_LABELS_EN, TMDATAGRID_LABELS_SV, TMDataGrid, type TMDataGridAddRowsOptions, type TMDataGridAddRowsResult, type TMDataGridAggregationName, type TMDataGridApi, TMDataGridBooleanEditor, type TMDataGridCapabilities, type TMDataGridCellCoords, type TMDataGridCellEventArgs, type TMDataGridCellExportOptions, type TMDataGridCellMatrix, type TMDataGridCellNav, type TMDataGridCellPosition, type TMDataGridCellRange, type TMDataGridCellSelectionMode, type TMDataGridClipboardTextOptions, type TMDataGridColumnCapabilities, type TMDataGridColumnEditOptions, type TMDataGridColumnFilter, type TMDataGridColumnFilterOptions, type TMDataGridColumnLayout, type TMDataGridColumnMenuItemsArgs, type TMDataGridColumnMenuItemsRenderer, type TMDataGridColumnMeta, type TMDataGridColumnRegion, type TMDataGridColumnSearchable, type TMDataGridColumnType, type TMDataGridColumnsPanelProps, type TMDataGridContextValue, type TMDataGridCsvFormatOptions, type TMDataGridDataSlice, TMDataGridDateEditor, type TMDataGridDetailsArgs, type TMDataGridDetailsRenderer, TMDataGridDraftActions, type TMDataGridDraftActionsActions, type TMDataGridDraftActionsControls, type TMDataGridDraftActionsProps, type TMDataGridDraftActionsSlotArgs, type TMDataGridDraftActionsState, type TMDataGridDropSide, type TMDataGridEditApi, type TMDataGridEditChange, type TMDataGridEditCommitArgs, type TMDataGridEditCommitDraftsArgs, type TMDataGridEditField, type TMDataGridEditMode, type TMDataGridEditRowProjection, type TMDataGridEditRowSnapshot, type TMDataGridEditState, type TMDataGridEditValueMap, type TMDataGridEditValueMapArgs, type TMDataGridEditingOptions, type TMDataGridEditorArgs, type TMDataGridEditorComponent, type TMDataGridExpandAllArgs, type TMDataGridExpandTarget, type TMDataGridExportApi, type TMDataGridExportColumns, type TMDataGridExportData, type TMDataGridExportFormat, type TMDataGridExportOptions, type TMDataGridExportPickerRequest, type TMDataGridExportRows, type TMDataGridExportSettings, type TMDataGridExportValueGetter, type TMDataGridExportWriteOptions, type TMDataGridFeatureFlags, type TMDataGridFeatures, type TMDataGridFieldValidate, type TMDataGridFilterControlArgs, type TMDataGridFilterControlComponent, type TMDataGridFilterControlLayout, type TMDataGridFilterOperator, type TMDataGridFilterPanelLayout, type TMDataGridFilterPanelProps, TMDataGridFilterPills, type TMDataGridFilterPillsProps, type TMDataGridFilterSidebarSide, type TMDataGridFilterSurface, type TMDataGridFilterValue, TMDataGridFilterValueInput, type TMDataGridFilterValueShape, type TMDataGridFiltersOptions, type TMDataGridFiltersSettings, type TMDataGridFooterProps, type TMDataGridJsonFormatOptions, type TMDataGridLabels, type TMDataGridLabelsOverride, type TMDataGridMenuColumnsProps, type TMDataGridMenuExportProps, type TMDataGridMenuProps, TMDataGridMultiSelectEditor, TMDataGridNumberEditor, type TMDataGridOption, type TMDataGridOptionsArgs, type TMDataGridOptionsSource, type TMDataGridPaginationActions, type TMDataGridPaginationApi, type TMDataGridPaginationControls, type TMDataGridPaginationSlotArgs, type TMDataGridPaginationState, type TMDataGridPersistKey, type TMDataGridPersistence, type TMDataGridProps, type TMDataGridQuickSearchMode, type TMDataGridRangeBounds, type TMDataGridRowAddArgs, type TMDataGridRowClickModifiers, type TMDataGridRowContextMenuArgs, type TMDataGridRowContextMenuRenderer, type TMDataGridRowData, type TMDataGridRowDeleteArgs, type TMDataGridRowEditForm, type TMDataGridRowStyle, type TMDataGridRowValidators, type TMDataGridSaveDraftsArgs, type TMDataGridSaveDraftsResult, type TMDataGridSaveOutcomes, type TMDataGridScrollAlign, type TMDataGridScrollToRowArgs, TMDataGridSearch, type TMDataGridSearchProps, TMDataGridSelectEditor, type TMDataGridSelectionMode, type TMDataGridSettingsSlice, type TMDataGridSize, type TMDataGridStorageMode, TMDataGridStringEditor, type TMDataGridTable, type TMDataGridTableMeta, type TMDataGridTableProps, type TMDataGridTableValidateArgs, type TMDataGridTableValidators, type TMDataGridToolbarProps, type TMDataGridTsvFormatOptions, type TMDataGridUiActions, type TMDataGridUiState, type TMDataGridUiStore, type UseTMDataGridOptions, activeColumnFilters, aggregateColumn, areAllRowsExpanded, autosizeColumn, boundsCellCount, boundsEdges, buildCellMatrix, buildExportData, buildGridCellMatrix, clearedValueForType, countSelectedExportRows, createTMDataGridColumnHelper, csvExcelFormat, csvFormat, downloadFile, downloadTextFile, emptyValueForOperator, exportGrid, exportGridToCsv, filterValueShape, formatExportValue, formatFilterLabel, formatGroupValue, fromCellExportOptions, fuzzyGlobalFilterFn, getColumnCapabilities, getColumnDefaultOperator, getColumnFilterControl, getColumnLabel, getColumnOperators, getColumnRegion, getColumnType, getDefaultOperator, getDisplayedRows, getEditFieldName, getExportableColumns, getGridCapabilities, getGroupDataRows, getOperatorsForType, getSelectableRowIds, getStepTargetColumn, getTMDataGridPaginationApi, guardFormula, isColumnEditableForRow, isColumnReorderable, isControlColumn, isFilterActive, isGeneratedColumn, isPagingActive, isSameCell, isWithinBounds, jsonFormat, keepGeneratedColumnsOutermost, measureColumnContentWidth, mergeLabels, moveColumn, moveColumnByStep, normalizeFieldValidate, openColumnFilter, operatorNeedsValue, operatorTakesArrayValue, operatorTakesRangeValue, optionsToComboboxData, readFeatureFlags, resolveCellMove, resolveColumnOptions, resolveExpandAll, resolveExportOptions, resolveRangeBounds, resolveRowSelectionClick, tmDataGridFeatures, toClipboardText, toExcelCsv, tsvFormat, useTMDataGrid, useTMDataGridContext, useTMDataGridExport, writeClipboardText, writeExportFile };