@coldsmirk/ledger-mantine 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1189 @@
+
+import { n as defaultLabels, t as DataTableLabels } from "./labels-ChBqD1II.cjs";
+import { BoxProps, ComboboxData, ElementProps, Factory, MantineBreakpoint, MantineColor, MantineSpacing, PopoverProps, StylesApiProps, TableTdProps, TableThProps, TableTrProps, TextInputProps } from "@mantine/core";
+import { Cell as Cell$1, CellData, Column as Column$1, ColumnDef as ColumnDef$1, ColumnFiltersState, ColumnFiltersState as ColumnFiltersState$1, ColumnOrderState, ColumnOrderState as ColumnOrderState$1, ColumnPinningState, ColumnPinningState as ColumnPinningState$1, ColumnSizingState, ColumnSizingState as ColumnSizingState$1, ColumnVisibilityState, ColumnVisibilityState as ColumnVisibilityState$1, ExpandedState, ExpandedState as ExpandedState$1, FilterFn, FilterFnOption, GroupingState, GroupingState as GroupingState$1, Header as Header$1, HeaderGroup as HeaderGroup$1, PaginationState, PaginationState as PaginationState$1, ReactTable, Row as Row$1, RowData, RowData as RowData$1, RowPinningState, RowPinningState as RowPinningState$1, RowSelectionState, RowSelectionState as RowSelectionState$1, SortingState, SortingState as SortingState$1, TableFeatures, TableOptions, flexRender } from "@tanstack/react-table";
+import { CSSProperties, ComponentProps, ComponentType, JSX, KeyboardEvent, MouseEvent, ReactElement, ReactNode, Ref } from "react";
+//#region src/icons.d.ts
+/**
+ * What a replacement icon receives — the two knobs the chrome actually turns. Lucide icons are
+ * drawn on a 24px grid at stroke 2; a custom component is free to ignore either.
+ */
+interface DataTableIconProps {
+  /**
+   * Rendered width and height in px. The chrome passes 12–16 for controls and 40 for the
+   * empty/error indicators.
+   */
+  size?: number;
+  strokeWidth?: number;
+}
+type DataTableIconComponent = ComponentType<DataTableIconProps>;
+/**
+ * Every glyph the table chrome renders, one slot per affordance. Slots are named for the
+ * `DataTableLabels` key of the same affordance where one exists (`pinStart`, `retry`,
+ * `clearSelection`, …), so the two registries read as one vocabulary.
+ */
+interface DataTableIcons {
+  sortAsc: DataTableIconComponent;
+  sortDesc: DataTableIconComponent;
+  /**
+   * The neutral both-directions affordance an unsorted sortable column shows.
+   */
+  sortable: DataTableIconComponent;
+  filterColumn: DataTableIconComponent;
+  expandRow: DataTableIconComponent;
+  /**
+   * The drag handle of the injected row-ordering column, and the ghost that follows a drag.
+   */
+  reorderRow: DataTableIconComponent;
+  empty: DataTableIconComponent;
+  noResults: DataTableIconComponent;
+  error: DataTableIconComponent;
+  retry: DataTableIconComponent;
+  search: DataTableIconComponent;
+  clearSelection: DataTableIconComponent;
+  resetColumns: DataTableIconComponent;
+  reorderColumn: DataTableIconComponent;
+  /**
+   * Both the group toggle and the grouped rest-state mark.
+   */
+  groupByColumn: DataTableIconComponent;
+  pinStart: DataTableIconComponent;
+  unpin: DataTableIconComponent;
+  pinEnd: DataTableIconComponent;
+}
+declare const defaultIcons: DataTableIcons;
+//#endregion
+//#region src/element-props.d.ts
+/**
+ * React's HTML attribute types enumerate every `aria-*` attribute but no `data-*` one: JSX
+ * accepts them through a compiler special case that an object literal does not get. The escape
+ * hatch therefore admits them explicitly — `data-*` is half the point of it.
+ */
+type DataAttributes = Record<`data-${string}`, string | number | boolean | null | undefined>;
+/**
+ * The DOM escape hatch (docs/styling.md#dom-props): every rendered row, cell, and header cell
+ * accepts consumer props — attributes, `data-*`, `aria-*`, inline styles, extra handlers —
+ * either as a static object or as a function of the element's subject.
+ *
+ * `ref` is deliberately excluded from every one of these types: they are declarative prop hooks
+ * resolved per render (per virtual item, for rows), not component instances, and ledger already
+ * owns the row ref for virtualization measurement.
+ */
+type DataTableElementProps<TProps, TSubject> = (TProps & DataAttributes) | ((subject: TSubject) => (TProps & DataAttributes) | undefined);
+//#endregion
+//#region src/ledger-features.d.ts
+declare const ledgerFeatures: {
+  cellSpanningFeature: import("@tanstack/react-table").TableFeature;
+  columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+  columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+  columnGroupingFeature: import("@tanstack/react-table").TableFeature;
+  columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+  columnPinningFeature: import("@tanstack/react-table").TableFeature;
+  columnSizingFeature: import("@tanstack/react-table").TableFeature;
+  columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+  globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+  rowAggregationFeature: import("@tanstack/react-table").TableFeature;
+  rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+  rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+  rowPinningFeature: import("@tanstack/react-table").TableFeature;
+  rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+  rowSortingFeature: import("@tanstack/react-table").TableFeature;
+  expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedMinMaxValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => undefined | [number, number];
+  facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+  filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  groupedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  aggregationFns: {
+    count: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number>;
+    extent: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, [(number | Date) | undefined, (number | Date) | undefined]>;
+    first: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, unknown>;
+    last: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, unknown>;
+    max: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    mean: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number | undefined>;
+    median: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number | undefined>;
+    min: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    sum: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number>;
+    unique: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, unknown[]>;
+    uniqueCount: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number>;
+  };
+  filterFns: {
+    "ledger-date-range": FilterFn<any, any>;
+    "ledger-one-of": FilterFn<any, any>;
+    arrHas: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludes: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludesAll: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludesSome: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    between: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    betweenInclusive: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    empty: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    endsWith: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equalsString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equalsStringSensitive: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    greaterThan: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    greaterThanOrEqualTo: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    inDateRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    inNumberRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    includesString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    includesStringSensitive: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    lessThan: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    lessThanOrEqualTo: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    notEmpty: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    startsWith: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    weakEquals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+  };
+  sortFns: {
+    alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+  };
+};
+type LedgerFeatures = typeof ledgerFeatures;
+/**
+ * TanStack's column helper, pre-bound to the canonical feature set — consumers keep the v8
+ * calling shape (`createColumnHelper<Person>()`), never managing `TFeatures` themselves.
+ */
+declare function createColumnHelper<TData extends RowData$1>(): import("@tanstack/react-table").ColumnHelper<{
+  cellSpanningFeature: import("@tanstack/react-table").TableFeature;
+  columnFacetingFeature: import("@tanstack/react-table").TableFeature;
+  columnFilteringFeature: import("@tanstack/react-table").TableFeature;
+  columnGroupingFeature: import("@tanstack/react-table").TableFeature;
+  columnOrderingFeature: import("@tanstack/react-table").TableFeature;
+  columnPinningFeature: import("@tanstack/react-table").TableFeature;
+  columnSizingFeature: import("@tanstack/react-table").TableFeature;
+  columnVisibilityFeature: import("@tanstack/react-table").TableFeature;
+  globalFilteringFeature: import("@tanstack/react-table").TableFeature;
+  rowAggregationFeature: import("@tanstack/react-table").TableFeature;
+  rowExpandingFeature: import("@tanstack/react-table").TableFeature;
+  rowPaginationFeature: import("@tanstack/react-table").TableFeature;
+  rowPinningFeature: import("@tanstack/react-table").TableFeature;
+  rowSelectionFeature: import("@tanstack/react-table").TableFeature;
+  rowSortingFeature: import("@tanstack/react-table").TableFeature;
+  expandedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedMinMaxValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => undefined | [number, number];
+  facetedRowModel: (table: import("@tanstack/react-table").Table<any, any>, columnId: string) => () => import("@tanstack/react-table").RowModel<any, any>;
+  facetedUniqueValues: (table: import("@tanstack/react-table").Table<import("@tanstack/react-table").TableFeatures, any>, columnId: string) => () => Map<any, number>;
+  filteredRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  groupedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  paginatedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  sortedRowModel: (table: import("@tanstack/react-table").Table<any, any>) => () => import("@tanstack/react-table").RowModel<any, any>;
+  aggregationFns: {
+    count: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number>;
+    extent: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, [(number | Date) | undefined, (number | Date) | undefined]>;
+    first: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, unknown>;
+    last: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, unknown>;
+    max: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    mean: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number | undefined>;
+    median: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number | undefined>;
+    min: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, (number | Date) | undefined>;
+    sum: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number>;
+    unique: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, unknown[]>;
+    uniqueCount: import("@tanstack/react-table").AggregationFnDef<any, any, unknown, number>;
+  };
+  filterFns: {
+    "ledger-date-range": FilterFn<any, any>;
+    "ledger-one-of": FilterFn<any, any>;
+    arrHas: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludes: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludesAll: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    arrIncludesSome: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    between: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    betweenInclusive: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    empty: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    endsWith: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equalsString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    equalsStringSensitive: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    greaterThan: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    greaterThanOrEqualTo: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    inDateRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    inNumberRange: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    includesString: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    includesStringSensitive: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    lessThan: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    lessThanOrEqualTo: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    notEmpty: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    startsWith: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+    weakEquals: import("@tanstack/react-table").CreatedFilterFn<any, any>;
+  };
+  sortFns: {
+    alphanumeric: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    alphanumericCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    basic: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    datetime: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    text: import("@tanstack/react-table").CreatedSortFn<any, any>;
+    textCaseSensitive: import("@tanstack/react-table").CreatedSortFn<any, any>;
+  };
+}, TData>;
+//#endregion
+//#region src/types.d.ts
+/**
+ * TanStack's table instance (the enriched React shape: `state`, `Subscribe`, `FlexRender`),
+ * feature-bound and renamed so it never collides with Mantine's `Table` in consumer imports.
+ */
+type TableInstance<TData extends RowData$1> = ReactTable<LedgerFeatures, TData>;
+type ColumnDef<TData extends RowData$1, TValue extends CellData = CellData> = ColumnDef$1<LedgerFeatures, TData, TValue> & {
+  enableResizing?: boolean;
+};
+type Column<TData extends RowData$1, TValue extends CellData = CellData> = Column$1<LedgerFeatures, TData, TValue>;
+type Row<TData extends RowData$1> = Row$1<LedgerFeatures, TData>;
+type Cell<TData extends RowData$1, TValue extends CellData = CellData> = Cell$1<LedgerFeatures, TData, TValue>;
+/**
+ * The subject of `meta.headerCellProps` / `meta.footerCellProps`, so it is re-exported too.
+ */
+type Header<TData extends RowData$1, TValue extends CellData = CellData> = Header$1<LedgerFeatures, TData, TValue>;
+type HeaderGroup<TData extends RowData$1> = HeaderGroup$1<LedgerFeatures, TData>;
+type DataTableFilterVariant = "text" | "select" | "multi-select" | "range" | "date-range";
+/**
+ * Per-variant configuration, discriminated by `variant`: each member carries exactly the keys its
+ * control reads. A union rather than one optional-everything object because the alternative type-
+ * checks configurations the renderer then ignores — `{ variant: "text", options }` has nowhere to
+ * put the options, and `{ variant: "range", placeholder }` no input to put one on (the bounds
+ * carry `filterRangeMin` / `filterRangeMax` instead).
+ */
+type DataTableFilterConfig = {
+  variant: "text";
+  placeholder?: string;
+} | {
+  variant: "select" | "multi-select";
+  /**
+   * Omitted in client mode → derived from faceted values; server mode requires it.
+   */
+  options?: ComboboxData;
+  placeholder?: string;
+} | {
+  variant: "range" | "date-range";
+};
+/**
+ * Renders a session editor into an editing cell. The host owns the session around it — the
+ * draft, the keyboard map, blur commit, pending state, and the whole lifecycle — the renderer
+ * only supplies the control (docs/editing.md#editors). The shipped `textEditor` / `numberEditor`
+ * / `selectEditor` helpers are renderers of exactly this shape.
+ */
+type DataTableEditRenderer<TData extends RowData$1, TValue> = (ctx: DataTableEditContext<TData, TValue>) => ReactNode;
+/**
+ * Renders an instant-apply control living in the cell itself — no session and no trigger: each
+ * change the control reports through `ctx.commit(value)` is one commit
+ * (docs/editing.md#instant-editing). The shipped `checkboxEditor` helper is one of these.
+ */
+type DataTableInstantEditRenderer<TData extends RowData$1, TValue> = (ctx: DataTableInstantEditContext<TData, TValue>) => ReactNode;
+interface DataTableEditConfigBase<TData extends RowData$1, TValue> {
+  /**
+   * Per-row gate on top of the table-level `enableEditing`.
+   */
+  enabled?: (row: Row<TData>) => boolean;
+  /**
+   * A non-null message blocks the commit and is shown on the editor.
+   */
+  validate?: (value: TValue, row: Row<TData>) => string | null;
+}
+/**
+ * A session editor with its gates. The bare renderer form is this config with neither gate.
+ */
+interface DataTableEditConfig<TData extends RowData$1, TValue> extends DataTableEditConfigBase<TData, TValue> {
+  render: DataTableEditRenderer<TData, TValue>;
+}
+/**
+ * An instant-apply control with its gates. Discriminated from the session config by its key:
+ * `instant` and `render` carry different contexts, so which one a column declares is which
+ * interaction model its cells get.
+ */
+interface DataTableInstantEditConfig<TData extends RowData$1, TValue> extends DataTableEditConfigBase<TData, TValue> {
+  instant: DataTableInstantEditRenderer<TData, TValue>;
+}
+interface DataTableEditContext<TData extends RowData$1, TValue> {
+  row: Row<TData>;
+  column: Column<TData, TValue>;
+  value: TValue;
+  setValue: (value: TValue) => void;
+  /**
+   * Returns whether validation and the application commit succeeded. Async commits resolve to
+   * the same result; rejection is presented as an editor error rather than rethrown. In row
+   * mode, `commit` and `cancel` operate on the whole row, matching the keyboard map.
+   */
+  commit: () => boolean | Promise<boolean>;
+  cancel: () => void;
+  error: string | null;
+  /**
+   * A write for this editor is still out — the cell's in cell mode, the whole row's in row mode.
+   * The host cannot know what to disable, so the renderer reads the flag and decides for itself
+   * (docs/editing.md#editors).
+   */
+  pending: boolean;
+  /**
+   * Which session hosts the editor. A renderer may adapt — the select helper opens its dropdown
+   * immediately and commits on pick only in cell mode, where one cell is the whole session.
+   */
+  mode: DataTableEditMode;
+  /**
+   * Whether this editor should take focus as it mounts: always in cell mode; in row mode only
+   * the column the session was started from.
+   */
+  autoFocus: boolean;
+  /**
+   * Localized accessible name for the control (`labels.editColumn` over the column title) — an
+   * editor is one of many identical controls in the grid, told apart by the column it edits.
+   */
+  label: string;
+}
+interface DataTableInstantEditContext<TData extends RowData$1, TValue> {
+  row: Row<TData>;
+  column: Column<TData, TValue>;
+  /**
+   * The value the cell holds as far as the application knows: the value this cell has already
+   * written while the data has not caught up with it, else the data's own.
+   */
+  value: TValue;
+  /**
+   * Commits `value` in one act — validation, the application handler, pending, and failure
+   * presentation all run exactly as a session commit's would. In row mode the control joins the
+   * row like any other editor: the call stages the value in the row draft, and the atomic row
+   * commit owns the write.
+   */
+  commit: (value: TValue) => boolean | Promise<boolean>;
+  /**
+   * This cell's own write is still out; the control should disable itself so a second change
+   * cannot race the first.
+   */
+  pending: boolean;
+  error: string | null;
+  /**
+   * Localized accessible name for the control (`labels.editColumn` over the column title).
+   */
+  label: string;
+}
+interface DataTableEditCommit<TData extends RowData$1> {
+  row: Row<TData>;
+  column: Column<TData, unknown>;
+  value: unknown;
+  previousValue: unknown;
+}
+interface DataTableEditingCell {
+  rowId: string;
+  columnId: string;
+}
+/**
+ * A completed row drag (docs/rows.md#row-ordering). Indexes address the `data` array — row
+ * order is data order — with `arrayMove` semantics: remove the row at `fromIndex`, insert it
+ * at `toIndex`.
+ */
+interface DataTableRowReorder<TData extends RowData$1> {
+  row: Row<TData>;
+  fromIndex: number;
+  toIndex: number;
+}
+type DataTableEditTrigger = "double-click" | "click";
+/**
+ * `"cell"` (default) edits one cell at a time, committing per cell; `"row"` opens every
+ * editable cell of a row at once and commits the row atomically (docs/editing.md#row-mode).
+ */
+type DataTableEditMode = "cell" | "row";
+interface DataTableRowEditCommit<TData extends RowData$1> {
+  row: Row<TData>;
+  /**
+   * Current values for every editable column of the row, keyed by column id — drafts where the
+   * user typed, unchanged accessor values elsewhere.
+   */
+  values: Record<string, unknown>;
+  previousValues: Record<string, unknown>;
+}
+interface DataTableExportMeta<TData extends RowData$1> {
+  /**
+   * Column title in the exported header line; defaults to the string `header` (or the id).
+   */
+  header?: string;
+  /**
+   * Cell value for the export; defaults to the accessor value. Runs before serialization, so
+   * anything `toCsv` can serialize (string, number, Date, object) is a valid return.
+   */
+  value?: (row: Row<TData>) => unknown;
+}
+type DataTablePersistableSlice = "sorting" | "columnFilters" | "globalFilter" | "pagination" | "columnVisibility" | "columnPinning" | "columnOrder" | "columnSizing" | "grouping";
+interface DataTablePersistState {
+  /**
+   * Storage key; one table per key.
+   */
+  key: string;
+  /**
+   * Which slices persist; defaults to the layout set: sizing, visibility, order, pinning.
+   */
+  slices?: DataTablePersistableSlice[];
+  /**
+   * Storage backend; defaults to `localStorage` (guarded — persistence is a no-op without it).
+   */
+  storage?: Pick<Storage, "getItem" | "setItem" | "removeItem">;
+}
+interface UseDataTableOptions<TData extends RowData$1> {
+  data: TData[];
+  columns: Array<ColumnDef<TData, any>>;
+  getRowId?: (originalRow: TData, index: number, parent?: Row<TData>) => string;
+  enableSorting?: boolean;
+  enableMultiSort?: boolean;
+  enableSortingRemoval?: boolean;
+  enableColumnFilters?: boolean;
+  enableGlobalFilter?: boolean;
+  enablePagination?: boolean;
+  enableRowSelection?: boolean | ((row: Row<TData>) => boolean);
+  enableMultiRowSelection?: boolean;
+  /**
+   * Ledger-owned switch (TanStack's name): the resize interaction is ledger's own pointer
+   * session, so no TanStack option backs it (docs/sizing.md).
+   */
+  enableColumnResizing?: boolean;
+  enableColumnPinning?: boolean;
+  enableColumnOrdering?: boolean;
+  enableHiding?: boolean;
+  enableEditing?: boolean;
+  enableGrouping?: boolean;
+  enableRowPinning?: boolean;
+  /**
+   * Cells may merge via the defs' `spanRows` / `spanColumns` (TanStack v9
+   * `cellSpanningFeature`). On by default; spanning is ignored while `virtualizedRows` (a
+   * merged cell breaks the one-`<tr>`-per-virtual-item invariant) or `virtualizedColumns` (it
+   * would reach across the windowed colgroup).
+   */
+  enableCellSpanning?: boolean;
+  getSubRows?: (originalRow: TData) => TData[] | undefined;
+  renderDetailPanel?: (row: Row<TData>) => ReactNode;
+  /**
+   * Overrides the injected selection column: its `cell` / `header` renderers, `size`, alignment,
+   * anything a `ColumnDef` carries. The reserved `id` is not overridable — it is how ledger
+   * recognizes its own column.
+   */
+  selectionColumn?: Partial<ColumnDef<TData, unknown>>;
+  /**
+   * Overrides the injected expander column, on the same terms as `selectionColumn`.
+   */
+  expanderColumn?: Partial<ColumnDef<TData, unknown>>;
+  sortingMode?: "client" | "server";
+  filterMode?: "client" | "server";
+  paginationMode?: "client" | "server";
+  /**
+   * Server-mode total row count; `pageCount` is derived internally.
+   */
+  rowCount?: number;
+  editTrigger?: DataTableEditTrigger;
+  editMode?: DataTableEditMode;
+  onEditCommit?: (change: DataTableEditCommit<TData>) => void | Promise<void>;
+  /**
+   * Row-mode atomic commit: every editable column's value, changed or not. Only consulted
+   * while `editMode: "row"`.
+   */
+  onRowEditCommit?: (change: DataTableRowEditCommit<TData>) => void | Promise<void>;
+  /**
+   * A single keyboard-reachable current row (row click or ↑/↓/Home/End on the focused body;
+   * Enter fires `onRowClick`), independent from checkbox selection. Off by default.
+   */
+  enableActiveRow?: boolean;
+  /**
+   * Drag-and-drop row reordering through an injected handle column. Row order IS data order —
+   * there is no order state — so a completed drag hands the move to `onRowReorder` and the
+   * application reorders `data`. Handles disable while sorting, a filter, a search or grouping
+   * controls the visible order; flat data only (`getSubRows` is not supported). Off by default.
+   */
+  enableRowOrdering?: boolean;
+  /**
+   * A completed drag: apply the move to `data` (`arrayMove` semantics, `fromIndex` → `toIndex`).
+   * Without this handler the switch is inert and no handle column is injected.
+   */
+  onRowReorder?: (reorder: DataTableRowReorder<TData>) => void;
+  /**
+   * Overrides the injected drag-handle column, on the same terms as `selectionColumn`.
+   */
+  rowDragColumn?: Partial<ColumnDef<TData, unknown>>;
+  sorting?: SortingState$1;
+  defaultSorting?: SortingState$1;
+  onSortingChange?: (value: SortingState$1) => void;
+  columnFilters?: ColumnFiltersState$1;
+  defaultColumnFilters?: ColumnFiltersState$1;
+  onColumnFiltersChange?: (value: ColumnFiltersState$1) => void;
+  globalFilter?: string;
+  defaultGlobalFilter?: string;
+  onGlobalFilterChange?: (value: string) => void;
+  pagination?: PaginationState$1;
+  defaultPagination?: PaginationState$1;
+  onPaginationChange?: (value: PaginationState$1) => void;
+  rowSelection?: RowSelectionState$1;
+  defaultRowSelection?: RowSelectionState$1;
+  onRowSelectionChange?: (value: RowSelectionState$1) => void;
+  expanded?: ExpandedState$1;
+  defaultExpanded?: ExpandedState$1;
+  onExpandedChange?: (value: ExpandedState$1) => void;
+  columnVisibility?: ColumnVisibilityState$1;
+  defaultColumnVisibility?: ColumnVisibilityState$1;
+  onColumnVisibilityChange?: (value: ColumnVisibilityState$1) => void;
+  columnPinning?: ColumnPinningState$1;
+  defaultColumnPinning?: ColumnPinningState$1;
+  onColumnPinningChange?: (value: ColumnPinningState$1) => void;
+  columnOrder?: ColumnOrderState$1;
+  defaultColumnOrder?: ColumnOrderState$1;
+  onColumnOrderChange?: (value: ColumnOrderState$1) => void;
+  columnSizing?: ColumnSizingState$1;
+  defaultColumnSizing?: ColumnSizingState$1;
+  onColumnSizingChange?: (value: ColumnSizingState$1) => void;
+  grouping?: GroupingState$1;
+  defaultGrouping?: GroupingState$1;
+  onGroupingChange?: (value: GroupingState$1) => void;
+  rowPinning?: RowPinningState$1;
+  defaultRowPinning?: RowPinningState$1;
+  onRowPinningChange?: (value: RowPinningState$1) => void;
+  /**
+   * Non-TanStack slice (like editing); the value is the active row's id.
+   */
+  activeRowId?: string | null;
+  defaultActiveRowId?: string | null;
+  onActiveRowIdChange?: (value: string | null) => void;
+  /**
+   * Non-TanStack slice; editing has no meaningful default.
+   */
+  editingCell?: DataTableEditingCell | null;
+  onEditingCellChange?: (value: DataTableEditingCell | null) => void;
+  /**
+   * Row-mode counterpart of `editingCell` (the editing row's id).
+   */
+  editingRowId?: string | null;
+  onEditingRowIdChange?: (value: string | null) => void;
+  persistState?: DataTablePersistState;
+  defaultColumn?: Partial<ColumnDef<TData, unknown>>;
+  /**
+   * Custom filter functions, registered by id on the table's feature set so their names are
+   * valid `filterFn` / `globalFilterFn` strings (TanStack v9 registry slots). Merged over the
+   * built-ins; ledger's two reserved ids win with a dev warning. Read once at mount — the
+   * registry wires code, not reactive state.
+   */
+  filterFns?: Record<string, FilterFn<any, any>>;
+  /**
+   * Full escape hatch, merged first; ledger-managed keys override with a dev warning (docs/state.md).
+   * `globalFilterFn` additionally accepts any string so ids registered through `filterFns`
+   * stay usable without a cast — unregistered ids fail at runtime with TanStack's dev warning.
+   */
+  tableOptions?: Omit<Partial<TableOptions<LedgerFeatures, TData>>, "globalFilterFn"> & {
+    globalFilterFn?: FilterFnOption<LedgerFeatures, TData> | (string & {});
+  };
+}
+interface DataTableScrollOptions {
+  align?: "start" | "center" | "end" | "auto";
+  behavior?: "auto" | "smooth";
+}
+interface DataTableHandle<TData extends RowData$1> {
+  table: TableInstance<TData>;
+  /**
+   * The ScrollArea viewport element.
+   */
+  viewport: HTMLDivElement | null;
+  /**
+   * Scrolls the row with this id into view. Separate from `scrollToIndex` rather than one
+   * parameter accepting both: `getRowId` may well return digits, and a table whose ids read
+   * `"5"` could not say which of the two it meant.
+   */
+  scrollToRow: (rowId: string, options?: DataTableScrollOptions) => void;
+  /**
+   * Scrolls the row at this position in the page's own row model into view.
+   */
+  scrollToIndex: (index: number, options?: DataTableScrollOptions) => void;
+  /**
+   * Scrolls the column with this id into view — width-engine math, so a column a virtual
+   * window is not rendering is still reachable. Pinned columns are already in view; a no-op.
+   */
+  scrollToColumn: (columnId: string, options?: DataTableScrollOptions) => void;
+  /**
+   * Cell mode requires `columnId`; row mode takes the id of any editable column to focus, or
+   * none.
+   */
+  startEditing: (rowId: string, columnId?: string) => void;
+  stopEditing: (options?: {
+    commit?: boolean;
+  }) => void;
+}
+/**
+ * What a mounted cell-mode editor hands the controller. Only what is genuinely per-instance: the
+ * editor holds no state of its own, so everything it shows it reads back from the session.
+ */
+interface LedgerCellEditor {
+  /**
+   * Something the editor shows has changed in the session — draw again.
+   */
+  redraw: () => void;
+}
+/**
+ * What a mounted row-mode editor hands the controller. Only what is genuinely per-instance: the
+ * editor holds no state of its own, so everything else it shows it reads back from the session.
+ */
+interface LedgerRowEditor {
+  focus: () => void;
+  /**
+   * Something the editor shows has changed in the session — draw again.
+   */
+  redraw: () => void;
+}
+interface LedgerRowEditingController {
+  id: string | null;
+  /**
+   * Whether this row has a live editing session. The slice naming a row is not enough — its gate
+   * may have shut while the application declined to close it — and the render layer asks this
+   * before putting an interactive editor on screen.
+   */
+  active: (rowId: string) => boolean;
+  /**
+   * Starts editing the row; an already-editing other row is committed first (commit, never
+   * discard), and the start only proceeds if that commit succeeds. `focusColumnId` marks
+   * which cell's editor autofocuses.
+   */
+  start: (rowId: string, options?: {
+    focusColumnId?: string;
+  }) => void;
+  /**
+   * Commits (default) or cancels the whole row atomically. Imperative: use `commit` when the
+   * answer matters.
+   */
+  stop: (options?: {
+    commit?: boolean;
+  }) => void;
+  /**
+   * Commits the whole row and reports whether it went through — validation and the application's
+   * handler both. What an editor renderer's `commit` returns (docs/editing.md#editors).
+   */
+  commit: () => boolean | Promise<boolean>;
+  /**
+   * Whether this column's editor should autofocus for the current session.
+   */
+  shouldFocus: (columnId: string) => boolean;
+  /**
+   * The row's editing store. It outlives editor unmounts, so a virtualized editing row that
+   * scrolls out and back keeps what was typed into it, and it is addressed by row: an editor
+   * names the row it belongs to rather than trusting the controller's idea of which row is
+   * current, so two rows' editors mounted at once during a switch cannot read each other's
+   * values.
+   */
+  drafts: {
+    /**
+     * Whether a write for this row is still out. Editors disable themselves on it.
+     */
+    pending: (rowId: string) => boolean;
+    /**
+     * The message this column is carrying, if any: a `validate` rejection on that column, or a
+     * row-level failure, which lands on the row's first editable column.
+     */
+    error: (rowId: string, columnId: string) => string | null;
+    /**
+     * What the editor should show: the pending value if there is one, else what this session has
+     * already written, else `source` — the cell's own value, supplied by the render doing the
+     * drawing. That render is the authority on what it is drawing; the event-time paths resolve
+     * their own values from the committed snapshot instead (docs/architecture.md).
+     */
+    read: (rowId: string, columnId: string, source: unknown) => unknown;
+    write: (rowId: string, columnId: string, value: unknown) => void;
+  };
+  register: (columnId: string, editor: LedgerRowEditor) => () => void;
+}
+interface LedgerEditingController {
+  mode: DataTableEditMode;
+  cell: DataTableEditingCell | null;
+  /**
+   * Whether this cell has a live editing session. The slice naming a cell is not enough — its
+   * gate may have shut while the application declined to close it — and the render layer asks
+   * this before putting an interactive editor on screen.
+   */
+  active: (rowId: string, columnId: string) => boolean;
+  start: (cell: DataTableEditingCell) => void;
+  /**
+   * Commits (default) or discards what the session holds. A successful commit asks for the slice
+   * to close; a failure keeps the session. Imperative — use `commit` when the answer matters.
+   */
+  stop: (options?: {
+    commit?: boolean;
+  }) => void;
+  /**
+   * Clears the slice directly.
+   */
+  clear: () => void;
+  /**
+   * Commits or discards what the session holds. The editors call these for Enter and Escape; the
+   * logic itself belongs to the session, because an editor can be unmounted at any moment.
+   */
+  commit: () => boolean | Promise<boolean>;
+  cancel: () => void;
+  /**
+   * Commits and moves to the row's next (or previous) editable cell — Tab and Shift+Tab. The
+   * session answers it, because where the caret goes next depends on the row as the render that
+   * reached the screen had it, and an editor could only ask the shared core.
+   */
+  moveTo: (backwards: boolean) => void;
+  /**
+   * The cell session's editing store, addressed by cell for the same reason row mode's is
+   * addressed by row: two editors for one cell can exist at once while React reconciles a
+   * remount, and a settled write must not act on the instance that replaced the one that sent it.
+   */
+  drafts: {
+    pending: (rowId: string, columnId: string) => boolean;
+    error: (rowId: string, columnId: string) => string | null;
+    /**
+     * What the editor should show: the pending value if there is one, else what this session has
+     * already written, else `source` — the cell's own value, supplied by the render doing the
+     * drawing. That render is the authority on what it is drawing; the event-time paths resolve
+     * their own values from the committed snapshot instead (docs/architecture.md).
+     */
+    read: (rowId: string, columnId: string, source: unknown) => unknown;
+    write: (rowId: string, columnId: string, value: unknown) => void;
+  };
+  /**
+   * A mounted editor registers while it is on screen; its departure arms the unmount commit.
+   */
+  register: (rowId: string, columnId: string, editor: LedgerCellEditor) => () => void;
+  /**
+   * Where F2 enters a row: its first editable cell in display order, as the render that reached
+   * the screen had it — the order, the gate and each column's editing kind all come from there
+   * rather than from the shared core, which carries whatever render pass ran last, committed or
+   * not (docs/architecture.md). `skipInstant` is the mode: cell mode has no editor to open on an
+   * instant column, row mode does.
+   */
+  firstEditable: (rowId: string, skipInstant: boolean) => string | null;
+  /**
+   * The instant-apply controls' transient edits. Not a session: a change *is* the commit, so
+   * there is nothing to open or close — but the write still out, the failure it came back with
+   * and the value the application now holds all outlive the control that sent them, and any
+   * number of cells can have one at once (docs/editing.md).
+   */
+  instant: LedgerInstantEditingController;
+  /**
+   * Row-mode surface; inert while `mode` is `"cell"`.
+   */
+  row: LedgerRowEditingController;
+}
+interface LedgerInstantEditingController {
+  /**
+   * What the control shows: the value this cell has written while the data has not moved past
+   * it, else the data's own.
+   */
+  value: (rowId: string, columnId: string, source: unknown) => unknown;
+  pending: (rowId: string, columnId: string) => boolean;
+  error: (rowId: string, columnId: string) => string | null;
+  /**
+   * Commits one value in one act, against what the application last knew the cell to hold.
+   * Addressed, not handed a `Cell`: the cell would carry the shared core with it, and everything
+   * this decides with comes from the render that reached the screen.
+   */
+  commit: (rowId: string, columnId: string, value: unknown) => boolean | Promise<boolean>;
+  register: (rowId: string, columnId: string, editor: LedgerCellEditor) => () => void;
+}
+interface LedgerMeta<TData extends RowData$1> {
+  /**
+   * The stable processed column definitions — the render layer's memo token. TanStack v9
+   * re-resolves `table.options` on every state tick, so `options.columns` identity is not a
+   * "definitions changed" signal anymore; this reference is.
+   */
+  columns: Array<ColumnDef<TData, any>>;
+  editing: LedgerEditingController;
+  filtering: {
+    subscribeColumnFilters: (listener: (value: ColumnFiltersState$1) => void) => () => void;
+    subscribeGlobalFilter: (listener: (value: string) => void) => () => void;
+  };
+  editTrigger: DataTableEditTrigger;
+  enableEditing: boolean;
+  onEditCommit?: (change: DataTableEditCommit<TData>) => void | Promise<void>;
+  onRowEditCommit?: (change: DataTableRowEditCommit<TData>) => void | Promise<void>;
+  renderDetailPanel?: (row: Row<TData>) => ReactNode;
+  /**
+   * Header checkbox scope: current page when paginated, all filtered rows otherwise (docs/selection.md).
+   */
+  selectAllScope: "page" | "all";
+  /**
+   * The active-row slice (docs/rows.md): a single keyboard-reachable current row.
+   */
+  activeRow: {
+    enabled: boolean;
+    id: string | null;
+    set: (id: string | null) => void;
+  };
+  /**
+   * Header drag-reorder affordance (ledger-owned; TanStack has state but no switch).
+   */
+  enableColumnOrdering: boolean;
+  /**
+   * Row drag reordering (docs/rows.md#row-ordering). `enabled` is the static gate — switch on,
+   * handler present, flat data — and decides the handle column; `orderable` is the live one —
+   * false while sorting, a filter, a search or grouping controls the visible order, which is
+   * when the handles disable.
+   */
+  rowOrdering: {
+    enabled: boolean;
+    orderable: boolean;
+    onRowReorder?: (reorder: DataTableRowReorder<TData>) => void;
+  };
+  /**
+   * Pagination master switch (ledger-owned; TanStack expresses it via row-model inclusion).
+   */
+  enablePagination: boolean;
+  /**
+   * Resize affordance switch (ledger-owned; the TanStack option belongs to the unregistered
+   * `columnResizingFeature`).
+   */
+  enableColumnResizing: boolean;
+}
+declare module "@tanstack/react-table" {
+  interface ColumnMeta<in out TFeatures extends TableFeatures, in out TData extends RowData$1, TValue extends CellData = CellData> {
+    /**
+     * Plain-text column name for the chrome that cannot render the `header` — the columns panel,
+     * CSV headers, filter and editor field names. Defaults to the string `header`, then the
+     * column id; a column whose `header` is a render function should declare one.
+     */
+    label?: string;
+    /**
+     * Logical text alignment — RTL-correct by construction.
+     */
+    align?: "start" | "center" | "end";
+    /**
+     * Single-line truncation with a title tooltip (host vocabulary: `Text.truncate`).
+     */
+    truncate?: boolean;
+    /**
+     * Header filter UI: a variant shorthand, a config, or a fully custom renderer.
+     */
+    filter?: DataTableFilterVariant | DataTableFilterConfig | ((column: Column<TData, TValue>) => ReactNode);
+    /**
+     * Inline cell editing: a session-editor renderer (bare or in a config with gates), or an
+     * instant-apply control (docs/editing.md). Rendering always belongs to the application —
+     * the shipped `textEditor` / `numberEditor` / `selectEditor` / `checkboxEditor` helpers are
+     * renderers built on the same public contexts.
+     */
+    edit?: DataTableEditRenderer<TData, TValue> | DataTableEditConfig<TData, TValue> | DataTableInstantEditConfig<TData, TValue>;
+    /**
+     * DOM props for this column's body cells — static, or per cell.
+     */
+    cellProps?: DataTableElementProps<Omit<TableTdProps, "ref">, Cell<TData, TValue>>;
+    /**
+     * DOM props for this column's header cell — static, or per header (group headers included).
+     */
+    headerCellProps?: DataTableElementProps<Omit<TableThProps, "ref">, Header<TData, TValue>>;
+    /**
+     * DOM props for this column's footer cell — static, or per footer.
+     */
+    footerCellProps?: DataTableElementProps<Omit<TableThProps, "ref">, Header<TData, TValue>>;
+    /**
+     * `toCsv` column control: `false` excludes the column; an object overrides the exported
+     * header text or derives the exported value.
+     */
+    export?: false | DataTableExportMeta<TData>;
+    /**
+     * Removes the column at and above the breakpoint (host vocabulary: `Box.hiddenFrom`).
+     * Breakpoint values follow the Mantine theme.
+     */
+    hiddenFrom?: MantineBreakpoint;
+    /**
+     * Shows the column only at and above the breakpoint (host vocabulary: `Box.visibleFrom`).
+     */
+    visibleFrom?: MantineBreakpoint;
+  }
+  interface TableMeta<in out TFeatures extends TableFeatures, in out TData extends RowData$1> {
+    ledger?: LedgerMeta<TData>;
+  }
+}
+//#endregion
+//#region src/columns-panel.d.ts
+interface DataTableColumnsPanelProps<TData extends RowData$1> {
+  table: TableInstance<TData>;
+  /**
+   * The control that opens the panel, wrapped as the Popover target — a button, an icon in a
+   * header cell, anything. Omitted: the panel renders bare for a drawer, a sidebar, or a page
+   * of its own.
+   */
+  children?: ReactElement;
+  /**
+   * Forwarded to the Popover; only meaningful alongside a trigger.
+   */
+  popoverProps?: Omit<PopoverProps, "children">;
+  labels?: Partial<DataTableLabels>;
+  icons?: Partial<DataTableIcons>;
+  className?: string;
+  style?: CSSProperties;
+}
+declare function DataTableColumnsPanel<TData extends RowData$1>(props: DataTableColumnsPanelProps<TData>): import("react").JSX.Element;
+//#endregion
+//#region src/csv.d.ts
+interface ToCsvOptions {
+  /**
+   * Which rows to export:
+   * - `"filtered"` (default) — everything after filters and sorting, before pagination;
+   * - `"all"` — the unfiltered data set;
+   * - `"page"` — the current page (identical to `"filtered"` without pagination);
+   * - `"selected"` — the current selection.
+   */
+  scope?: "filtered" | "all" | "page" | "selected";
+  delimiter?: string;
+  /**
+   * Include the header line. Default true.
+   */
+  withHeaders?: boolean;
+  /**
+   * Prefix text a spreadsheet would evaluate as a formula (leading `=`, `+`, `-`, `@`, tab or
+   * CR — the OWASP CSV-injection set) with a `'`. Applies to header text and string-valued
+   * cells; numeric cells keep their sign. Default false — the quote is data to every
+   * non-spreadsheet consumer, so it is opt-in for exports that feed spreadsheets.
+   */
+  escapeFormulas?: boolean;
+}
+declare function toCsv<TData extends RowData$1>(table: TableInstance<TData>, options?: ToCsvOptions): string;
+//#endregion
+//#region src/pagination-bar.d.ts
+interface DataTablePaginationProps<TData extends RowData$1> {
+  table: TableInstance<TData>;
+  pageSizeOptions?: number[];
+  labels?: Partial<DataTableLabels>;
+  className?: string;
+  style?: CSSProperties;
+}
+/**
+ * Standalone compound (`DataTable.Pagination`) — place it anywhere, theme it via defaultProps.
+ */
+declare function DataTablePagination<TData extends RowData$1>(props: DataTablePaginationProps<TData>): import("react").JSX.Element;
+//#endregion
+//#region src/search.d.ts
+interface DataTableSearchProps<TData extends RowData$1> extends Omit<TextInputProps, "value" | "defaultValue" | "onChange"> {
+  table: TableInstance<TData>;
+  /**
+   * Debounce before the global filter applies, in milliseconds.
+   */
+  debounce?: number;
+  labels?: Partial<DataTableLabels>;
+  icons?: Partial<DataTableIcons>;
+}
+declare function DataTableSearch<TData extends RowData$1>(props: DataTableSearchProps<TData>): import("react").JSX.Element;
+//#endregion
+//#region src/selection-bar.d.ts
+interface DataTableSelectionBarProps<TData extends RowData$1> {
+  table: TableInstance<TData>;
+  labels?: Partial<DataTableLabels>;
+  icons?: Partial<DataTableIcons>;
+  /**
+   * Bulk actions, rendered after the count and clear control.
+   */
+  children?: ReactNode;
+  className?: string;
+  style?: CSSProperties;
+}
+declare function DataTableSelectionBar<TData extends RowData$1>(props: DataTableSelectionBarProps<TData>): import("react").JSX.Element | null;
+//#endregion
+//#region src/data-table.d.ts
+type DataTableStylesNames = "root" | "main" | "header" | "scroller" | "footer" | "table" | "thead" | "tbody" | "tfoot" | "headerRow" | "headerCell" | "headerLabel" | "headerActions" | "sortIndicator" | "resizer" | "filterPopover" | "row" | "cell" | "selectionCell" | "expanderCell" | "detailPanel" | "cellEditor" | "instantCell" | "instantSpinner" | "rowDragCell" | "rowDragOverlay" | "footerRow" | "footerCell" | "empty" | "loaderRow" | "loaderRowContent" | "paginationBar";
+interface DataTableCssVariables {
+  root: "--ledger-striped-color" | "--ledger-hover-color" | "--ledger-border-color";
+}
+interface DataTableBaseProps<TData extends RowData$1> extends BoxProps, StylesApiProps<DataTableFactory>, ElementProps<"div"> {
+  /**
+   * Root element ref (React 19 ref-as-prop; genericFactory components receive it here).
+   */
+  ref?: Ref<HTMLDivElement>;
+  striped?: boolean | "odd" | "even";
+  stripedColor?: MantineColor;
+  highlightOnHover?: boolean;
+  highlightOnHoverColor?: MantineColor;
+  withTableBorder?: boolean;
+  withColumnBorders?: boolean;
+  withRowBorders?: boolean;
+  borderColor?: MantineColor;
+  verticalSpacing?: MantineSpacing;
+  horizontalSpacing?: MantineSpacing;
+  tabularNums?: boolean;
+  tableMinWidth?: number | string;
+  /**
+   * Row virtualization ([virtualization.md](../docs/virtualization.md)): the body renders a
+   * measured window of rows between two spacer rows.
+   */
+  virtualizedRows?: boolean | {
+    estimateHeight?: number;
+    overscan?: number;
+  };
+  /**
+   * Column virtualization ([virtualization.md](../docs/virtualization.md#column-virtualization)):
+   * the center zone renders a windowed slice of columns between two spacer cols; pinned columns
+   * stay mounted. Widths are the width engine's exact pixels, so there is nothing to estimate.
+   */
+  virtualizedColumns?: boolean | {
+    overscan?: number;
+  };
+  onEndReached?: () => void;
+  endReachedOffset?: number;
+  loadingMore?: boolean;
+  /**
+   * The last `onEndReached` load failed — replaces the trailing loader row with the message
+   * (`true` uses `labels.loadMoreError`) and a retry button that fires `onEndReached` again.
+   */
+  loadMoreError?: boolean | ReactNode;
+  loading?: boolean;
+  emptyState?: ReactNode;
+  /**
+   * Loading the data failed — shows an error panel over the body (`true` uses `labels.error`;
+   * a node replaces the message). Takes precedence over the empty state.
+   */
+  error?: boolean | ReactNode;
+  /**
+   * Renders a retry button in the error panel.
+   */
+  onRetry?: () => void;
+  /**
+   * Renders the column header region. Turning it off takes the header's own affordances with
+   * it — sort controls, filter popovers, resize handles, drag reordering — so name the table
+   * some other way ([accessibility.md](../docs/accessibility.md)).
+   */
+  withColumnHeaders?: boolean;
+  withPaginationBar?: boolean;
+  pageSizeOptions?: number[];
+  /**
+   * A literal primary click on the row. Pointer-only by definition — reach for `onRowActivate`
+   * when the intent is "the user chose this row", so the keyboard reaches it too.
+   */
+  onRowClick?: (row: Row<TData>, event: MouseEvent) => void;
+  /**
+   * The row was activated, whatever the input device: a primary click, or `Enter` on the
+   * current row while `enableActiveRow` is on ([rows.md](../docs/rows.md#active-row)).
+   */
+  onRowActivate?: (row: Row<TData>, event: MouseEvent | KeyboardEvent) => void;
+  onRowDoubleClick?: (row: Row<TData>, event: MouseEvent) => void;
+  onRowContextMenu?: (row: Row<TData>, event: MouseEvent) => void;
+  /**
+   * DOM props for every data row — static, or per row. Synthetic rows (detail panels, loader
+   * and skeleton rows) have no `Row` subject and never receive them.
+   */
+  rowProps?: DataTableElementProps<Omit<TableTrProps, "ref">, Row<TData>>;
+  /**
+   * DOM props for every header row — static, or per header group (grouped columns render one
+   * row per level).
+   */
+  headerRowProps?: DataTableElementProps<Omit<TableTrProps, "ref">, HeaderGroup<TData>>;
+  /**
+   * DOM props for every footer row — static, or per footer group.
+   */
+  footerRowProps?: DataTableElementProps<Omit<TableTrProps, "ref">, HeaderGroup<TData>>;
+  /**
+   * DOM props for the internal scroll viewport — `onScroll`, `data-*`, extra styles. Host
+   * vocabulary: `ScrollArea.viewportProps`. ledger owns its scroll listener, its overscroll
+   * behavior and (with `enableActiveRow`) its keyboard handling; those compose rather than
+   * being replaced.
+   */
+  viewportProps?: Omit<ComponentProps<"div">, "ref"> & DataAttributes;
+  labels?: Partial<DataTableLabels>;
+  /**
+   * Replacements for the chrome's glyphs, merged over the defaults per slot — `lucide-react`
+   * components slot in as-is (docs/styling.md#icons).
+   */
+  icons?: Partial<DataTableIcons>;
+  /**
+   * Imperative handle: `{ table, viewport, scrollToRow, scrollToIndex, scrollToColumn, startEditing, stopEditing }`.
+   */
+  handleRef?: Ref<DataTableHandle<TData>>;
+}
+/**
+ * Data source — a discriminated pair: a hook-mode instance XOR inline behavior options.
+ */
+type DataTableProps<TData extends RowData$1 = RowData$1> = DataTableBaseProps<TData> & (({
+  table: TableInstance<TData>;
+} & {
+  data?: never;
+  columns?: never;
+}) | ({
+  table?: never;
+} & UseDataTableOptions<TData>));
+type DataTableFactory = Factory<{
+  props: DataTableProps;
+  ref: HTMLDivElement;
+  stylesNames: DataTableStylesNames;
+  vars: DataTableCssVariables;
+  signature: <TData extends RowData$1>(props: DataTableProps<TData>) => JSX.Element;
+  staticComponents: {
+    Search: typeof DataTableSearch;
+    ColumnsPanel: typeof DataTableColumnsPanel;
+    Pagination: typeof DataTablePagination;
+    SelectionBar: typeof DataTableSelectionBar;
+  };
+}>;
+declare const DataTable: (<TData extends RowData$1>(props: DataTableProps<TData>) => JSX.Element) & import("@mantine/core").ThemeExtend<{
+  props: DataTableProps;
+  ref: HTMLDivElement;
+  stylesNames: DataTableStylesNames;
+  vars: DataTableCssVariables;
+  signature: <TData extends RowData$1>(props: DataTableProps<TData>) => JSX.Element;
+  staticComponents: {
+    Search: typeof DataTableSearch;
+    ColumnsPanel: typeof DataTableColumnsPanel;
+    Pagination: typeof DataTablePagination;
+    SelectionBar: typeof DataTableSelectionBar;
+  };
+}> & import("@mantine/core").ComponentClasses<{
+  props: DataTableProps;
+  ref: HTMLDivElement;
+  stylesNames: DataTableStylesNames;
+  vars: DataTableCssVariables;
+  signature: <TData extends RowData$1>(props: DataTableProps<TData>) => JSX.Element;
+  staticComponents: {
+    Search: typeof DataTableSearch;
+    ColumnsPanel: typeof DataTableColumnsPanel;
+    Pagination: typeof DataTablePagination;
+    SelectionBar: typeof DataTableSelectionBar;
+  };
+}> & {
+  Search: typeof DataTableSearch;
+  ColumnsPanel: typeof DataTableColumnsPanel;
+  Pagination: typeof DataTablePagination;
+  SelectionBar: typeof DataTableSelectionBar;
+} & {
+  varsResolver: import("@mantine/core").VarsResolver<{
+    props: DataTableProps;
+    ref: HTMLDivElement;
+    stylesNames: DataTableStylesNames;
+    vars: DataTableCssVariables;
+    signature: <TData extends RowData$1>(props: DataTableProps<TData>) => JSX.Element;
+    staticComponents: {
+      Search: typeof DataTableSearch;
+      ColumnsPanel: typeof DataTableColumnsPanel;
+      Pagination: typeof DataTablePagination;
+      SelectionBar: typeof DataTableSelectionBar;
+    };
+  }>;
+} & import("@mantine/core").FactoryComponentWithProps<{
+  props: DataTableProps;
+  ref: HTMLDivElement;
+  stylesNames: DataTableStylesNames;
+  vars: DataTableCssVariables;
+  signature: <TData extends RowData$1>(props: DataTableProps<TData>) => JSX.Element;
+  staticComponents: {
+    Search: typeof DataTableSearch;
+    ColumnsPanel: typeof DataTableColumnsPanel;
+    Pagination: typeof DataTablePagination;
+    SelectionBar: typeof DataTableSelectionBar;
+  };
+}> & {
+  displayName?: string;
+};
+//#endregion
+//#region src/editors.d.ts
+/**
+ * A plain text editor: `meta.edit: textEditor()`.
+ */
+declare function textEditor(): DataTableEditRenderer<any, any>;
+/**
+ * A numeric editor; an emptied input holds `null`, never `0`.
+ */
+declare function numberEditor(): DataTableEditRenderer<any, any>;
+/**
+ * A single-pick editor over the given options. In cell mode the dropdown opens immediately and
+ * picking an option commits at once — one cell is the whole session; in row mode it is one
+ * draft-bound field among the row's others, and the row's own commit decides.
+ */
+declare function selectEditor(options: ComboboxData): DataTableEditRenderer<any, any>;
+/**
+ * A live checkbox for an instant column: `meta.edit: { instant: checkboxEditor() }`. Each
+ * toggle commits the flipped value; the host disables it while its own write is out.
+ */
+declare function checkboxEditor(): DataTableInstantEditRenderer<any, any>;
+//#endregion
+//#region src/use-data-table.d.ts
+declare function useDataTable<TData extends RowData$1>(options: UseDataTableOptions<TData>): TableInstance<TData>;
+//#endregion
+export { type Cell, type Column, type ColumnDef, type ColumnFiltersState, type ColumnOrderState, type ColumnPinningState, type ColumnSizingState, type ColumnVisibilityState, DataTable, type DataTableBaseProps, DataTableColumnsPanel, type DataTableColumnsPanelProps, type DataTableCssVariables, type DataTableEditCommit, type DataTableEditConfig, type DataTableEditContext, type DataTableEditMode, type DataTableEditRenderer, type DataTableEditTrigger, type DataTableEditingCell, type DataTableElementProps, type DataTableExportMeta, type DataTableFactory, type DataTableFilterConfig, type DataTableFilterVariant, type DataTableHandle, type DataTableIconComponent, type DataTableIconProps, type DataTableIcons, type DataTableInstantEditConfig, type DataTableInstantEditContext, type DataTableInstantEditRenderer, type DataTableLabels, DataTablePagination, type DataTablePaginationProps, type DataTablePersistState, type DataTablePersistableSlice, type DataTableProps, type DataTableRowEditCommit, type DataTableRowReorder, type DataTableScrollOptions, DataTableSearch, type DataTableSearchProps, DataTableSelectionBar, type DataTableSelectionBarProps, type DataTableStylesNames, type ExpandedState, type GroupingState, type Header, type HeaderGroup, type LedgerCellEditor, type LedgerEditingController, type LedgerFeatures, type LedgerInstantEditingController, type LedgerMeta, type LedgerRowEditingController, type LedgerRowEditor, type PaginationState, type Row, type RowData, type RowPinningState, type RowSelectionState, type SortingState, type TableInstance, type ToCsvOptions, type UseDataTableOptions, checkboxEditor, createColumnHelper, defaultIcons, defaultLabels, flexRender, numberEditor, selectEditor, textEditor, toCsv, useDataTable };
+//# sourceMappingURL=index.d.cts.map