import { $n as CellEditor, B as FilterRuntime, Gn as QuerySupport, Hn as QueryCondition, L as FilterDef, Mn as RowHeight, Nn as RowStyle, Q as FilterTypeSpec, Qn as CellEditTarget, R as FilterOption, S as TableQueryParams, Un as QueryExtensions, Vn as QueryAggregate, Wn as QueryFilterGroup, Z as FilterTypeRegistry, Zn as CellEditCommit, _ as RowAction, a as ColorScheme, b as SortableValue, bn as ExtraRow, cn as GroupAggregatesFn, ct as ActiveFilterChip, d as Direction, dn as GroupSort, f as ExtraFilters, fn as GroupedFlatEntry, h as PaginationMode, hr as normalizeEditorOptions, ln as GroupNode, lt as ChipLabelResolver, m as PaginatedResponse, mt as FilterFormSource, n as BulkAction, o as ColumnDef, p as FilterValue, qn as SortLevel, r as BulkActionContext, rn as TableSource, rr as EditableColumnLike, u as ColumnHeaderController, un as GroupPaging, v as SortByOption, w as FacetMap, x as TableLabels, y as SortDirection, zn as TableStateMutators } from "./types-Cqk1_BXq.js";
import { A as UseColumnLayoutResult, C as ColumnLayoutState, D as PinSide, F as ColumnGroupRecord, I as ColumnInput, a as ExportViewEntry, f as CellSpanAppearance, m as GetCellSpan, s as ExportWriter, t as ExportPayload } from "./exportWriter-VdWUamzf.js";
import { i as AggregateSpec, r as AggregateOptions } from "./aggregate-C1nNljQr.js";
import { t as UrlStateAdapter } from "./adapter-BD3RX3cl.js";
import { CSSProperties, DragEvent, KeyboardEvent, MouseEvent, PointerEvent, ReactElement, ReactNode, RefCallback, RefObject } from "react";
import { VirtualItem } from "@tanstack/react-virtual";

//#region src/actions/contextMenuModel.d.ts
/** Where the menu was opened. */
type ContextMenuTarget<TRow> = {
  kind: "header";
  columnKey: string;
} | {
  kind: "row";
  row: TRow;
  rowId: string;
} | {
  kind: "cell";
  row: TRow;
  rowId: string;
  columnKey: string;
};
/** One entry in a context menu. */
interface ContextMenuItem {
  /** Stable identity, and the React key. */
  key: string;
  /** The caption, already localized. */
  label: string;
  /** Greyed and unselectable, but still announced — the menu keeps its shape. */
  disabled?: boolean;
  /** Destructive, so a kit can colour it as such. */
  danger?: boolean;
  /** Draw a divider above this entry. */
  separatorBefore?: boolean;
  /** What selecting it does. The menu closes first, then this runs. */
  onSelect: () => void;
}
/** The handlers a built-in entry needs, each optional. */
interface ContextMenuActions<TRow> {
  /** Copy the selection, or this cell when nothing is selected. */
  onCopy?: (target: ContextMenuTarget<TRow>) => void;
  /** Cut — present only when the host wired `onCellCut`. */
  onCut?: (target: ContextMenuTarget<TRow>) => void;
  /** Sort by a column. */
  onSort?: (columnKey: string, direction: "asc" | "desc") => void;
  /** Toggle a column's pin. */
  onTogglePin?: (columnKey: string) => void;
  /** Hide a column. */
  onHide?: (columnKey: string) => void;
  /** Open the filter UI on a column. */
  onFilter?: (columnKey: string) => void;
}
//#endregion
//#region src/actions/commandRegistry.d.ts
/** A command, which is exactly a menu entry. */
type Command = ContextMenuItem;
/**
 * The commands matching a query, in the order they were registered.
 *
 * Registration order is deliberate: it is the order the host chose, which
 * is more meaningful than alphabetical and does not move under the user as
 * they type. An empty query lists everything.
 *
 * @param commands - Every command available right now.
 * @param query - What the user has typed.
 * @returns The matches.
 */
declare function filterCommands(commands: readonly Command[], query: string): Command[];
/** What {@link tableCommands} needs to build the table-wide actions. */
interface TableCommandOptions {
  /** Labels for the built-in commands. */
  labels: {
    print?: string;
    exportCsv?: string;
    clearAll?: string;
  };
  /** Open the print dialog on the current view. */
  onPrint?: () => void;
  /** Run the export the toolbar button runs. */
  onExport?: () => void;
  /** Clear every active filter. */
  onClearFilters?: () => void;
  /** Whether there is anything to clear, so the entry can say so. */
  hasFilters?: boolean;
}
/**
 * The commands that belong to the table rather than to a target.
 *
 * Each appears only when its handler is wired, on the same rule the
 * context menus follow: an action the host has not connected is not
 * offered, because a palette entry that does nothing is worse than one
 * that is missing.
 *
 * @param options - The handlers and their labels.
 * @returns The table-wide commands, in display order.
 */
declare function tableCommands(options: TableCommandOptions): Command[];
//#endregion
//#region src/actions/confirm.d.ts
/** A confirmation request raised by a row or bulk action. */
interface ConfirmRequest {
  /** Dialog title. */
  title: string;
  /** Dialog message. */
  message: string;
  /** Confirm button label. */
  confirmLabel: string;
  /** Cancel button label. */
  cancelLabel: string;
  /** Marks the action destructive. */
  danger?: boolean;
  /** Runs when the user accepts. */
  onConfirm: () => void;
}
/** Shows a confirmation, then runs `onConfirm` if accepted. */
type ConfirmHandler = (request: ConfirmRequest) => void;
/**
 * The default confirmation handler — a dependency-free `window.confirm`.
 * Adapters pass a styled handler when they have one.
 *
 * When no dialog exists at all (SSR, jsdom, some embedded webviews) the
 * action is DENIED: an environment that cannot ask must never approve a
 * destructive action on the user's behalf. Integrators in dialogless
 * environments pass their own `confirm` handler.
 */
declare const defaultConfirm: ConfirmHandler;
/**
 * Normalize a `disabledReason` result. Per the action contract only a
 * *non-empty* string disables, so an empty string maps to `undefined` —
 * letting every adapter treat "disabled" as simply "reason is defined" and
 * fall back to the action label for tooltips. (A plain `|| undefined` would
 * trip `prefer-nullish-coalescing`; this keeps the falsy-empty intent.)
 */
declare function resolveDisabledReason(reason: string | undefined): string | undefined;
/**
 * Run a row action, routing through `confirm` first when the action
 * declares a `confirm` block.
 *
 * @typeParam TRow - The row type.
 * @param action - The action to run.
 * @param row - The row it was triggered on.
 * @param confirm - The confirmation handler.
 * @param cancelLabel - Cancel label for the dialog.
 */
declare function runRowAction<TRow>(action: RowAction<TRow>, row: TRow, confirm: ConfirmHandler, cancelLabel: string): void;
//#endregion
//#region src/actions/useContextMenu.d.ts
/** Where on screen the menu should appear. */
interface ContextMenuPoint {
  x: number;
  y: number;
}
//#endregion
//#region src/actions/useBulkActionRunner.d.ts
/** A bulk-action rejection as display text, or `null` when there is none. */
declare function bulkActionErrorMessage(error: unknown): string | null;
/** How a bulk-action run ended — passed to `onComplete` on every run. */
type BulkActionOutcome = {
  status: "success";
} | {
  status: "error";
  error: unknown;
};
/** Options for {@link useBulkActionRunner}. */
interface UseBulkActionRunnerOptions {
  /** Confirmation handler for actions that declare a `confirm` block. */
  confirm: ConfirmHandler;
  /** Cancel label for confirm dialogs. */
  cancelLabel: string;
  /**
   * Called after EVERY run with its outcome — success or failure — so a
   * host can clear the selection on success and report failures. (Earlier
   * versions only called this on success, with no argument.)
   */
  onComplete?: (outcome: BulkActionOutcome) => void;
}
/** The runner returned by {@link useBulkActionRunner}. */
interface BulkActionRunner {
  /** Key of the action currently running, or `null`. */
  pending: string | null;
  /**
   * The value the last run rejected with, or `null`. Cleared when the
   * next run starts.
   */
  error: unknown;
  /**
   * Run a bulk action against the given ids (confirming first if needed).
   * Omit `context` for the plain page-selection scope.
   */
  run: (action: BulkAction, ids: string[], context?: BulkActionContext) => void;
}
/**
 * Headless runner for bulk actions: tracks the in-flight action key,
 * routes through the confirmation handler, catches rejections (exposed as
 * `error`, never an unhandled rejection), and calls `onComplete` with the
 * outcome of every run. Adapters render the buttons and call `run`.
 *
 * @param options - See {@link UseBulkActionRunnerOptions}.
 * @returns The {@link BulkActionRunner}.
 */
declare function useBulkActionRunner({
  confirm,
  cancelLabel,
  onComplete
}: UseBulkActionRunnerOptions): BulkActionRunner;
//#endregion
//#region src/selection/useSelection.d.ts
/** Tri-state of the "select all visible" header control. */
type HeaderSelectionState = "all" | "some" | "none";
/** Options for {@link useSelection}. */
interface UseSelectionOptions<TRow> {
  /** The currently visible rows. */
  rows: readonly TRow[];
  /** Stable id extractor for a row. */
  getId: (row: TRow) => string;
  /**
   * When this value changes, the selection is cleared (the previously
   * selected ids may no longer be visible). Compose it from search /
   * page / active-filter count — e.g. `` `${search}|${page}` ``.
   */
  resetKey?: unknown;
  /**
   * Controlled selection. When provided, the hook reads from this value
   * and reports every change request through `onSelectionChange` instead
   * of mutating its own state — the same controlled/uncontrolled split as
   * `useColumnLayout`.
   */
  selectedIds?: readonly string[];
  /** Change handler; required for the controlled mode to update. */
  onSelectionChange?: (selectedIds: string[]) => void;
}
/** Selection state + actions returned by {@link useSelection}. */
interface SelectionState {
  /** The set of selected ids. */
  selectedIds: ReadonlySet<string>;
  /** Number of selected ids. */
  selectedCount: number;
  /** Tri-state for the visible rows (`all` / `some` / `none`). */
  headerState: HeaderSelectionState;
  /** Whether a specific id is selected. */
  isSelected: (id: string) => boolean;
  /** Toggle a single id. */
  toggle: (id: string) => void;
  /**
   * Toggle all leaf ids in a group (select missing, or deselect when all
   * selected) — one commit so memoized rows see a single selection change.
   */
  toggleGroupLeaves: (leafIds: readonly string[]) => void;
  /** Toggle every visible id (select all, or clear all if already full). */
  toggleAll: () => void;
  /** Clear the entire selection. */
  clear: () => void;
  /** The visible ids, in row order. */
  visibleIds: string[];
  /** True when the user chose "select all matching" across every page. */
  allMatching: boolean;
  /** Extend the selection to every matching row (across all pages). */
  selectAllMatching: () => void;
}
/**
 * Headless multi-row selection. Tracks a set of ids, derives the header
 * tri-state from the visible rows, and clears itself when `resetKey`
 * changes so stale ids never linger after a filter/page change.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseSelectionOptions}.
 * @returns Selection state and actions.
 */
declare function useSelection<TRow>(options: UseSelectionOptions<TRow>): SelectionState;
//#endregion
//#region src/actions/useShortcuts.d.ts
/** One shortcut: the chord, and what it runs. */
interface Shortcut {
  /**
   * The chord, as `"mod+k"`. `mod` is Cmd on a Mac and Ctrl elsewhere,
   * which is the only way to write one shortcut that is right on both.
   * Also accepts `ctrl`, `meta`, `alt` and `shift`.
   */
  chord: string;
  /** The key of the command it runs. */
  command: string;
}
/** The shortcuts a table has unless the host says otherwise. */
declare const DEFAULT_SHORTCUTS: readonly Shortcut[];
/** What {@link useShortcuts} needs. */
interface UseShortcutsOptions {
  /** Off unless the host armed it; nothing is bound when false. */
  enabled: boolean;
  /** The shortcuts. Defaults to {@link DEFAULT_SHORTCUTS}. */
  shortcuts?: readonly Shortcut[];
  /** Run a command by key. Returning nothing is fine. */
  onCommand: (command: string) => void;
  /**
   * Where to listen. Defaults to the document, which is what a
   * table-scoped palette wants: the shortcut has to work when focus is on
   * the table, in its toolbar, or nowhere in particular.
   */
  target?: () => EventTarget | null;
}
/**
 * Bind a table's shortcuts.
 *
 * @param options - The shortcuts and what to do when one fires.
 */
declare function useShortcuts(options: UseShortcutsOptions): void;
//#endregion
//#region src/actions/useCommandPalette.d.ts
/** How a host arms the palette. */
interface CommandPaletteOptions {
  /**
   * Extra commands, appended after the built-in ones. They are the same
   * objects the context menus take, so an action can be written once and
   * offered in both.
   */
  commands?: readonly Command[];
  /**
   * The shortcuts. Defaults to Cmd/Ctrl+K opening the palette; pass your
   * own to remap, or `[]` to bind nothing.
   */
  shortcuts?: readonly Shortcut[];
}
/** What {@link useCommandPalette} needs. */
interface UseCommandPaletteOptions extends TableCommandOptions {
  /** The prop as the host wrote it: `true`, an options object, or absent. */
  commandPalette?: boolean | CommandPaletteOptions;
  labels: TableLabels;
}
/** What an adapter binds and renders. */
interface TableCommandPalette {
  /** Whether it is showing. */
  open: boolean;
  /** Close it. */
  close: () => void;
  /** Open it — for a toolbar button or a host control. */
  show: () => void;
  /** Everything it lists. */
  commands: readonly Command[];
}
/**
 * Arm a table's command palette.
 *
 * @param options - The prop, the labels, and the handlers behind the
 *   built-in commands.
 * @returns The open state and the commands.
 */
declare function useCommandPalette(options: UseCommandPaletteOptions): TableCommandPalette;
//#endregion
//#region src/actions/useTableContextMenu.d.ts
/** How a host arms the context menu. */
interface ContextMenuOptions<TRow> {
  /**
   * Extra entries, appended behind a divider so a custom action is never
   * mistaken for a built-in one.
   */
  items?: (target: ContextMenuTarget<TRow>) => readonly ContextMenuItem[];
}
/** What {@link useTableContextMenu} needs. */
interface TableContextMenuOptions<TRow> {
  /** The prop as the host wrote it: `true`, an options object, or absent. */
  contextMenu?: boolean | ContextMenuOptions<TRow>;
  columns: readonly ColumnDef<TRow>[];
  labels: TableLabels;
  /** The row behind an id, since the DOM only carries the id. */
  rowFor: (rowId: string) => TRow | undefined;
  /** The handlers the built-in entries call. */
  actions: ContextMenuActions<TRow>;
  sortBy?: string;
  sortDir?: "asc" | "desc";
  isPinned?: (columnKey: string) => boolean;
}
/** What an adapter binds and renders. */
interface TableContextMenu {
  /** Spread onto the element containing the headers, rows and cells. */
  regionProps: Record<string, unknown>;
  /** The entries for whatever is open; empty when nothing is. */
  items: readonly ContextMenuItem[];
  /** Where it was opened, or `null` when it is closed. */
  at: ContextMenuPoint | null;
  /** Close it, putting focus back where it came from. */
  close: () => void;
}
/**
 * Arm a table's context menu.
 *
 * @param options - The prop, the columns, and the handlers behind the
 *   built-in entries.
 * @returns The props to bind and the state to render.
 */
declare function useTableContextMenu<TRow>(options: TableContextMenuOptions<TRow>): TableContextMenu;
//#endregion
//#region src/columns/columnMenuModel.d.ts
/** Readable label for a column in the menu (header string → mobileLabel → key). */
declare function columnMenuLabel<TRow>(column: ColumnDef<TRow>): string;
/** Edge a column is pinned to, or `undefined` when unpinned. */
type PinnedSide = PinSide | undefined;
/** One row of the column-management menu, with its derived display state. */
interface ColumnMenuRow<TRow> {
  column: ColumnDef<TRow>;
  key: string;
  name: string;
  /** Hidden columns keep their position; only the eye toggles. */
  hidden: boolean;
  /** Edge the column is pinned to, or `undefined` when unpinned. */
  pinned: PinnedSide;
  /** Index in the full column order (visible + hidden) — the reorder target. */
  index: number;
  /** False when `column.lockPosition` is set. */
  canMove: boolean;
  /** False when `column.lockVisibility` is set. */
  canHide: boolean;
  /** False when `column.lockPin` is set. */
  canPin: boolean;
  /** False when `column.lockWidth` is set. */
  canResize: boolean;
  /** True when the column declared `sortable`. */
  canSort: boolean;
  /** True when the column declared a `filter`. */
  canFilter: boolean;
}
/**
 * Toggle a DATA column's start pin: none ↔ start (`"start"` = the logical
 * inline-start edge, which is the right edge under `dir="rtl"`). Data columns
 * never pin to the END edge — that is reserved for the trailing actions column,
 * which has its own end-pin toggle. Pinning a leading data column to the
 * trailing edge has no value: it just sticky-travels across the row and
 * collides with the actions column.
 */
declare function nextPinSide(current: PinnedSide): PinnedSide;
/**
 * The label for a data column's pin toggle — "Pin to start" when unpinned,
 * "Unpin" when pinned — so the accessible name always matches what the click
 * will do. (The actions column uses its own "Pin to end" / "Unpin" label.)
 */
declare function pinActionLabel(current: PinnedSide, labels: {
  pinStart: string;
  unpin: string;
}): string;
/**
 * Build the column-menu rows in the table's real order — visible and hidden
 * columns interleaved exactly as they appear (hiding never reorders the list).
 * Shared so all five adapters render an identical model and only differ in kit
 * markup.
 */
/**
 * Reserved layout key for the injected row-actions column. It is not a
 * `ColumnDef`, but the layout state treats keys opaquely, so the actions
 * column hides (`hidden: ["actions"]`) and end-pins
 * (`pinned: { actions: "end" }`) like any data column — adapters list it
 * in the Columns menu with a visibility toggle and an end-pin toggle (no
 * reorder/resize; it always trails).
 */
declare const ACTIONS_COLUMN_KEY = "actions";
/**
 * Reserved layout key for the injected row-reorder column. Same deal as
 * {@link ACTIONS_COLUMN_KEY}: not a `ColumnDef`, but hideable and
 * start-pinnable through the layout because the key is just a string.
 */
declare const REORDER_COLUMN_KEY = "reorder";
declare function columnMenuRows<TRow>(allColumns: readonly ColumnDef<TRow>[], layout: UseColumnLayoutResult<TRow>): ColumnMenuRow<TRow>[];
/** Keep rows whose name or key contains the query (case-insensitive). */
declare function filterColumnMenuRows<TRow>(rows: readonly ColumnMenuRow<TRow>[], query: string): ColumnMenuRow<TRow>[];
/** Show every unlocked hidden column. */
declare function showAllColumns<TRow>(rows: readonly ColumnMenuRow<TRow>[], layout: UseColumnLayoutResult<TRow>): void;
/** Hide every unlocked visible column. */
declare function hideAllColumns<TRow>(rows: readonly ColumnMenuRow<TRow>[], layout: UseColumnLayoutResult<TRow>): void;
/** Unpin every unlocked pinned column. */
declare function unpinAllColumns<TRow>(rows: readonly ColumnMenuRow<TRow>[], layout: UseColumnLayoutResult<TRow>): void;
/** Restore one column's visibility, pin and width. Locks still apply. */
declare function resetColumnLayout<TRow>(row: ColumnMenuRow<TRow>, layout: UseColumnLayoutResult<TRow>): void;
/** One action in a per-column submenu. */
interface ColumnMenuAction {
  id: string;
  label: string;
  disabled: boolean;
  run: () => void;
}
/** What a submenu needs besides the row itself. */
interface ColumnMenuActionContext<TRow = unknown> {
  labels: ColumnMenuLabels;
  layout: UseColumnLayoutResult<TRow>;
  sortBy?: string;
  sortDir?: "asc" | "desc";
  onSortColumn?: (key: string, dir: "asc" | "desc") => void;
  onAutoSizeColumn?: (key: string) => void;
  onFilterColumn?: (key: string) => void;
}
/** Sort, pin, hide, autosize, filter, reset — disabled when locked. */
declare function columnMenuActions<TRow>(row: ColumnMenuRow<TRow>, ctx: ColumnMenuActionContext<TRow>): ColumnMenuAction[];
/**
 * Labels every adapter's column menu needs (pre-translated by the caller).
 * Hoisted here so the five adapters share one contract instead of
 * re-declaring it.
 */
interface ColumnMenuLabels {
  columns: string;
  pinStart: string;
  pinEnd: string;
  unpin: string;
  moveStart: string;
  moveEnd: string;
  resetColumns: string;
  /** "Size columns to content" — the menu's auto-size action. */
  autoSizeColumns: string;
  showColumn: string;
  hideColumn: string;
  searchColumns: string;
  showAllColumns: string;
  hideAllColumns: string;
  unpinAllColumns: string;
  resetColumn: string;
  sortAscending: string;
  sortDescending: string;
  filterColumn: string;
  columnActions: string;
  autoSizeColumn: string;
}
/** The shared prop surface of every adapter's `<ColumnMenu>`. */
interface ColumnMenuChromeProps<TRow> {
  /** All declared columns (pre layout filtering). */
  allColumns: ColumnDef<TRow>[];
  /** The user column-layout state + mutators. */
  layout: UseColumnLayoutResult<TRow>;
  /** Resolved labels. */
  labels: ColumnMenuLabels;
}
//#endregion
//#region src/columns/columnReorder.d.ts
/** MIME type carrying the dragged column key during a reorder drag. */
declare const COLUMN_DND_MIME = "application/x-adapttable-column";
/** Props that make a whole menu ROW draggable (so the browser's drag image is
 * the full row — you see the column move). Pair with {@link columnDropProps}. */
interface ColumnRowDragProps {
  draggable: true;
  onDragStart: (event: DragEvent<HTMLElement>) => void;
}
/**
 * Build drag props for a column-menu row. The entire row is the drag handle,
 * matching the native drag-image so the reorder feels physical.
 *
 * @param key - Column key being reordered.
 */
declare function columnRowDragProps(key: string): ColumnRowDragProps;
/** Props for a small, focusable reorder grip — keyboard a11y for the row drag. */
interface ColumnReorderKeyProps {
  role: "button";
  tabIndex: 0;
  "aria-label": string;
  "data-adapttable-grip": "";
  onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
}
/**
 * Build keyboard props for the reorder grip. Arrow keys move the column one
 * slot — the accessible equivalent of the pointer drag. Up/Down always mean
 * earlier/later in the order; Left/Right follow the writing direction, so in
 * RTL pressing ArrowRight moves the column toward the start (visually right).
 *
 * @param key - Column key being reordered.
 * @param index - The column's current index in the full order.
 * @param move - Layout mutator that moves a column to a new index.
 * @param label - Accessible label for the grip.
 */
declare function columnReorderKeyProps(key: string, index: number, move: (key: string, toIndex: number) => void, label: string): ColumnReorderKeyProps;
/** Props for a row that accepts a dropped column, moving it to this index. */
interface ColumnDropProps {
  onDragOver: (event: DragEvent<HTMLElement>) => void;
  onDrop: (event: DragEvent<HTMLElement>) => void;
}
/**
 * Build drop props for a reorder target: moves the dragged column to this
 * row's `index` on drop.
 *
 * @param index - Target index the dragged column moves to.
 * @param move - Layout mutator that moves a column to a new index.
 */
declare function columnDropProps(index: number, move: (key: string, toIndex: number) => void): ColumnDropProps;
/** Indicator attributes for a column-menu row during a reorder drag. */
interface ColumnDragRowAttrs {
  /** Present on the row being dragged (kits dim it). */
  "data-dragging"?: "";
  /** Present on the hovered drop target, with the insertion edge. */
  "data-drop"?: "before" | "after";
}
/** Live drag state + composed prop builders from {@link useColumnDragState}. */
interface ColumnDragState {
  /** Key currently being dragged, or `null` outside a drag. */
  draggingKey: string | null;
  /** Hovered drop index, or `null`. */
  overIndex: number | null;
  /** Drag props for a row — {@link columnRowDragProps} + state tracking. */
  rowDragProps: (key: string, index: number) => ColumnRowDragProps & {
    onDragEnd: () => void;
  };
  /** Drop props for a row — {@link columnDropProps} + hover tracking. */
  dropProps: (index: number, move: (key: string, toIndex: number) => void) => ColumnDropProps;
  /** Indicator data-attributes for a row; style them with kit CSS. */
  rowAttrs: (key: string, index: number) => ColumnDragRowAttrs;
}
/**
 * Drop-position feedback for the column-menu reorder. Composes the existing
 * drag/drop prop builders with the tracking they lack, so adapters can show
 * WHERE the dragged column will land instead of leaving the user to guess:
 * the dragged row carries `data-dragging` (dim it) and the hovered target
 * carries `data-drop="before" | "after"` (draw an insertion line on that
 * edge). State clears on drop, drag end, and drag cancel alike.
 */
declare function useColumnDragState(): ColumnDragState;
//#endregion
//#region src/columns/columnResize.d.ts
/**
 * Props for a column-resize handle element. Modeled as a `button` (a focusable
 * `separator`/splitter would require `aria-valuenow/min/max`); ArrowLeft/Right
 * resize it for keyboard users.
 */
interface ColumnResizeHandleProps {
  role: "button";
  tabIndex: 0;
  "aria-label": string;
  onPointerDown: (event: PointerEvent<HTMLElement>) => void;
  onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
  /** Double-click sizes the column to its content, as every grid does. */
  onDoubleClick: (event: MouseEvent<HTMLElement>) => void;
}
/**
 * Build the props for a column-resize handle. Pointer drag resizes live; arrow
 * keys nudge by {@link COLUMN_RESIZE_STEP} for keyboard a11y. Width is measured
 * from the live cell, so columns need no preset width to be resizable.
 *
 * @param key - Column key being resized.
 * @param setWidth - Layout mutator that persists the new width.
 * @param label - Accessible label for the handle.
 */
declare function columnResizeHandleProps(key: string, setWidth: (key: string, width: number) => void, label: string): ColumnResizeHandleProps;
//#endregion
//#region src/columns/columnWidths.d.ts
/** A column identity for width resolution — just its key and declared width. */
type WidthColumn = Pick<ColumnDef<unknown>, "key" | "width">;
/** Fallback width (px) for a pinned column with no resolvable declared width. */
/**
 * Parse a declared column width to pixels, or `undefined` when it carries no
 * pixel value (relative units like `%`, `rem`, `fr` have no px here, so
 * `parseInt("50%")` → 50 would silently corrupt a sticky inset / min-width).
 */
declare function parsePxWidth(width: number | string | undefined): number | undefined;
/**
 * A column's effective pixel width: a resize override (from the layout
 * `widths` map) wins over the declared width. `undefined` when neither
 * resolves to pixels.
 */
declare function resolveColumnWidth(column: WidthColumn, widths?: Readonly<Record<string, number>>): number | undefined;
/**
 * Total pixel width of the fixed-width columns, plus any extra leading/trailing
 * fixed columns (selection checkbox, actions). Columns without a px width
 * contribute nothing, so a table with no declared widths returns `0` and is
 * never forced to a min-width. Adapters apply the result as the table's
 * `min-width` so a fixed-width table scrolls horizontally instead of squishing
 * its columns below their declared sizes.
 *
 * @typeParam TRow - The row type.
 * @param columns - The visible columns.
 * @param options - `widths` resize overrides; `extra` px for non-data columns.
 * @returns The min table width in px, or `0` when no column declares a width.
 */
declare function tableMinWidth<TRow>(columns: readonly ColumnDef<TRow>[], options?: {
  widths?: Readonly<Record<string, number>>;
  extra?: number;
}): number;
/**
 * The pixel width to RENDER a pinned column at: its resolved width, else
 * {@link FALLBACK_PIN_WIDTH}. Pin insets are summed from these same numbers
 * (see `pinOffset`), so applying this width to pinned header cells keeps
 * stacked pins flush — a natural-width pinned column would otherwise render
 * narrower or wider than the inset math assumed.
 *
 * @param column - The pinned column.
 * @param widths - Resize overrides from the column layout.
 */
declare function pinnedColumnWidth(column: WidthColumn, widths?: Readonly<Record<string, number>>): number;
//#endregion
//#region src/constants.d.ts
/** Default rows-per-page. */
declare const DEFAULT_LIMIT = 25;
/** Page-size options offered by adapter pagination controls. */
declare const PAGE_SIZE_OPTIONS: readonly [10, 25, 50, 100];
/**
 * Page-size options to render in a rows-per-page selector, guaranteeing every
 * given size is present. Pass the active `limit` alone, or `[limit,
 * defaultLimit]` so a host default (scale's 500, a shared-URL 15) stays
 * listed after the user picks 10 / 25 / 50 / 100 — otherwise it vanishes
 * and cannot be selected again.
 *
 * Off-list values are prepended in the order given, de-duplicated.
 *
 * @param limit - The currently-active page size, or several sizes that must
 *   stay listed (active + the table's default page size).
 * @param sizes - The standard options to offer (defaults to {@link PAGE_SIZE_OPTIONS}).
 * @returns The options to render, with every given size guaranteed present.
 */
declare function pageSizeOptions(limit: number | readonly number[], sizes?: readonly number[]): readonly number[];
/** Default debounce (ms) for the search input before it commits to state. */
declare const SEARCH_DEBOUNCE_MS = 300;
/** Default card-height estimate (px) for virtualized mobile layouts. */
declare const DEFAULT_CARD_SIZE_PX = 132;
//#endregion
//#region src/editing/editingEvents.d.ts
/** Which commit unit produced an event. */
type EditUnit = "cell" | "row" | "batch";
/**
 * One lifecycle event. `columnKey` is the edited field for a cell, and empty
 * for a row or batch whose payload is the whole patch (or list of patches).
 */
interface EditEvent<TRow> {
  /** The row as it was when the gesture started. */
  row: TRow;
  /** Its stable id. */
  rowId: string;
  /** The column, or `""` when the unit is the whole row or a batch. */
  columnKey: string;
  /** What the reader arrived at — the parsed value, the patch, or the edits. */
  value: unknown;
  /** What was there before. */
  previousValue: unknown;
  /** Which commit unit fired this. */
  unit: EditUnit;
  /** Why a commit was refused, or why a save rejected. */
  error?: string;
}
/** A host callback that observes one kind of event. */
type EditEventHandler<TRow> = (event: EditEvent<TRow>) => void;
/** The five observers a host may wire. All optional, all inert when omitted. */
interface EditLifecycle<TRow> {
  /** An editor opened. */
  onEditStart?: EditEventHandler<TRow>;
  /** The reader threw the draft away. */
  onEditCancel?: EditEventHandler<TRow>;
  /** The host received the value. */
  onEditCommit?: EditEventHandler<TRow>;
  /** A validator refused the value; the editor stayed open. */
  onValidationFail?: EditEventHandler<TRow>;
  /** A save promise rejected. */
  onEditError?: EditEventHandler<TRow>;
}
//#endregion
//#region src/editing/batchEditing.d.ts
/** One row's pending changes. */
interface BatchRowEdit<TRow> {
  /** The row as it was when the reader started changing it. */
  row: TRow;
  /** Its stable id. */
  rowId: string;
  /** Parsed values by column key — only the fields that actually changed. */
  patch: Readonly<Record<string, unknown>>;
}
/** Headless batch-editing state. */
interface BatchEditingState<TRow> {
  /** How many rows are waiting — what a "3 unsaved rows" line reads. */
  count: number;
  /** Whether anything is waiting at all. */
  pending: boolean;
  /** Whether this row has pending changes. */
  isPending: (rowId: string) => boolean;
  /** This cell's draft, or the row's stored value when it has none. */
  draftFor: (row: TRow, rowId: string, columnKey: string) => string;
  /** Whether this cell has been changed. */
  isChanged: (rowId: string, columnKey: string) => boolean;
  /** Change one cell, without telling the host. */
  setDraft: (row: TRow, rowId: string, columnKey: string, value: string) => void;
  /** Hand the host every pending row, as one list, then forget them. */
  saveAll: () => void;
  /** Forget everything, restoring nothing — the drafts were never applied. */
  cancelAll: () => void;
  /** Forget one row's changes. */
  cancelRow: (rowId: string) => void;
  /** A digest of the pending drafts, for a row memo comparator. */
  signature: string;
}
/** What {@link useBatchEditing} needs. */
interface UseBatchEditingOptions<TRow> {
  /**
   * Whether batch editing is armed. Off by default: it changes when a commit
   * happens, which is a decision about the data rather than a preference.
   */
  enabled?: boolean;
  /** The columns, for seeding drafts and parsing them back. */
  columns: readonly EditableColumnLike<TRow>[];
  /**
   * Take every pending row at once. The table never writes to a row, and the
   * whole point of the mode is that this is called once.
   */
  onBatchEdit?: (edits: readonly BatchRowEdit<TRow>[]) => unknown;
  /** A row became pending. */
  onEditStart?: EditEventHandler<TRow>;
  /** Pending changes were thrown away. */
  onEditCancel?: EditEventHandler<TRow>;
  /** The host received the batch. */
  onEditCommit?: EditEventHandler<TRow>;
}
/**
 * Headless state for changing many rows and saving them together.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseBatchEditingOptions}.
 * @returns The state; inert unless `enabled`.
 */
declare function useBatchEditing<TRow>(options: UseBatchEditingOptions<TRow>): BatchEditingState<TRow>;
//#endregion
//#region src/editing/dirtyCells.d.ts
/** Dirty state for the whole table. */
interface DirtyCellState {
  /** Whether this cell holds a change nobody has confirmed. */
  isDirty: (rowId: string, columnKey: string) => boolean;
  /** Whether any cell in this row does — what a row marker reads. */
  isRowDirty: (rowId: string) => boolean;
  /** How many cells are waiting, for a "3 unsaved changes" line. */
  count: number;
  /** Mark a cell changed. */
  mark: (rowId: string, columnKey: string) => void;
  /** Clear one cell — a save confirmed, or a change undone. */
  confirm: (rowId: string, columnKey: string) => void;
  /** Clear every cell in one row. */
  confirmRow: (rowId: string) => void;
  /** Clear everything — what a successful refetch means. */
  confirmAll: () => void;
  /** A digest of the marks, for a row memo comparator. */
  signature: string;
}
/** What {@link useDirtyCells} needs. */
interface UseDirtyCellsOptions {
  /**
   * Whether to mark at all. Off by default: a mark is a claim about what the
   * server has agreed to, and a table whose host never says would be guessing.
   */
  enabled?: boolean;
}
/**
 * Headless dirty-cell state for inline editing.
 *
 * @param options - See {@link UseDirtyCellsOptions}.
 * @returns The state; inert unless `enabled`.
 */
declare function useDirtyCells(options?: UseDirtyCellsOptions): DirtyCellState;
//#endregion
//#region src/editing/editConflict.d.ts
/** How an unhandled conflict is resolved. */
type EditConflictPolicy = "keep" | "take" | "ask";
/** The host's choice, when it makes one. */
type EditConflictChoice = "keep" | "take";
/**
 * One conflict. `row` is what just arrived; `previous` is the snapshot the
 * editor opened against (or last accepted).
 */
interface EditConflict<TRow> {
  /** The incoming row. */
  row: TRow;
  /** The row as it was when the editor opened (or last accepted). */
  previous: TRow;
  /** Its stable id. */
  rowId: string;
  /** The column being edited. */
  columnKey: string;
  /** What the reader has typed. */
  draft: string;
  /** The incoming cell value. */
  incomingValue: string;
  /** The cell value the editor opened against. */
  previousValue: string;
}
/** What a host returns from {@link EditConflictHandler}. `void` defers to policy. */
type EditConflictHandler<TRow> = (conflict: EditConflict<TRow>) => EditConflictChoice | void;
/** Headless conflict state for the active editor. */
interface EditConflictState<TRow> {
  /** The conflict being asked about, or `null`. */
  current: EditConflict<TRow> | null;
  /** Whether this cell is the one in conflict. */
  isConflict: (rowId: string, columnKey: string) => boolean;
  /** Keep the draft; accept the incoming row as the new snapshot. */
  keep: () => void;
  /** Replace the draft with the incoming value. */
  take: () => void;
  /**
   * Compare the open editor to the live rows. Call from the same effect that
   * discards a missing row — a conflict is that check one step milder.
   */
  reconcile: (input: ReconcileLiveEdit<TRow>) => void;
  /** Drop a conflict without choosing — the editor closed. */
  clear: () => void;
}
/** What {@link EditConflictState.reconcile} needs to judge one live update. */
interface ReconcileLiveEdit<TRow> {
  /** The active cell, or `null` when idle. */
  active: {
    rowId: string;
    columnKey: string;
  } | null;
  /** The row the editor opened against. */
  openedRow: TRow | undefined;
  /** The live draft. */
  draft: string;
  /** The rendered row set. */
  rows: readonly TRow[];
  /** Columns, to read the edited field. */
  columns: readonly EditableColumnLike<TRow>[];
  rowKey: (row: TRow) => string;
  /** Host version accessor — any change is a conflict, not just this cell. */
  rowVersion?: (row: TRow) => string | number;
  policy: EditConflictPolicy;
  onEditConflict?: EditConflictHandler<TRow>;
  /** Keep: new snapshot, same draft. */
  keep: (row: TRow) => void;
  /** Take: new snapshot and the incoming value as the draft. */
  take: (row: TRow, incomingValue: string) => void;
}
/**
 * Whether the live row disagrees with the snapshot the editor opened against.
 *
 * With `rowVersion`, any version change is a conflict — the host said the row
 * moved. Without it, only the edited column's stored value counts, so an
 * unrelated field updating does not steal the draft.
 */
declare function liveRowChanged<TRow>(input: {
  opened: TRow;
  current: TRow;
  column: EditableColumnLike<TRow>;
  rowVersion?: (row: TRow) => string | number;
}): boolean;
/**
 * Headless conflict state. Inert until {@link EditConflictState.reconcile}
 * sees a live row that disagrees with the open editor.
 */
declare function useEditConflict<TRow>(): EditConflictState<TRow>;
//#endregion
//#region src/editing/rowEditing.d.ts
/** The drafts a row edit holds, by column key. */
type RowEditDrafts = Readonly<Record<string, string>>;
/** Headless row-editing state. */
interface RowEditingState<TRow> {
  /** The row being edited, or `null` when none is. */
  activeRowId: string | null;
  /** Whether this row is the one being edited. */
  isEditing: (rowId: string) => boolean;
  /** Every draft in the open row, by column key. */
  drafts: RowEditDrafts;
  /** One column's draft in the open row. */
  draftFor: (columnKey: string) => string;
  /** Open a row, seeding every editable column from its current value. */
  begin: (row: TRow, rowId: string) => void;
  /** Replace one column's draft. */
  setDraft: (columnKey: string, value: string) => void;
  /**
   * Hand the host everything the reader changed, as one patch, then close.
   * A no-op when nothing is open, and it reports nothing when nothing changed —
   * saving an untouched row is a write the host never asked for.
   */
  save: () => void;
  /** Throw every draft away and close. */
  cancel: () => void;
  /** Whether any draft differs from the row's stored value. */
  isDirty: boolean;
  /** A digest of the open row's drafts, for a row memo comparator. */
  signature: string;
}
/** What {@link useRowEditing} needs. */
interface UseRowEditingOptions<TRow> {
  /**
   * Whether row editing is armed. Off by default: it changes the commit unit,
   * which is a decision about the data, not a preference.
   */
  enabled?: boolean;
  /** The columns, for seeding drafts and parsing them back. */
  columns: readonly EditableColumnLike<TRow>[];
  /**
   * Take everything the reader changed, as one patch of parsed values keyed by
   * column. The table never writes to a row.
   */
  onRowEdit?: (row: TRow, patch: Readonly<Record<string, unknown>>) => unknown;
  /** An editor opened on this row. */
  onEditStart?: EditEventHandler<TRow>;
  /** The reader threw the drafts away. */
  onEditCancel?: EditEventHandler<TRow>;
  /** The host received the patch. */
  onEditCommit?: EditEventHandler<TRow>;
}
/**
 * Headless state for editing a row as one unit.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseRowEditingOptions}.
 * @returns The state; inert unless `enabled`.
 */
declare function useRowEditing<TRow>(options: UseRowEditingOptions<TRow>): RowEditingState<TRow>;
//#endregion
//#region src/editing/saveState.d.ts
/** What a cell's last save is doing. */
type CellSaveStatus = "saving" | "failed";
/** One cell's failed save, with what it takes to retry or undo it. */
interface FailedCellSave<TRow> {
  /** The row as it was before the edit — what a rollback restores. */
  previous: TRow;
  /** The value the reader tried to save. */
  attempted: unknown;
  /** Why it failed, in a sentence a reader can read. */
  message: string;
}
/** What {@link useCellSaveState} needs. */
interface UseCellSaveStateOptions<TRow> {
  /**
   * Put the previous row back after a rejected save. Without it the table marks
   * the cell failed and leaves the value where it is — correct for a table that
   * refetches, wrong for one that applied the edit optimistically.
   */
  onRollback?: (previous: TRow, columnKey: string) => void;
  /** Turn a rejection into the sentence the cell shows. */
  formatError?: (error: unknown) => string;
  /** Observe a rejected save — never owns the outcome. */
  onEditError?: EditEventHandler<TRow>;
}
/** Per-cell save state for the whole table. */
interface CellSaveState<TRow> {
  /** What this cell's last save is doing, if anything. */
  statusFor: (rowId: string, columnKey: string) => CellSaveStatus | undefined;
  /** Why this cell's last save failed, if it did. */
  failureFor: (rowId: string, columnKey: string) => FailedCellSave<TRow> | undefined;
  /**
   * Watch one commit, and report how it went: `true` when the value reached
   * wherever it was going, `false` when it did not.
   *
   * The outcome comes back from here rather than being read off the state
   * afterwards, because a caller holding a render-old closure would read the
   * state as it was BEFORE the failure and conclude the save succeeded.
   */
  track: (options: {
    rowId: string;
    columnKey: string; /** The row before the edit — what a rollback restores. */
    previous: TRow; /** The value being saved. */
    attempted: unknown;
    /**
     * The cell's previous value, when the caller has it. The error event
     * reports this as `previousValue`; without it the event uses the row.
     */
    previousValue?: unknown; /** Whatever `onCellEdit` returned. */
    result: unknown;
  }) => Promise<boolean>;
  /** Put a failed cell's previous row back, and forget the failure. */
  rollback: (rowId: string, columnKey: string) => void;
  /** Forget a cell's failure without restoring anything — what a retry does. */
  clear: (rowId: string, columnKey: string) => void;
  /** A digest of the states, for a row memo comparator. */
  signature: string;
  /**
   * Whether the table was told how to put a row back. An undo control offered
   * without one would do nothing when pressed.
   */
  canRollback: boolean;
}
/**
 * Headless save state for inline editing.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseCellSaveStateOptions}.
 * @returns The state; inert until a commit returns a promise that rejects.
 */
declare function useCellSaveState<TRow>(options?: UseCellSaveStateOptions<TRow>): CellSaveState<TRow>;
//#endregion
//#region src/editing/useCellEditing.d.ts
/** Keyboard outcome from {@link CellEditingState.handleKeyDown}. */
type CellEditKeyAction = "commit" | "cancel" | "commit-advance";
/** Row/column context for Tab / Shift+Tab advance. */
interface CellEditNavigation {
  rows: readonly unknown[];
  columns: readonly EditableColumnLike[];
  rowKey: (row: unknown) => string;
}
/** Outcome of {@link CellEditingState.handleKeyDown}. */
interface CellEditKeyOutcome {
  action: CellEditKeyAction;
  commit: CellEditCommit | null;
  advanceTarget: CellEditTarget | null;
}
/** Headless cell-editing state returned by {@link useCellEditing}. */
interface CellEditingState {
  /** The cell currently being edited, or `null` when idle. */
  active: CellEditTarget | null;
  /** Live draft string for the active editor. */
  draft: string;
  /** Whether `(rowId, columnKey)` is the active cell. */
  isActive: (rowId: string, columnKey: string) => boolean;
  /**
   * Start editing a cell. Re-beginning the same cell keeps the draft;
   * switching cells abandons the previous draft without committing.
   * Pass the row so lifecycle observers can name what opened.
   */
  begin: (rowId: string, columnKey: string, initialValue: string, row?: unknown) => void;
  /** Update the draft without committing. */
  setDraft: (value: string) => void;
  /**
   * Commit the draft. Returns the commit payload, or `null` when idle.
   * Clears the active cell. The table never mutates rows — callers must
   * apply the result through `onCellEdit` (see {@link applyCellEditCommit}).
   */
  commit: () => CellEditCommit | null;
  /**
   * Cancel editing and clear the active cell (Escape). Adapters should
   * restore focus to the cell that was being edited.
   */
  cancel: () => void;
  /**
   * Close the editor without treating it as a cancel — what a successful
   * validation does before handing the value to the host. Observers do not
   * hear about this; the commit event fires from the send instead.
   */
  close: () => void;
  /**
   * Drop the active edit when its row leaves the current page/filter set
   * (no commit). No-op when idle or the row is still present.
   */
  discardIfRowMissing: (rows: readonly unknown[], rowKey: (row: unknown) => string) => void;
  /**
   * The row the editor opened against, so a live update can be compared to
   * what the reader started from.
   */
  openedRow: () => unknown;
  /**
   * Keep the draft and accept `row` as the new snapshot — the incoming
   * change is acknowledged, the typing is not.
   */
  keepLive: (row: unknown) => void;
  /**
   * Replace the draft with `value` and accept `row` as the new snapshot —
   * the reader takes the incoming cell.
   */
  takeLive: (row: unknown, value: string) => void;
  /**
   * Keyboard flow:
   * - Enter → commit
   * - Escape → cancel (adapters restore focus)
   * - Tab → commit and advance; Shift+Tab → commit and go previous
   *
   * Returns `null` when idle or for unrelated keys (so the input keeps
   * default behaviour).
   */
  handleKeyDown: (event: {
    key: string;
    preventDefault: () => void;
    shiftKey?: boolean;
  }, navigation?: CellEditNavigation) => CellEditKeyOutcome | null;
}
/** What {@link useCellEditing} observes, when the host wired lifecycle events. */
interface UseCellEditingOptions<TRow = unknown> {
  /** An editor opened. */
  onEditStart?: EditEventHandler<TRow>;
  /** The reader threw the draft away (Escape, or switching cells). */
  onEditCancel?: EditEventHandler<TRow>;
}
/**
 * Headless editing state machine: one active cell, draft value, and the
 * Enter / Escape / Tab keyboard flow.
 *
 * @typeParam TRow - The row type, when lifecycle observers are wired.
 * @param options - Optional start/cancel observers.
 * @returns The state machine.
 */
declare function useCellEditing<TRow = unknown>(options?: UseCellEditingOptions<TRow>): CellEditingState;
//#endregion
//#region src/editing/validation.d.ts
/** Validate one edited value. Return a message to reject it, nothing to allow. */
type CellValidator<TRow> = (value: unknown, row: TRow) => string | undefined | Promise<string | undefined>;
/**
 * Validate the row an edit would produce.
 *
 * Return a message for a row-level problem, a map of column key → message to
 * mark individual cells, or nothing to allow the commit.
 */
type RowValidator<TRow> = (row: TRow) => string | Record<string, string> | undefined | Promise<string | Record<string, string> | undefined>;
/** A cell address, as the editing state spells it. */
interface ValidationTarget {
  rowId: string;
  columnKey: string;
}
/** Outcome of {@link EditValidationState.check}. */
interface ValidationCheckResult {
  /** Whether the commit may proceed. */
  allowed: boolean;
  /**
   * Why it may not, when it may not. Absent when a newer check superseded
   * this one.
   */
  error?: string;
}
/** Validation state for the whole table. */
interface EditValidationState<TRow> {
  /** The message on one cell, if any. */
  errorFor: (rowId: string, columnKey: string) => string | undefined;
  /** The row-level message, if any. */
  rowErrorFor: (rowId: string) => string | undefined;
  /** Whether a cell's validators are still running. */
  isValidating: (rowId: string, columnKey: string) => boolean;
  /** Whether any cell in this row carries a message. */
  rowHasError: (rowId: string) => boolean;
  /**
   * Run the validators for one commit.
   *
   * `allowed` is whether the commit may proceed. A rejection also carries
   * `error` — the sentence the editor shows — so a caller that fires in the
   * same tick as the check does not have to wait for a render to read it.
   */
  check: (options: {
    target: ValidationTarget;
    value: unknown;
    row: TRow;
    validateCell?: CellValidator<TRow>;
  }) => Promise<ValidationCheckResult>;
  /** Forget everything about one cell — what cancelling an edit does. */
  clear: (rowId: string, columnKey: string) => void;
  /** Forget every message. */
  clearAll: () => void;
  /** A digest of the messages, for a row memo comparator. */
  signature: string;
  /**
   * Whether a row validator is armed. A cell with no validator of its own still
   * has to run the check when the table has one — a cross-field rule fires on
   * whichever cell was edited.
   */
  hasRowValidator: boolean;
}
//#endregion
//#region src/editing/editableCellController.d.ts
/** Opt-in editing bundle from {@link TableChrome.editing}. */
interface EditableCellEditing<TRow> {
  /**
   * The per-cell change channel. Return a promise and the cell shows it is
   * saving until that promise settles, and shows why if it rejects.
   *
   * Absent when the host wants row-level commits only: the bundle still exists
   * (row mode needs it) and every cell stays display-only until a reader opens
   * the row.
   */
  onCellEdit?: (row: TRow, key: string, nextValue: unknown) => unknown;
  state: CellEditingState;
  /**
   * Validation, when the host declared any. A commit runs the validators first
   * and is dropped if one rejects — the editor stays open with the message on
   * it, so the reader fixes what they typed instead of losing it.
   */
  validation?: EditValidationState<TRow>;
  /**
   * Save state, when the host's `onCellEdit` returns promises. Inert for a
   * host that saves synchronously.
   */
  saving?: CellSaveState<TRow>;
  /** Dirty marks, when the host asked for them (`dirtyIndicators`). */
  dirty?: DirtyCellState;
  /**
   * Row-mode state, when the host armed it. While a row is open its cells render
   * row editors instead of the per-cell activate control.
   */
  rowEditing?: RowEditingState<TRow>;
  /**
   * Batch state, when the host armed it. Every editable cell renders a field
   * and nothing reaches the host until the reader saves them all.
   */
  batch?: BatchEditingState<TRow>;
  /** Lifecycle observers — fire from the same place the transition happens. */
  lifecycle?: EditLifecycle<TRow>;
  /** Live-update conflict for the open editor, when one is being asked about. */
  conflict?: EditConflictState<TRow>;
  /** Labels for the conflict notice — already resolved. */
  conflictLabels?: {
    message: string;
    keepMine: string;
    takeTheirs: string;
    theirsValue: (value: string) => string;
  };
}
/** Display / edit mode for one cell. */
type EditableCellMode = "display" | "activatable" | "editing";
/** Controller returned by {@link editableCellController}. */
interface EditableCellController<TRow = unknown> {
  mode: EditableCellMode;
  /** The validator's message for this cell, if it rejected the last commit. */
  error?: string;
  /** Whether an async validator is still deciding about this cell. */
  validating: boolean;
  /** What this cell's last save is doing: in flight, or failed. */
  saveStatus?: CellSaveStatus;
  /** Why this cell's last save failed, and what it takes to undo it. */
  saveFailure?: FailedCellSave<TRow>;
  /** Whether this cell holds a change nobody has confirmed yet. */
  isDirty: boolean;
  /** Whether an undo can be offered — the host said how to perform one. */
  canRollback: boolean;
  /** Put the previous value back after a failed save. */
  rollback: () => void;
  /** Forget a failed save without restoring anything. */
  dismissFailure: () => void;
  /** Resolved editor when the column is editable; always set for activatable/editing. */
  editor: CellEditor | null;
  /** Normalized select options (empty for text/number). */
  selectOptions: ReturnType<typeof normalizeEditorOptions>;
  draft: string;
  begin: () => void;
  setDraft: (value: string) => void;
  /** Commit the draft now, without waiting for Enter or a blur. */
  commit: () => void;
  /** Abandon the draft, exactly as Escape does. */
  cancel: () => void;
  /** Wire to the editor's keydown — Enter/Tab/Escape. */
  onEditorKeyDown: (event: {
    key: string;
    preventDefault: () => void;
    shiftKey?: boolean;
  }) => void;
  /** Commit on blur (click-away). No-op when not editing. */
  commitOnBlur: () => void;
  /**
   * A live row changed under this editor. Present only while the policy is
   * asking; Keep mine / Take theirs resolve it.
   */
  conflict?: EditConflict<TRow>;
  /** Labels for the conflict notice. */
  conflictLabels?: {
    message: string;
    keepMine: string;
    takeTheirs: string;
    theirsValue: (value: string) => string;
  };
  /** Keep the draft. */
  keepConflict: () => void;
  /** Take the incoming value. */
  takeConflict: () => void;
}
/**
 * Derive the per-cell editing controller. When `editing` is omitted (host
 * did not pass `onCellEdit`), always returns `mode: "display"` — zero UI
 * change for tables that never opted in.
 */
declare function editableCellController<TRow>(options: {
  editing: EditableCellEditing<TRow> | undefined;
  row: TRow;
  column: ColumnDef<TRow>;
  rowId: string;
  rows: readonly TRow[];
  columns: readonly ColumnDef<TRow>[];
  rowKey: (row: TRow) => string;
}): EditableCellController;
/**
 * Attach as a `ref` (or kit `inputRef`) so the editor receives focus when the
 * cell enters edit mode — replaces the `autoFocus` attribute (axe/a11y).
 * Accepts DOM nodes and kit refs that expose `.focus()` (e.g. antd InputRef).
 */
declare function focusEditorOnMount(node: {
  focus: () => void;
} | null): void;
/**
 * Whether any cell in a row holds a change nobody has confirmed.
 *
 * Read by every adapter's row so the mark exists at both scales: a reader
 * scanning a long table sees which rows are unsettled without hunting for the
 * cell inside them.
 *
 * @typeParam TRow - The row type.
 * @param editing - The editing bundle from the chrome.
 * @param rowId - The row's stable id.
 * @returns Whether to mark the row.
 */
declare function rowIsDirty<TRow>(editing: EditableCellEditing<TRow> | undefined, rowId: string): boolean;
/**
 * Memo digest for one desktop/card row: `null` when editing is off (host
 * never passed `onCellEdit`); empty string when this row is idle; otherwise
 * `columnKey:draft` so only the active edit row re-renders on keystrokes.
 */
declare function rowEditingSignature<TRow>(editing: EditableCellEditing<TRow> | undefined, rowId: string): string | null;
//#endregion
//#region src/editing/EditableCellGate.d.ts
/** Props for a kit-native editor while a cell is active. */
interface EditableCellEditorCtrl {
  draft: string;
  setDraft: (value: string) => void;
  onEditorKeyDown: (event: {
    key: string;
    preventDefault: () => void;
    shiftKey?: boolean;
  }) => void;
  commitOnBlur: () => void;
  editor: NonNullable<ReturnType<typeof editableCellController>["editor"]>;
  selectOptions: ReturnType<typeof editableCellController>["selectOptions"];
  /**
   * A validator's message for this cell, when the last commit was rejected.
   * Wire it to the kit's own error surface (Mantine's `error`, MUI's
   * `helperText`, …) — and it is on the DOM either way, see `errorId`.
   */
  error?: string;
  /** Whether an async validator is still deciding. */
  validating: boolean;
  /**
   * `id` of the element holding the message. Put it on the editor's
   * `aria-describedby` so the message is announced with the field, and set
   * `aria-invalid` when `error` is set.
   */
  errorId: string;
  /**
   * Attach as the editor's `ref` so the table decides what takes focus.
   *
   * In cell mode that is this editor, every time. In row mode a whole row opens
   * at once, and only the FIRST field should take focus — nine editors each
   * calling focus on mount would leave the reader at the last column of the row
   * they just opened.
   */
  focusRef: (node: {
    focus: () => void;
  } | null) => void;
  /** A live row changed under this editor. */
  conflict?: boolean;
}
/**
 * Opt-in cell wrapper: plain display when editing is off; double-click /
 * Enter / F2 to activate; kit supplies the editor via `renderEditor`.
 *
 * When `editing` is omitted this is a pure pass-through of `display` —
 * zero DOM / behavior change for tables that never opted into cell edit.
 */
interface EditableCellGateProps<TRow> {
  readonly editing: EditableCellEditing<TRow> | undefined;
  readonly row: TRow;
  readonly column: ColumnDef<TRow>;
  readonly rowId: string;
  readonly rows: readonly TRow[];
  readonly columns: readonly ColumnDef<TRow>[];
  readonly rowKey: (row: TRow) => string;
  /** Accessible name for the activate control. */
  readonly editLabel: string;
  /** Optional class for the activate button (adapters' styling hook). */
  readonly activateClassName?: string;
  /** Optional class for the validation message (adapters' styling hook). */
  readonly errorClassName?: string;
  /** Optional class for a failed save's message. */
  readonly saveErrorClassName?: string;
  /** Optional class for the undo control beside it. */
  readonly rollbackClassName?: string;
  /**
   * Label for the undo control a failed save offers (`labels.undoEdit`). Omit
   * it and the message shows without one — right for a table that refetches
   * rather than rolling back.
   */
  readonly undoLabel?: string;
  /**
   * Set by a kit whose own input renders the message — Mantine's `error`, MUI's
   * `helperText`. Those components own the input's `aria-describedby`, so a
   * second copy of the text would be both duplicated in the DOM and announced
   * twice. The gate then renders no message of its own and leaves the ARIA to
   * the kit.
   */
  readonly kitRendersError?: boolean;
  readonly display: ReactNode;
  /**
   * Kit-native editor. Only called while this cell is the active edit.
   * Wire `value`/`onChange`/`onKeyDown`/`onBlur` from the controller.
   */
  readonly renderEditor: (ctrl: EditableCellEditorCtrl) => ReactElement;
  /** Kit activate control and conflict / undo buttons. */
  readonly slots: EditableCellSlots;
}
/** Kit activate control the gate calls while the cell is idle. */
interface EditableCellActivateProps {
  readonly title: string;
  readonly className?: string;
  readonly saveStatus: string | undefined;
  readonly dirty: boolean;
  readonly activateRef: (node: HTMLButtonElement | null) => void;
  readonly display: ReactNode;
  readonly onDoubleClick: (event: {
    preventDefault: () => void;
    stopPropagation: () => void;
  }) => void;
  readonly onClick: (event: {
    stopPropagation: () => void;
  }) => void;
  readonly onKeyDown: (event: {
    key: string;
    preventDefault: () => void;
    stopPropagation: () => void;
  }) => void;
}
/** Kit button the gate calls for conflict choices and undo. */
interface EditableCellButtonProps {
  readonly label: string;
  readonly part: string;
  readonly className?: string;
  readonly onMouseDown?: (event: {
    preventDefault: () => void;
  }) => void;
  readonly onClick: (event: {
    stopPropagation: () => void;
  }) => void;
}
/** Adapter-supplied controls for {@link EditableCellGate}. */
interface EditableCellSlots {
  readonly Activate: (props: EditableCellActivateProps) => ReactNode;
  readonly Button: (props: EditableCellButtonProps) => ReactNode;
}
/**
 * The ARIA a kit's editor needs when validation is in play.
 *
 * Spread onto the input or select: invalid marks the field, `describedby`
 * points at the message so it is read WITH the field rather than announced
 * once and lost, and busy says an async check is still deciding.
 *
 * @param ctrl - The editor controller the gate handed the kit.
 * @returns Attributes to spread; empty while the value is fine.
 */
declare function editorValidationProps(ctrl: EditableCellEditorCtrl): {
  "aria-invalid"?: true;
  "aria-describedby"?: string;
  "aria-busy"?: true;
  "data-conflict"?: "";
};
/**
 * Busy and conflict marks, for a kit whose own input owns `aria-invalid`
 * (Mantine, MUI). `data-conflict` still belongs on the field so the same
 * selector works on every kit; `aria-describedby` points at the notice
 * while one is up.
 *
 * @param ctrl - The editor controller the gate handed the kit.
 * @returns Attributes to spread; empty unless a check is running or a
 *   conflict is being asked.
 */
declare function editorBusyProps(ctrl: EditableCellEditorCtrl): {
  "aria-busy"?: true;
  "aria-describedby"?: string;
  "data-conflict"?: "";
};
/**
 * Toggle a checkbox editor and commit in the same gesture.
 *
 * A checkbox has one gesture, so waiting for Enter or a blur would leave the
 * reader looking at a ticked box that has changed nothing. Safe to call
 * synchronously: the editing state writes its draft ref in the same tick, so the
 * commit that follows sees the new value.
 *
 * @param ctrl - The editor controller the gate handed the kit.
 * @param checked - The box's new state.
 */
declare function commitBooleanDraft(ctrl: EditableCellEditorCtrl, checked: boolean): void;
/**
 * The draft for a native `<select multiple>`'s current selection.
 *
 * @param select - The select element.
 * @returns The draft string the editing state holds.
 */
declare function multiDraftFromSelect(select: HTMLSelectElement): string;
/** Opt out of the React Compiler: early returns swap trees of different memo sizes. */
declare function EditableCellGate<TRow>(props: EditableCellGateProps<TRow>): ReactElement;
//#endregion
//#region src/export/useExportHandler.d.ts
/** Where an export is in its life. */
type ExportStatus = "idle" | "busy" | "done" | "failed";
/** What {@link useExportHandler} returns. */
interface ExportHandlerState {
  /** Bind to the Export button, or `undefined` when export is off. */
  onExportCsv: (() => void) | undefined;
  /** True while a host-handled export is still running. */
  exportBusy: boolean;
  /**
   * Idle, busy, done or failed — for a kit that shows more than a spinner, and
   * for tests that assert the outcome rather than the visuals.
   */
  exportStatus: ExportStatus;
  /**
   * Live-region text for the last outcome, empty until there is one. Adapters
   * render it in a polite region beside the button.
   */
  exportAnnouncement: string;
  /**
   * The button's caption, naming the format it actually produces — "Export CSV"
   * by default, "Export XLSX" with the spreadsheet writer, and localized either
   * way. A button that names a file the user is not getting is a lie no adapter
   * should have to correct.
   */
  exportLabel: string;
}
/**
 * Make an export handler single-flight, and report what it is doing.
 *
 * @param handler - The handler from `makeExportCsvHandler`, or `undefined`
 *   when the `exportCsv` prop is off.
 * @param labels - Resolved table labels, for the caption and the announcements.
 * @param format - The writer's extension. Defaults to `"csv"`, the built-in.
 * @param pageOnly - The handler writes the current page even though the
 *   host asked for `"all"`. The button says so instead of "Export CSV".
 */
declare function useExportHandler(handler: (() => void | Promise<void>) | undefined, labels?: TableLabels, format?: string, pageOnly?: boolean): ExportHandlerState;
//#endregion
//#region src/filters/FilterHeaderRow.d.ts
/** Class hooks the unstyled adapter maps onto `DataTableClassNames`. */
interface FilterHeaderClassNames {
  filterHeaderRow?: string;
  filterHeaderCell?: string;
  filterHeaderInput?: string;
  filterHeaderMenu?: string;
  headerCell?: string;
  expandHeader?: string;
  reorderHeader?: string;
  selectionHeader?: string;
  actionsHeader?: string;
}
/** Overlay a sticky `top` on a cell or pad style. */
declare function headerFilterStickTop(sticky: boolean, base: CSSProperties | undefined, top: number, stickyExtras?: CSSProperties): CSSProperties | undefined;
/** Props for an adapter {@link FilterHeaderRow} — no slots on the public API. */
interface FilterHeaderRowProps<TRow> {
  /** When false the row does not render, even if defs exist. */
  readonly enabled?: boolean;
  readonly columns: readonly ColumnDef<TRow>[];
  readonly defs: readonly FilterDef<TRow>[];
  readonly source: FilterFormSource<TRow>;
  readonly registry?: FilterTypeRegistry;
  readonly labels: Required<TableLabels>;
  readonly expandable?: boolean;
  readonly showReorder?: boolean;
  readonly selection?: boolean;
  readonly showActions?: boolean;
  readonly columnSpacers?: {
    start: number;
    end: number;
  };
  readonly cellStyle?: (column: ColumnDef<TRow>) => CSSProperties | undefined;
  readonly pinSide?: (key: string) => "start" | "end" | undefined;
  readonly padStyle?: CSSProperties;
  readonly stickyAttr?: true;
  readonly classNames?: FilterHeaderClassNames;
}
/** Props for an adapter {@link FilterHeaderControl} — no slots on the public API. */
interface FilterHeaderControlProps<TRow> {
  readonly def: FilterDef<TRow>;
  readonly source: FilterFormSource<TRow>;
  readonly labels: Required<TableLabels>;
  readonly className?: string;
  readonly registry?: FilterTypeRegistry;
  /**
   * Dismiss the overlay after a finished single-control write. Default off.
   * Wired from the table's `closeHeaderFilterOnSelect`.
   */
  readonly closeOnSelect?: boolean;
}
/** One option in a header Select or multi menu. */
interface FilterHeaderOption {
  readonly value: string;
  readonly label: string;
}
/** Kit search field a text header cell calls. */
interface FilterHeaderSearchProps {
  readonly label: string;
  readonly placeholder: string;
  readonly value: string;
  readonly className?: string;
  readonly onChange: (value: string) => void;
}
/** Kit Select a select/boolean header cell calls. */
interface FilterHeaderSelectProps {
  readonly label: string;
  readonly value: string;
  readonly options: readonly FilterHeaderOption[];
  readonly className?: string;
  readonly onChange: (value: string) => void;
}
/** Kit number/date field a range header cell calls. */
interface FilterHeaderRangeProps {
  readonly label: string;
  readonly type: "text" | "number" | "date";
  readonly value: string;
  readonly onChange: (value: string) => void;
}
/** Kit compact multi menu a checklist/multiSelect header cell calls. */
interface FilterHeaderMultiProps {
  readonly label: string;
  readonly summary: string;
  readonly options: readonly FilterHeaderOption[];
  readonly selected: readonly string[];
  readonly className?: string;
  readonly menuClassName?: string;
  readonly onToggle: (value: string, checked: boolean) => void;
}
/** Adapter-supplied controls for {@link FilterHeaderChrome}. */
interface FilterHeaderSlots {
  readonly Search: (props: FilterHeaderSearchProps) => ReactNode;
  readonly Select: (props: FilterHeaderSelectProps) => ReactNode;
  readonly Range: (props: FilterHeaderRangeProps) => ReactNode;
  readonly Multi: (props: FilterHeaderMultiProps) => ReactNode;
}
/** Props for {@link FilterHeaderChrome}. */
interface FilterHeaderChromeProps<TRow> extends FilterHeaderRowProps<TRow> {
  readonly slots: FilterHeaderSlots;
}
/** Props for {@link FilterHeaderControlChrome}. */
interface FilterHeaderControlChromeProps<TRow> extends FilterHeaderControlProps<TRow> {
  readonly slots: FilterHeaderSlots;
}
/** The definition that drives a column's header filter, if any. */
declare function filterDefForColumn<TRow>(defs: readonly FilterDef<TRow>[], key: string): FilterDef<TRow> | undefined;
/** Compact control for one filter definition — used in the header row and antd titles. */
declare function FilterHeaderControlChrome<TRow>({
  def,
  source,
  labels,
  className,
  registry,
  slots
}: Readonly<FilterHeaderControlChromeProps<TRow>>): ReactElement;
/**
 * Second header row of per-column quick filters. Pads and spacers match
 * the leaf header so sticky, pin offsets, and column windowing stay aligned.
 */
declare function FilterHeaderChrome<TRow>({
  enabled,
  columns,
  defs,
  source,
  labels,
  expandable,
  showReorder,
  selection,
  showActions,
  columnSpacers,
  cellStyle,
  pinSide,
  padStyle,
  stickyAttr,
  classNames,
  registry,
  slots
}: Readonly<FilterHeaderChromeProps<TRow>>): ReactElement | null;
//#endregion
//#region src/focus/gridFocus.d.ts
/** A cell address in the grid: both indices absolute, both zero-based. */
interface GridCell {
  /** Row index within the whole dataset, not within the rendered window. */
  row: number;
  /** Column index within the visible column set. */
  col: number;
}
/** The grid's shape, as the mover needs to see it. */
interface GridBounds {
  /** Total rows the user can reach — the dataset, not the rendered slice. */
  rowCount: number;
  /** Total columns the user can reach. */
  colCount: number;
  /**
   * Rows a PageUp/PageDown travels. The viewport's worth, so paging feels like
   * paging rather than an arbitrary jump.
   */
  pageSize: number;
}
/**
 * What a key press means. Named rather than passed as raw keys so the mapping
 * is testable on its own and an adapter can bind a kit's own control to the
 * same intent.
 */
type GridFocusMove = "up" | "down" | "left" | "right" | "rowStart" | "rowEnd" | "gridStart" | "gridEnd" | "pageUp" | "pageDown";
/**
 * Where a move lands, clamped to the grid.
 *
 * Edges stop rather than wrap. Wrapping a right-arrow from the last column to
 * the first cell of the next row is a spreadsheet convention, and in a table
 * it silently moves the user to a different record — so this holds still and
 * lets the screen reader stay quiet.
 *
 * A covered cell (inside someone else's row/col span) is skipped in the
 * same direction; if every remaining cell is covered, focus stays put.
 *
 * @param from - Where focus is now.
 * @param move - The intent, from {@link gridFocusMoveForKey}.
 * @param bounds - The grid's shape.
 * @param covered - True for a cell that must not receive focus.
 * @returns The new address, which may equal `from` at an edge.
 */
declare function moveGridFocus(from: GridCell, move: GridFocusMove, bounds: GridBounds, covered?: (cell: GridCell) => boolean): GridCell;
/** The key press, as much of it as the mapping needs. */
interface GridKeyPress {
  key: string;
  /** Ctrl or Cmd — either one means "to the end of the grid". */
  ctrlKey?: boolean;
  metaKey?: boolean;
}
/**
 * Turn a key press into a move, or `null` when the grid should not react.
 *
 * Left and Right swap under `dir="rtl"`, because the arrow keys describe the
 * screen and not the data: in a mirrored table the visually-next column is the
 * previous one. Nothing else flips — Home is still the start of the row, which
 * in RTL is its right-hand end, and that is what a user pressing Home wants.
 *
 * @param press - The key event, narrowed to what matters.
 * @param dir - The table's text direction.
 * @returns The intended move, or `null` to let the event through untouched.
 */
declare function gridFocusMoveForKey(press: GridKeyPress, dir?: Direction): GridFocusMove | null;
/** Are two addresses the same cell? */
declare function sameGridCell(a: GridCell | null, b: GridCell | null): boolean;
//#endregion
//#region src/focus/cellRange.d.ts
/** A rectangle of cells, stored as the two corners that made it. */
interface CellRange {
  /** Where the selection began — fixed while the head moves. */
  anchor: GridCell;
  /** Where it currently reaches — the moving corner. */
  head: GridCell;
}
/** The rectangle's edges, normalized so `from` is always the top-left. */
interface CellRangeBounds {
  fromRow: number;
  toRow: number;
  fromCol: number;
  toCol: number;
}
/**
 * The rectangle a range covers, with the corners sorted.
 *
 * A range dragged upward has an anchor below its head, so every consumer would
 * otherwise repeat the same min/max dance and one of them would forget.
 */
declare function cellRangeBounds(range: CellRange): CellRangeBounds;
/** Is this cell inside the range? */
declare function isInCellRange(range: CellRange | null, cell: GridCell): boolean;
/** How many cells the range covers — rows × columns, never enumerated. */
declare function cellRangeSize(range: CellRange | null): number;
/** A single cell selected on its own. */
declare function singleCellRange(cell: GridCell): CellRange;
/**
 * Move the head, keeping the anchor — what Shift+arrow and Shift+click do.
 *
 * Starting from nothing anchors at the cell that had focus, so the first
 * Shift+Down selects two cells rather than one.
 */
declare function extendCellRange(range: CellRange | null, head: GridCell, fallbackAnchor: GridCell): CellRange;
/** Is the range a single cell? Useful for deciding whether to show chrome. */
declare function isSingleCell(range: CellRange | null): boolean;
/**
 * The rows and columns a range covers, as index lists.
 *
 * This is the one place that does enumerate, because an exporter has to walk
 * them — and it is a deliberate boundary: the model stays two corners, and
 * anything that needs the cells asks for them explicitly.
 */
declare function cellRangeIndices(range: CellRange): {
  rows: number[];
  cols: number[];
};
//#endregion
//#region src/find/useFindInTable.d.ts
/** What {@link useFindInTable} needs. */
interface UseFindInTableOptions<TRow> {
  /** Off unless the host asked for it; when false nothing is searched. */
  enabled: boolean;
  /** The rows the browser holds, in table order. */
  rows: readonly TRow[];
  /** The columns as rendered. */
  columns: readonly ColumnDef<TRow>[];
  /** Where the rendered window starts in the dataset. Zero unless paged. */
  firstRowIndex?: number;
}
/** What {@link useFindInTable} returns. */
interface FindInTableState {
  /** Whether the bar is showing. */
  open: boolean;
  /** Show or hide the bar. Hiding clears the query, as a find bar does. */
  setOpen: (open: boolean) => void;
  /** The current query. */
  query: string;
  /** Type into the find bar. Resets the walk to the first hit. */
  setQuery: (query: string) => void;
  /** Every matching cell, in reading order. */
  matches: readonly GridCell[];
  /** Their keys, for marking cells as this render walks them. */
  matchKeys: ReadonlySet<string>;
  /** Which match the walk is on, from zero; `-1` when there are none. */
  index: number;
  /** The cell the walk is on, or `null`. */
  current: GridCell | null;
  /** Step to the next hit, wrapping at the end. */
  next: () => void;
  /** Step to the previous hit, wrapping at the start. */
  previous: () => void;
  /**
   * Open the bar — what Ctrl/Cmd+F and a host's own button call. `undefined`
   * when the feature is off, so the shortcut stays the BROWSER'S rather than
   * being swallowed by a table that has no bar to show.
   */
  openBar?: () => void;
}
/**
 * Find state over the loaded rows.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseFindInTableOptions}.
 * @returns The state; inert with `enabled` false.
 */
declare function useFindInTable<TRow>(options: UseFindInTableOptions<TRow>): FindInTableState;
/**
 * Take the table's focus to whichever match the walk is on.
 *
 * Highlighting alone is not finding: with 500 rows rendered, the hit is
 * usually off-screen, so the walk moves focus — which scrolls the cell into
 * view, announces it, and leaves it selected. Both the shell and the antd
 * adapter wire find this way, and this is the one place that rule lives.
 *
 * @param current - The match the walk is on, or `null`.
 * @param focusCell - The grid's `focusCell`.
 * @param selectRange - The grid's `selectRange`.
 */
declare function useFindFocus(current: GridCell | null, focusCell: (cell: GridCell) => void, selectRange: (range: CellRange | null) => void): void;
//#endregion
//#region src/focus/cellEdits.d.ts
/**
 * What a batch gesture commits, and who receives it.
 *
 * Paste and fill both write many cells at once, and both do it as ORDINARY
 * edits: the same shape an inline commit produces, through the same handler.
 * That is deliberate — anything later wrapped around single-cell editing
 * (validation, async saves, conflict handling) covers a batch without the
 * batch knowing it exists, and there is never a second half-maintained
 * editing route to keep in step.
 */
/** One cell written — exactly what an inline commit writes. */
interface CellEdit<TRow> {
  /** The row being written. */
  row: TRow;
  /** Which column, by key. */
  columnKey: string;
  /** The value to commit, already through the column's `parseValue`. */
  value: unknown;
}
/**
 * Resolve who receives a batch of edits.
 *
 * A table that can already be edited can already be pasted into and filled:
 * with no batch handler, each edit goes through `onCellEdit`, the exact call
 * an inline commit makes. The batch handler exists for hosts that want the
 * whole set at once — one server round trip, one undo entry — and takes
 * precedence when given.
 *
 * @typeParam TRow - The row type.
 * @param batch - The host's batch handler, when it has one.
 * @param onCellEdit - The ordinary inline-edit channel.
 * @returns The handler, or `undefined` when the table takes no edits at all —
 *   which leaves the gesture's key or drag to the browser.
 */
declare function batchEditHandler<TRow>(batch: ((edits: CellEdit<TRow>[]) => void) | undefined, onCellEdit: ((row: TRow, key: string, nextValue: unknown) => void) | undefined): ((edits: CellEdit<TRow>[]) => void) | undefined;
//#endregion
//#region src/focus/useGridFocus.d.ts
/** The attribute a focusable cell carries, so focus can find it in the DOM. */
declare const GRID_CELL_ATTR = "data-grid-cell";
/** `data-grid-cell` value for one address — `"row:col"`, both absolute. */
declare function gridCellAttr(cell: GridCell): string;
/** Options for {@link useGridFocus}. */
interface UseGridFocusOptions<TRow> {
  /** Off unless the host asked for it; when false the hook does nothing. */
  enabled: boolean;
  /**
   * Offer a checkbox in every column header that selects that column.
   *
   * Ctrl/Cmd+click is the gesture for a keyboard and a mouse, and a touch
   * device has neither — there is no Ctrl key to hold. This is the same
   * state reached by a control a finger can hit, and the same state a
   * screen reader can name. Off unless asked for.
   */
  headerCheckbox?: boolean;
  /**
   * Rows in the whole dataset. This is the ARIA number — `aria-rowcount` — and
   * deliberately NOT what movement is clamped to; see the note on navigable
   * bounds below.
   */
  rowCount: number;
  /** Columns in the order they are rendered. */
  columns: readonly ColumnDef<TRow>[];
  /** The rendered rows, for reading a cell's text when focus lands. */
  rows: readonly TRow[];
  /**
   * Where the rendered window starts in the dataset. Zero without
   * virtualization; with it, `rows[i]` is dataset row `firstRowIndex + i`.
   */
  firstRowIndex?: number;
  /** Rows a PageUp/PageDown travels. Defaults to the rendered row count. */
  pageSize?: number;
  /** Text direction — flips the left/right arrows. */
  dir?: Direction;
  /** Announcement strings; falls back to the built-in English. */
  labels?: TableLabels;
  /**
   * Bring a dataset row into view. Supplied by the virtualizer; without it a
   * move to an unmounted row cannot be completed and is left alone rather than
   * silently dropping focus.
   */
  scrollToRow?: (rowIndex: number) => void;
  /** Enter or F2 on a cell — the editing model's entry point. */
  onActivate?: (cell: GridCell) => void;
  /**
   * True for a cell covered by someone else's span. Arrow keys skip it
   * rather than landing inside a cell that is not in the DOM.
   */
  isCoveredCell?: (cell: GridCell) => boolean;
  /**
   * Fired whenever the selected range changes, including when it collapses to
   * a single cell. `null` means nothing is selected.
   */
  onRangeChange?: (range: CellRange | null) => void;
  /**
   * Ctrl/Cmd+X after the copy succeeded. The table never clears data itself —
   * what "cut" removes is the host's decision, and a cut that emptied cells
   * before the clipboard accepted them would lose them outright.
   */
  onCut?: (range: CellRange) => void;
  /**
   * Ctrl/Cmd+V, with the clipboard already parsed into ordinary cell edits.
   *
   * Paste is not a second commit path: these are the same edits an inline edit
   * produces, so validation or async saving added to that path covers a paste
   * without paste knowing. Applying them stays the host's job — the table never
   * writes to data it does not own.
   */
  onPaste?: (edits: CellEdit<TRow>[]) => void;
  /**
   * A fill — the handle dragged from the selection's corner, or Ctrl/Cmd+D —
   * already turned into ordinary cell edits. Same shape and same contract as
   * {@link UseGridFocusOptions.onPaste}: the table proposes, the host writes.
   */
  onFill?: (edits: CellEdit<TRow>[]) => void;
  /**
   * Ctrl/Cmd+Z. Returns how many cells came back, so the grid can say — zero
   * means the history was empty, which is worth announcing rather than
   * swallowing.
   */
  onUndo?: () => number;
  /** Ctrl/Cmd+Shift+Z and Ctrl+Y. Returns how many cells were rewritten. */
  onRedo?: () => number;
  /** Ctrl/Cmd+F — open the find bar instead of the browser's own. */
  onFind?: () => void;
  /**
   * Cells the find bar matched, keyed `"row:col"`. They carry
   * `data-cell-match`, and the one the walk is on carries
   * `data-cell-match-current`, so each kit paints the hits its own way.
   */
  matchKeys?: ReadonlySet<string>;
  /** The match the walk is on, for the stronger mark. */
  currentMatch?: GridCell | null;
}
/** What {@link useGridFocus} returns. */
interface GridFocusState {
  /**
   * Whether cell navigation is on. Consumers render the live region only when
   * it is: an `aria-live` region that appears at the same moment as its text is
   * frequently missed by screen readers, so it has to exist beforehand — and
   * must not exist at all when the feature is off.
   */
  enabled: boolean;
  /** The focused cell, or `null` before the grid has been entered. */
  active: GridCell | null;
  /** Props for the grid container: role, dimensions, key handling. */
  getGridProps: () => Record<string, unknown>;
  /** Props for one cell — roving `tabIndex`, absolute indices, the hook. */
  getCellProps: (cell: GridCell) => Record<string, unknown>;
  /** Props for one row: its absolute `aria-rowindex`. */
  getRowProps: (rowIndex: number) => Record<string, unknown>;
  /**
   * Props for a cell addressed by its position in the RENDERED window — which
   * is the index an adapter already has, whether it is mapping `source.rows` or
   * a virtual entry.
   *
   * The conversion to an absolute address lives here rather than in eight
   * adapters, because getting it wrong is invisible: the table looks right and
   * only a screen reader announces the wrong row.
   */
  getCellPropsAt: (windowIndex: number, col: number) => Record<string, unknown>;
  /** Props for a row addressed by its position in the rendered window. */
  getRowPropsAt: (windowIndex: number) => Record<string, unknown>;
  /** Live-region text naming where focus is. Empty until focus moves. */
  announcement: string;
  /** The selected rectangle, or `null` when nothing is selected. */
  range: CellRange | null;
  /** Select a rectangle programmatically — what a Select-all would call. */
  selectRange: (range: CellRange | null) => void;
  /**
   * Props for a column header that selects its whole column on click, with
   * Ctrl/Cmd+click extending the current selection instead of replacing it.
   */
  getColumnHeaderProps: (col: number, options?: {
    sortable?: boolean;
  }) => Record<string, unknown>;
  /**
   * Select a whole column by index — the loaded rows of it, since a column of
   * 100,000 rows cannot be selected while 500 are in hand.
   */
  selectColumn: (col: number, extend?: boolean) => void;
  /**
   * Whether an adapter should draw the per-column header checkbox: the host
   * asked for it AND cell navigation is on, resolved here so a header cell
   * renders on one boolean instead of checking two.
   */
  columnCheckbox: boolean;
  /**
   * Whether the selection is exactly this column, over every loaded row.
   *
   * Exactly — a column inside a wider rectangle reads as unchecked, because a
   * checkbox that ticks while its neighbours are also selected says the
   * selection is one column when it is four.
   */
  isColumnSelected: (col: number) => boolean;
  /**
   * What the header checkbox does: select this column alone, or clear the
   * selection when it is already the only thing selected.
   */
  toggleColumn: (col: number) => void;
  /** Move focus programmatically — the fill handle and clipboard will need it. */
  focusCell: (cell: GridCell) => void;
  /**
   * The cell carrying the fill handle — the selection's bottom inline-end
   * corner — or `null` when there is nothing to fill from or no host to
   * receive it.
   */
  fillHandleCell: GridCell | null;
  /** Props for the adapter-owned fill handle element. */
  getFillHandleProps: () => Record<string, unknown>;
  /** The handle's accessible name, already localized. */
  fillHandleLabel: string;
  /**
   * What a fill in progress would cover, for a kit that wants to draw the
   * preview its own way. `null` unless a fill is being dragged.
   */
  fillPreview: CellRange | null;
  /**
   * Copy or cut without the keyboard.
   *
   * Ctrl+C always has a focused range. A context menu does not — a
   * right-click on a cell with nothing selected has to copy that cell — so
   * an explicit cell wins and the selection is the fallback.
   */
  copyCells: (cell?: GridCell, cut?: boolean) => void;
}
/**
 * Keyboard focus over the cell grid.
 *
 * @typeParam TRow - The row type.
 */
declare function useGridFocus<TRow>(options: UseGridFocusOptions<TRow>): GridFocusState;
//#endregion
//#region src/focus/selectionStats.d.ts
/** The numbers behind a selection. */
interface SelectionStats {
  /** Every selected cell, numeric or not. */
  cells: number;
  /** How many of them held a number. */
  numeric: number;
  /** Total of the numeric cells; `null` when there are none. */
  sum: number | null;
  /** Mean of the numeric cells; `null` when there are none. */
  average: number | null;
  /** Smallest numeric value; `null` when there are none. */
  min: number | null;
  /** Largest numeric value; `null` when there are none. */
  max: number | null;
}
/** What the statistics need: the rectangle, and the data under it. */
interface SelectionStatsOptions<TRow> {
  /**
   * Off unless the host asked for it. Passed rather than checked at the call
   * site so the two tables that compute this read identically.
   */
  enabled?: boolean;
  /** The selected rectangle, in absolute addresses. */
  range: CellRange | null;
  /** The rows the browser holds, in table order. */
  rows: readonly TRow[];
  /** The columns as rendered — a range's column indices address these. */
  columns: readonly ColumnDef<TRow>[];
  /** Where the rendered window starts in the dataset. Zero unless paged. */
  firstRowIndex?: number;
}
/**
 * Count, sum, average, min and max over the selected cells.
 *
 * Rows outside what the browser holds are skipped rather than counted as
 * empty: a column selection over 500 loaded rows of 100,000 describes the 500,
 * and inventing the rest would put a wrong total on screen.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link SelectionStatsOptions}.
 * @returns The statistics, or `null` when nothing is selected.
 */
declare function selectionStats<TRow>(options: SelectionStatsOptions<TRow>): SelectionStats | null;
//#endregion
//#region src/tree/treeRows.d.ts
/** One visual row of a tree: the row itself, plus where it sits. */
interface TreeEntry<TRow> {
  /** The row. */
  row: TRow;
  /** Its stable id. */
  key: string;
  /** Depth from zero — what the tree column indents by. */
  level: number;
  /** Whether it has children at all, loaded or not. */
  hasChildren: boolean;
  /** Whether its children are showing. */
  expanded: boolean;
  /** Its ancestors' ids, outermost first — what collapsing a parent hides. */
  path: readonly string[];
  /**
   * Every descendant's id, for selection: ticking a folder ticks what is in
   * it, and a parent shows as partly selected when only some are.
   */
  descendantIds: readonly string[];
  /** Whether children are being fetched for this node right now. */
  loading?: boolean;
}
/** How a host declares the hierarchy. */
interface TreeShape<TRow> {
  /** Nested data: the children of a row, if any. */
  getChildren?: (row: TRow) => readonly TRow[] | undefined;
  /** Flat data: the id of a row's parent, if any. */
  getParentId?: (row: TRow) => string | undefined;
  /**
   * Whether a row has children the browser has not fetched yet. Without it a
   * node with no loaded children is a leaf, which is the right default for
   * data that is all in hand.
   */
  hasChildren?: (row: TRow) => boolean;
}
/** What {@link buildTreeEntries} needs. */
interface BuildTreeEntriesOptions<TRow> extends TreeShape<TRow> {
  /** The rows, nested or flat. */
  rows: readonly TRow[];
  /** Row identity. */
  getRowId: (row: TRow) => string;
  /** Which nodes are expanded, by id. */
  expandedIds: ReadonlySet<string>;
  /** Nodes whose children are being fetched. */
  loadingIds?: ReadonlySet<string>;
}
/**
 * Flatten a hierarchy into the rows a table renders, in reading order.
 *
 * A collapsed node contributes itself and nothing beneath it. `descendantIds`
 * covers the whole subtree whether or not it is showing, because selecting a
 * folder means selecting what is in it — including the part currently folded
 * away.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link BuildTreeEntriesOptions}.
 * @returns The entries, in render order.
 */
declare function buildTreeEntries<TRow>(options: BuildTreeEntriesOptions<TRow>): TreeEntry<TRow>[];
/**
 * Keep the rows that match, and every ancestor that leads to one.
 *
 * A filtered tree that dropped the folders would leave matching files with no
 * path to them — the reader would see a flat list and lose the one thing the
 * tree was for. Ancestors are kept even when they do not match themselves.
 *
 * @typeParam TRow - The row type.
 * @param options - The shape, the rows, and the predicate.
 * @returns The rows that survive, nested exactly as they arrived.
 */
declare function filterTreeRows<TRow>(options: {
  rows: readonly TRow[];
  getChildren: (row: TRow) => readonly TRow[] | undefined; /** Rebuild a row with the children that survived — the host owns its shape. */
  withChildren: (row: TRow, children: readonly TRow[]) => TRow;
  match: (row: TRow) => boolean;
}): TRow[];
/**
 * The style a tree column's cell carries at a given depth.
 *
 * Logical padding, so a tree indents from the right in Arabic and Hebrew
 * without a second rule — the same one grouping uses, at the same step, so a
 * table that has both does not step differently between them.
 *
 * @param level - Depth from zero.
 * @returns The style for the tree column's cell.
 */
declare function treeIndentStyle(level: number): {
  paddingInlineStart?: string;
};
/**
 * The style a card carries at a given depth.
 *
 * A card is a block, not a cell, so the whole card steps in rather than its
 * text — on a narrow screen an indented card edge reads as hierarchy where an
 * indented line reads as a typo. Logical margin, so it steps from the right
 * in Arabic and Hebrew.
 *
 * @param level - Depth from zero.
 * @returns The style for the card.
 */
declare function treeCardStyle(level: number): {
  marginInlineStart?: string;
};
/** Which column renders the chevron and the indent. */
declare function treeColumnKey<TRow>(columns: readonly ColumnDef<TRow>[], declared?: string): string | undefined;
/** One body row an adapter renders, tree or flat. */
interface BodyRowEntry<TRow> {
  /** The row. */
  row: TRow;
  /** Its position for `data-index` and cell navigation. */
  index: number;
  /**
   * Index in the page dataset when pinned rows left the window.
   * Equals `index` when pinning is off.
   */
  sourceIndex?: number;
  /** Its stable key. */
  key: string;
  /** Its place in the tree, when the table is one. */
  treeEntry?: TreeEntry<TRow>;
}
/**
 * The rows a body renders: the tree's visible entries when the host declared
 * a hierarchy, the (possibly windowed) rows otherwise.
 *
 * Nine adapters make the same choice, so they make it in one place — and each
 * body keeps a single `.map` over one list rather than a branch that has to
 * stay in step across nine files.
 *
 * @typeParam TRow - The row type.
 * @param rows - The flat rows, already windowed.
 * @param tree - The tree bundle, when one is armed.
 * @returns What to render, in reading order.
 */
declare function bodyRowEntries<TRow>(rows: readonly {
  row: TRow;
  index: number;
  key: string;
  sourceIndex?: number;
}[], tree?: {
  entries: readonly TreeEntry<TRow>[];
}): BodyRowEntry<TRow>[];
//#endregion
//#region src/export/tableCsv.d.ts
/** Which rows an export covers. */
type ExportRowScope = "page" | "all" | "selected" | "range";
/**
 * Which columns an export covers: what the user can see, every defined
 * column, or an explicit list of keys in file order.
 */
type ExportColumnScope = "visible" | "all" | readonly string[];
/** Opt-in CSV export config for the shared DataTable surface. */
interface ExportCsvOptions<TRow = unknown> {
  /** Download filename. Defaults to `"export.csv"`. */
  filename?: string;
  /**
   * Which rows the file contains.
   *
   * `"page"` (default) — current page / loaded slice.
   * `"all"` — full filtered+sorted set when the source exposes
   * {@link TableSource.allFilteredRows}; otherwise falls back to the
   * page with a dev-only warning.
   * `"selected"` — the checked rows, in table order. Selection is a set of
   * ids, so this searches the widest set the source can offer: a row selected
   * on page 1 is still exported while page 3 is on screen.
   * `"range"` — the highlighted cell rectangle, which needs `cellNavigation`;
   * a rectangle names its own columns, so it decides them and `columns` is not
   * consulted. Without a selection this falls back to the page with a dev-only
   * warning.
   */
  scope?: ExportRowScope;
  /**
   * Which columns the file contains.
   *
   * `"visible"` (default) — what the user can see, so the file matches the
   * screen. `"all"` — every defined column including those hidden through the
   * column menu, for a complete extract. An explicit array picks columns by
   * key, in the order given, and silently ignores a key that matches no
   * column so a stale saved config cannot break the button.
   *
   * The synthetic actions column is never exported under any of them.
   */
  columns?: ExportColumnScope;
  /**
   * Neutralise spreadsheet formula injection (see
   * {@link RowsToCsvOptions.escapeFormulas}). Disable ONLY for
   * machine-consumed output that is never opened in a spreadsheet.
   * @defaultValue true
   */
  escapeFormulas?: boolean;
  /**
   * Runs after the rows and columns are chosen and before the file is
   * written, which is the only moment where both are known and nothing has
   * happened yet.
   *
   * Return `false` to cancel the export — enough is known here to decide
   * (too many rows, nothing selected, a permission the host enforces).
   * Return `{ filename }` to name the file from the data, which is what most
   * callers want it for. Return nothing to continue unchanged.
   */
  onBeforeExport?: (info: ExportInfo<TRow>) => boolean | void | {
    filename?: string;
  };
  /**
   * Runs once the file has been handed to the browser, with what was written.
   * For analytics, a toast, or keeping a copy.
   *
   * `csv` is the file's text; a binary format leaves it empty and carries its
   * bytes in `file.parts`.
   */
  onAfterExport?: (info: ExportInfo<TRow> & {
    csv: string;
    file: ExportPayload;
  }) => void;
  /**
   * The file format. Defaults to CSV; `@adapttable/core/xlsx` exports
   * {@link ExportWriter | a spreadsheet writer}, and any function of the
   * resolved rows and columns is a valid one.
   *
   * The scope options above are unaffected by this — which rows and columns
   * leave the table is decided before a writer sees them.
   */
  writer?: ExportWriter;
  /**
   * Hand the export to your backend instead of building the file in the
   * browser.
   *
   * Past a certain size the browser is the wrong place to do this: the rows
   * are not all loaded, holding them would cost more memory than the tab has,
   * and the work blocks the main thread. With this set, the button sends the
   * user's current view — filters, search, sort, the chosen scope — to your
   * handler, and building the file (or queueing a job and emailing a link)
   * happens where the data already lives.
   *
   * The table builds no file and downloads nothing when this is present.
   * Return a promise and the button stays busy until it settles, so a second
   * click cannot start the same export twice.
   */
  request?: (info: ExportRequest<TRow>) => void | Promise<void>;
  /**
   * Let `scope: "all"` page a server source itself.
   *
   * A server-backed table holds one page, so "all" has nothing to read. The
   * first answer is {@link ExportCsvOptions.request} — the backend already has
   * the data. This is the second: opt in and the table walks the query page by
   * page and builds the file in the browser.
   *
   * It is opt-in because it is a loop of network requests the reader did not
   * ask for, and capped because an unbounded one over a large table is a way
   * to hang a tab. Past {@link FetchAllExport.maxRows} the export stops and
   * says so through {@link FetchAllExport.onCapped} rather than quietly
   * writing a partial file.
   */
  fetchAll?: FetchAllExport<TRow>;
}
/** How `scope: "all"` pages a server source when the host opts in. */
interface FetchAllExport<TRow> {
  /**
   * Fetch one page of the current query. Called with 1-based page numbers
   * until it returns fewer rows than `limit`, or the cap is reached.
   */
  fetchPage: (query: ExportQuery) => Promise<readonly TRow[]>;
  /** Rows per request. Defaults to the table's current page size. */
  pageSize?: number;
  /**
   * Stop after this many rows. Defaults to 50,000 — high enough that ordinary
   * tables never meet it, low enough that a runaway query cannot exhaust the
   * tab.
   */
  maxRows?: number;
  /**
   * Called when the cap stopped the export short, with what was written and
   * the cap that stopped it. Tell the reader; a silently truncated file is the
   * outcome this whole option exists to avoid.
   */
  onCapped?: (info: {
    rows: number;
    maxRows: number;
  }) => void;
}
/** The default {@link FetchAllExport.maxRows}. */
declare const EXPORT_FETCH_ALL_MAX_ROWS = 50000;
/**
 * Walk a server source page by page for `scope: "all"`.
 *
 * @typeParam TRow - The row type.
 * @param source - The table's source, for the current query and page size.
 * @param config - See {@link FetchAllExport}.
 * @returns Every row the query matches, up to the cap.
 */
declare function fetchAllExportRows<TRow>(source: TableSource<TRow>, config: FetchAllExport<TRow>): Promise<readonly TRow[]>;
/** The view an export was asked for, as a server needs to hear it. */
interface ExportRequest<TRow> extends ExportInfo<TRow> {
  /**
   * The query behind the current view: search, filters, sort and paging,
   * exactly as {@link TableQuery} carries them to a server tier.
   */
  query: ExportQuery;
  /** Which rows were asked for. `rows` holds what the browser has of them. */
  scope: ExportRowScope;
  /**
   * The file extension the button would have produced — `"csv"`, `"xlsx"`, or
   * whatever a custom writer names itself. A backend building the file needs to
   * know which one, and the filename alone is a guess.
   */
  format: string;
}
/** The view-defining half of a table query, for an export request. */
interface ExportQuery {
  /**
   * Undefined for `scope: "all"`: "all" means every row the filters match, so
   * a page number would contradict the ask. Present for every other scope.
   */
  page: number | undefined;
  /** Undefined for `scope: "all"` — see {@link ExportQuery.page}. */
  limit: number | undefined;
  search: string;
  sortBy: string | undefined;
  sortDir: SortDirection | undefined;
  filters: ExtraFilters;
  groupBy: string | undefined;
}
/** What an export lifecycle hook is told about the file being written. */
interface ExportInfo<TRow> {
  /** The rows the chosen scope resolved to, in table order. */
  rows: readonly TRow[];
  /** The columns the chosen scope resolved to, in file order. */
  columns: readonly ColumnDef<TRow>[];
  /** The filename as it stands, before any override this hook returns. */
  filename: string;
}
/** Boolean-or-options CSV export prop (off / on / configured). */
type ExportCsvProp<TRow = unknown> = boolean | ExportCsvOptions<TRow> | undefined;
/** Resolve a boolean-or-options prop into a concrete config, or `null` when off. */
declare function resolveExportCsv<TRow = unknown>(value: ExportCsvProp<TRow>): ExportCsvOptions<TRow> | null;
/** Columns that belong in a CSV (drop synthetic actions and reorder columns). */
declare function exportableColumns<TRow>(columns: readonly ColumnDef<TRow>[]): ColumnDef<TRow>[];
/**
 * Everything an export needs beyond the visible columns: the selection to
 * honour a `"selected"` scope, and the full column set to honour `"all"`.
 *
 * Every field is optional. A caller that passes none gets exactly the
 * behaviour this function always had.
 */
interface ExportContext<TRow> {
  /** The checked row ids. */
  selectedIds?: ReadonlySet<string>;
  /** How a row's id is derived — the table's own `getRowId`. */
  getRowId?: (row: TRow) => string;
  /** Every defined column, including any hidden through the column menu. */
  allColumns?: readonly ColumnDef<TRow>[];
  /** The highlighted cell rectangle, for `scope: "range"`. */
  range?: CellRange | null;
  /**
   * Where the rendered window starts in the dataset — the offset that turns a
   * range's absolute row addresses back into rows the browser holds. Zero
   * unless the table is paged.
   */
  firstRowIndex?: number;
  /** Omit covered cells from the file — a span exports its value once. */
  getCellSpan?: GetCellSpan<TRow>;
  /**
   * The grouping model's entries, when grouping is armed. A spreadsheet
   * writes headers, outline levels and footers from them. A range export
   * ignores this — a rectangle is already its own shape.
   */
  grouping?: {
    entries: readonly GroupedFlatEntry<TRow>[];
  };
  /**
   * The flattened tree, when a tree is armed. Outranks grouping, the same
   * way the table does.
   */
  tree?: {
    entries: readonly TreeEntry<TRow>[];
    /**
     * The same hierarchy with every node open. A folded folder is display
     * state, so `scope: "all"` writes what is inside it — without this, a
     * collapsed subtree is silently missing from the file.
     */
    allEntries?: readonly TreeEntry<TRow>[];
  };
  /** Caption for a group footer — the table's `labels.groupTotal`. */
  groupTotal?: (label: string) => string;
  /**
   * The table's `summaryRow` mapper. Called on the scoped rows so a grand
   * total in the file matches the rows that actually left.
   */
  summaryRow?: (rows: readonly TRow[]) => Partial<Record<string, ReactNode>>;
}
/** Pick the column set an export scope asks for, minus the actions column. */
declare function resolveExportColumns<TRow>(scope: ExportColumnScope | undefined, visible: readonly ColumnDef<TRow>[], all: readonly ColumnDef<TRow>[] | undefined): ColumnDef<TRow>[];
/**
 * Build CSV text for the chosen row and column scopes.
 *
 * @typeParam TRow - The row type.
 */
declare function buildTableCsv<TRow>(options: {
  source: TableSource<TRow>;
  columns: readonly ColumnDef<TRow>[];
  scope?: ExportRowScope;
  columnScope?: ExportColumnScope;
  escapeFormulas?: boolean;
  context?: ExportContext<TRow>;
}): string;
/**
 * Build + download a file for the current table view. CSV unless a `writer`
 * says otherwise.
 *
 * @typeParam TRow - The row type.
 */
declare function downloadTableCsv<TRow>(options: {
  source: TableSource<TRow>;
  columns: readonly ColumnDef<TRow>[];
  filename?: string;
  scope?: ExportRowScope;
  columnScope?: ExportColumnScope;
  escapeFormulas?: boolean;
  context?: ExportContext<TRow>;
  writer?: ExportWriter;
  onBeforeExport?: NonNullable<ExportCsvOptions<TRow>["onBeforeExport"]>;
  onAfterExport?: NonNullable<ExportCsvOptions<TRow>["onAfterExport"]>;
}): void;
/**
 * Resolve the `exportCsv` prop into a click handler, or `undefined` when off.
 * Adapters bind this to the toolbar Export button.
 *
 * @typeParam TRow - The row type.
 */
declare function makeExportCsvHandler<TRow>(exportCsv: boolean | ExportCsvOptions<TRow> | undefined, source: TableSource<TRow>, columns: readonly ColumnDef<TRow>[], context?: ExportContext<TRow>): (() => void | Promise<void>) | undefined;
//#endregion
//#region src/state/featureNotices.d.ts
/** Which opted-in feature is inert. */
type FeatureNoticeKind = "virtualize-paged" | "pin-nested" | "reorder-nested" | "grouping-unavailable" | "export-all-page" | "edit-without-writer";
/** How the table already looks to the person sitting at it. */
type FeatureNoticeAppearance = "off" | "disabled" | "one-page";
/** One inert feature, ready for a status slot or a root attribute. */
interface FeatureNotice {
  readonly kind: FeatureNoticeKind;
  readonly appearance: FeatureNoticeAppearance;
  readonly message: string;
}
//#endregion
//#region src/virtual/measureRowPair.d.ts
/** What a virtualizer must offer for a pair to be measurable. */
interface ResizableVirtualizer {
  /** Tell the virtualizer an item's real size. */
  resizeItem: (index: number, size: number) => void;
}
/** Ref callbacks for the two halves of one row. */
interface RowPairMeasurer {
  /** Ref for the row element itself. */
  row: (index: number) => (node: Element | null) => void;
  /** Ref for its detail element, when one is open. */
  detail: (index: number) => (node: Element | null) => void;
}
/**
 * Measure each row together with its open detail panel.
 *
 * Sizes are reported on every resize of either half, so a detail panel that
 * grows — an image loading, a nested table expanding — corrects the item's
 * height rather than leaving the scrollbar wrong until the next scroll.
 *
 * @param virtualizer - The virtualizer to report sizes to.
 * @param enabled - Off when nothing is virtualized or nothing can expand, in
 *   which case the returned refs do nothing at all.
 * @returns Ref callbacks for a row and its detail.
 */
declare function useRowPairMeasurer(virtualizer: ResizableVirtualizer | undefined, enabled: boolean): RowPairMeasurer;
//#endregion
//#region src/virtual/useTableVirtualization.d.ts
/** One row/card entry materialized from a virtual window. */
interface VirtualTableRow<TRow> {
  /** Row data for this visual slot. */
  row: TRow;
  /**
   * Index in the array the virtualizer windows. When pinning is on that is
   * the unpinned scroll list, not the page — use {@link rowSourceIndex}
   * for ARIA, focus and `rowClassName`.
   */
  index: number;
  /**
   * Index in the page's full row list. Equals {@link VirtualTableRow.index}
   * unless pinned rows were pulled out of the window.
   */
  sourceIndex?: number;
  /** Stable key resolved from the caller's rowKey. */
  key: string;
  /** Virtualizer item metadata; absent when virtualization is disabled. */
  virtualItem?: VirtualItem;
}
/** Dataset index for ARIA / focus — the window index when pinning is off. */
declare function rowSourceIndex(entry: Pick<VirtualTableRow<unknown>, "index" | "sourceIndex">): number;
/** Result consumed by adapters that opt into virtualized rendering. */
interface TableVirtualization<TRow> {
  /** Whether the returned rows represent a virtual window. */
  enabled: boolean;
  /** Rows to render: either every source row or only the virtual slice. */
  rows: readonly VirtualTableRow<TRow>[];
  /** Spacer before the rendered slice. */
  paddingTop: number;
  /** Spacer after the rendered slice. */
  paddingBottom: number;
  /** Element measurement callback for virtualized rows/cards. */
  measureElement?: (node: Element | null) => void;
  /**
   * Measure a row TOGETHER with its open detail panel.
   *
   * A table cannot nest a detail panel inside the row it belongs to, so the
   * two are separate elements and the virtualizer would size the item from the
   * row alone. These refs report the pair's real height instead — which is
   * what lets row detail and virtualization be used together at all.
   */
  measureRowPair?: RowPairMeasurer;
}
/** Options for {@link useTableVirtualization}. */
interface UseTableVirtualizationOptions<TRow> {
  /** Source rows from the table source. */
  rows: readonly TRow[];
  /** Stable row key resolver. */
  rowKey: (row: TRow) => string;
  /** Master switch; adapters keep this optional. */
  enabled?: boolean;
  /** Estimated row/card size in px, or a per-index reader. */
  estimateSize?: number | ((index: number) => number);
  /** Extra items rendered before/after the visible window. */
  overscan?: number;
  /** Window virtualizer scroll margin, usually sticky header height. */
  scrollMargin?: number;
  /**
   * Scroll container accessor. When provided, the virtual window tracks
   * THIS element's scrolling (a `maxHeight` box) instead of the page —
   * that's how `virtualize` + `maxHeight` compose.
   */
  getScrollElement?: () => Element | null;
  /** Called when the virtual window reaches the last source row. */
  onEndReached?: () => void;
  /**
   * Whether rows can expand. With detail panels in play the window measures
   * each row together with its panel; without them the extra observers would
   * be pure cost.
   */
  expandable?: boolean;
}
/** Resolve either virtual entries or the full source rows into render entries. */
declare function resolveVirtualRows<TRow>(rows: readonly TRow[], rowKey: (row: TRow) => string, rowEntries?: readonly VirtualTableRow<TRow>[]): readonly VirtualTableRow<TRow>[];
/**
 * Headless window virtualization for adapter tables. When disabled, it returns
 * every row and no spacer/measurement data, so adapters can use the same render
 * path for virtual and non-virtual tables.
 */
declare function useTableVirtualization<TRow>({
  rows,
  rowKey,
  enabled,
  estimateSize,
  overscan,
  scrollMargin,
  getScrollElement,
  onEndReached,
  expandable
}: UseTableVirtualizationOptions<TRow>): TableVirtualization<TRow>;
/** Result of {@link useKeyedVirtualization} — index window over a keyed list. */
interface KeyedVirtualization {
  enabled: boolean;
  /** Source indices in the virtual window (or every index when disabled). */
  indices: readonly number[];
  paddingTop: number;
  paddingBottom: number;
  measureElement?: (node: Element | null) => void;
}
/**
 * Virtualize an opaque keyed list (e.g. grouped flat entries). Same window /
 * element modes as {@link useTableVirtualization}.
 */
declare function useKeyedVirtualization(options: {
  keys: readonly string[];
  enabled?: boolean;
  estimateSize?: number | ((index: number) => number);
  overscan?: number;
  scrollMargin?: number;
  getScrollElement?: () => Element | null;
  onEndReached?: () => void;
}): KeyedVirtualization;
/** Slice a flat grouped model to the virtual window indices. */
declare function windowGroupedEntries<TEntry>(entries: readonly TEntry[], indices: readonly number[]): readonly TEntry[];
//#endregion
//#region src/rows/rowPinning.d.ts
/** Which edge a pinned row sticks to. */
type RowPinSide = "top" | "bottom";
/** Controlled pin lists — ids in dataset order within each edge. */
interface RowPinState {
  readonly top: readonly string[];
  readonly bottom: readonly string[];
}
/** Empty pin lists — omit `pinnedRowIds` and this is what the table holds. */
declare const EMPTY_ROW_PIN_STATE: RowPinState;
/** Synthesized "Pin to top" action. */
declare const PIN_TOP_ACTION_KEY = "adapttable:pin-row-top";
/** Synthesized "Pin to bottom" action. */
declare const PIN_BOTTOM_ACTION_KEY = "adapttable:pin-row-bottom";
/** Synthesized "Unpin" action. */
declare const UNPIN_ROW_ACTION_KEY = "adapttable:unpin-row";
/** Labels the pin actions and the live region need. */
interface RowPinLabels {
  pinToTop: string;
  pinToBottom: string;
  unpinRow: string;
}
/** Headless pin state adapters read. */
interface RowPinningState<TRow> {
  /** Current lists. */
  state: RowPinState;
  /** Which edge a row is pinned to, if any. */
  sideOf: (rowId: string) => RowPinSide | undefined;
  /** Pin a row to an edge (moves it if it was on the other). */
  pin: (rowId: string, side: RowPinSide) => void;
  /** Remove a row from both edges. */
  unpin: (rowId: string) => void;
  /** Pin actions, hidden per row so a top-pinned row does not offer Pin to top. */
  actions: readonly RowAction<TRow>[];
}
/** Split a row list into top pins, the scroll window, and bottom pins. */
declare function partitionPinnedRows<TRow>(rows: readonly TRow[], state: RowPinState, getRowId: (row: TRow) => string): {
  top: TRow[];
  scroll: TRow[];
  bottom: TRow[];
};
/** Memo digest so a virtualized row repaints when it is pinned or unpinned. */
declare function rowPinSignature(pinning: Pick<RowPinningState<unknown>, "sideOf"> | undefined, rowId: string): string | null;
/** Apply a pin or unpin to a copy of the state. */
declare function applyRowPin(state: RowPinState, rowId: string, side: RowPinSide | undefined): RowPinState;
/**
 * Headless row pinning. Inert until the host passes {@link UseRowPinningOptions.enabled};
 * omit the prop and this hook still runs (Rules of Hooks) but every action no-ops.
 */
declare function useRowPinning<TRow>(options: {
  enabled: boolean;
  pinnedRowIds?: RowPinState;
  onPinnedRowIdsChange?: (next: RowPinState) => void;
  getRowId: (row: TRow) => string;
  labels: RowPinLabels;
}): RowPinningState<TRow>;
//#endregion
//#region src/rows/pinnedRowChrome.d.ts
/** `data-adapttable-part` on a pinned row in the shared tbody. */
declare const PINNED_TOP_PART = "pinned-top";
/** Bottom pin marker on that row. */
declare const PINNED_BOTTOM_PART = "pinned-bottom";
/** Part name for a pinned row, or `undefined` when the row is not pinned. */
declare function pinnedRowPart(side: RowPinSide | undefined): typeof PINNED_TOP_PART | typeof PINNED_BOTTOM_PART | undefined;
/** Sticky style when the row is pinned and the kit asked for sticky pins. */
declare function pinnedRowSticky(side: RowPinSide | undefined, sticky: boolean, headerOffsetPx: number): ReturnType<typeof pinnedRowStickyStyle> | undefined;
/** Sticky style for a pinned-row section (tbody or the row itself). */
declare function pinnedRowStickyStyle(side: RowPinSide, headerOffsetPx: number): {
  position: "sticky";
  top?: number;
  bottom?: number;
  zIndex: number;
};
/**
 * Extra sticky inset a cell in a pinned row needs, and the z-index when
 * that cell is also a pinned column.
 */
declare function pinnedRowCellStyle(side: RowPinSide | undefined, headerOffsetPx: number, columnPinned: boolean): {
  position?: "sticky";
  top?: number;
  bottom?: number;
  zIndex?: number;
};
/** Measure an element's offset height; used for the sticky header offset. */
declare function useOffsetHeight(): [(node: HTMLElement | null) => void, number];
/**
 * Card list order: top pins, then the scroll window, then bottom pins.
 * Desktop sticky sections use the same three lists; cards are a list, so
 * this is the only "chrome" they get.
 */
declare function orderedCardEntries<TRow>(rows: readonly TRow[], getRowId: (row: TRow) => string, rowEntries: readonly VirtualTableRow<TRow>[] | undefined, pinnedTop: readonly TRow[], pinnedBottom: readonly TRow[]): readonly VirtualTableRow<TRow>[];
//#endregion
//#region src/grouping/groupKeys.d.ts
/**
 * The grouping keys, as a prop, as URL text, and as the list the model walks.
 *
 * Grouping travels as a comma-separated STRING — `?groupBy=team,status` — for
 * one reason: the URL and the source contract already carried a single key,
 * and a list that reads the same way keeps every link, saved view and
 * `source.setGroupBy` call ever written working. The array is what the model
 * and the adapters see; the string is what state is stored as.
 */
/** How the grouping keys are written down: one key, a list, or nothing. */
type GroupByInput = string | readonly string[] | null | undefined;
/**
 * The grouping keys as a list, in order.
 *
 * Blank entries are dropped rather than grouped on: `"team,"` is a trailing
 * comma, not a request to group by a column with no name.
 *
 * @param value - The prop, the source value, or the URL parameter.
 * @returns The keys, possibly empty.
 */
declare function parseGroupBy(value: GroupByInput): string[];
/**
 * The grouping keys as the single string state is stored as.
 *
 * @param value - The keys.
 * @returns The joined string, or `undefined` when nothing is grouped.
 */
declare function formatGroupBy(value: GroupByInput): string | undefined;
//#endregion
//#region src/grouping/useGroupCollapse.d.ts
/** Collapse state + actions returned by {@link useGroupCollapse}. */
interface GroupCollapseState {
  /** Ids of currently collapsed groups (`group:…` keys). */
  collapsedGroupIds: ReadonlySet<string>;
  /** Whether a group is collapsed. */
  isCollapsed: (groupKey: string) => boolean;
  /** Toggle a group's collapsed state. */
  toggle: (groupKey: string) => void;
  /** Expand every group (clear the collapsed set). */
  expandAll: () => void;
  /** Collapse every group in `groupKeys`. */
  collapseAll: (groupKeys: readonly string[]) => void;
  /**
   * Show the tree down to `depth` and no further: every group at that depth or
   * deeper closes, everything above it opens. Depth 0 collapses the top level,
   * so only the outermost headers show.
   */
  collapseToDepth: (depth: number, groups: readonly {
    key: string;
    level: number;
  }[]) => void;
}
/**
 * Headless collapse state for single-level row groups. Ephemeral — not
 * URL-synced (punch-list #62). Groups default to expanded (empty set).
 */
declare function useGroupCollapse(controlled?: {
  collapsedGroupIds?: readonly string[];
  onCollapsedGroupIdsChange?: (ids: string[]) => void;
}): GroupCollapseState;
//#endregion
//#region src/rows/mobileCard.d.ts
/** One field on a mobile card. */
interface MobileCardField<TRow> {
  /** The column it came from. */
  column: ColumnDef<TRow>;
  /**
   * The label the built-in card would show — the column's `mobileLabel`, its
   * string header, or its key. `undefined` when the column asked for none
   * (`mobileLabel: ""`), which is how a bare avatar or title line avoids a
   * caption reading "Avatar".
   */
  label: string | undefined;
  /**
   * The value, rendered exactly as the built-in card renders it: the column's
   * `Cell` or accessor, wrapped in the cell editor when editing is armed.
   */
  value: ReactNode;
}
/** What {@link MobileCardRenderer} is given. */
interface MobileCardModel<TRow> {
  /** The card's place in the rendered window. */
  index: number;
  /** The fields the built-in card would have laid out, in order. */
  fields: readonly MobileCardField<TRow>[];
  /** Whether this row is selected. */
  selected: boolean;
  /** Whether this row's detail panel is open. */
  expanded: boolean;
}
/**
 * Replace a mobile card's body.
 *
 * @typeParam TRow - The row type.
 * @returns The card's content, rendered inside the shell the table owns.
 */
type MobileCardRenderer<TRow> = (row: TRow, card: MobileCardModel<TRow>) => ReactNode;
//#endregion
//#region src/rows/rowActions.d.ts
/** How the trailing actions column renders. Omit / `"buttons"` is today's strip. */
type RowActionsLayout = "buttons" | "menu";
/**
 * Inputs a host `renderRowActions` receives. `actions` is the resolved list
 * (host entries plus built-in duplicate / delete / pin) — hidden ones are
 * still present so a custom cell can decide; the default layouts skip them.
 */
interface RowActionsRenderContext<TRow> {
  row: TRow;
  actions: readonly RowAction<TRow>[];
  confirm: ConfirmHandler;
  labels: Required<TableLabels>;
}
/** Host override for the trailing actions cell (desktop and mobile cards). */
type RowActionsRenderer<TRow> = (ctx: RowActionsRenderContext<TRow>) => ReactNode;
/**
 * Actions that should render for this row. `isHidden` returning true drops
 * the entry; everything else stays, including disabled ones.
 *
 * @typeParam TRow - The row type.
 */
declare function visibleRowActions<TRow>(actions: readonly RowAction<TRow>[], row: TRow): RowAction<TRow>[];
//#endregion
//#region src/rows/rowReorder.d.ts
/** MIME type carrying the dragged row id during a reorder drag. */
declare const ROW_DND_MIME = "application/x-adapttable-row";
/** Width (px) of the injected reorder column — shared so pin leads agree. */
declare const REORDER_COLUMN_WIDTH = 40;
/**
 * Dim the lifted row and draw an insertion line on the drop target.
 * Kits apply this so a host without CSS still sees the gesture; unstyled
 * hosts can also target `data-dragging` / `data-drop` from classNames.
 */
declare function rowReorderDropStyle(attrs: {
  "data-dragging"?: "";
  "data-drop"?: "before" | "after";
} | undefined): CSSProperties;
/** Move `from` to `to` in a copy of `rows`. Out-of-range is a no-op copy. */
declare function applyRowReorder<T>(rows: readonly T[], from: number, to: number): T[];
/** Dataset-relative index: the rendered slot plus the page/window offset. */
declare function datasetIndex(localIndex: number, windowStart: number): number;
/** What a host receives when the reader drops a row. */
type RowReorderHandler<TRow> = (from: number, to: number, row: TRow) => void;
/** Labels the reorder handle and the live region need. */
interface RowReorderLabels {
  reorderRow: string;
  moveRowUp: string;
  moveRowDown: string;
  rowLifted: (position: number) => string;
  rowMoved: (from: number, to: number) => string;
  rowReorderCancelled: string;
}
/** Headless reorder state returned by {@link useRowReorder}. */
interface RowReorderState<TRow> {
  /** The lifted row, or `null` when idle. */
  lifted: {
    rowId: string;
    from: number;
  } | null;
  /** Hovered drop index (local), or `null`. */
  overIndex: number | null;
  /** Live-region text. Empty until something happens. */
  announcement: string;
  /** Whether this row is the one being moved. */
  isLifted: (rowId: string) => boolean;
  /** Pointer: start a drag from this row. */
  dragProps: (rowId: string, localIndex: number) => {
    draggable: true;
    onDragStart: (event: DragEvent<HTMLElement>) => void;
    onDragEnd: () => void;
  };
  /** Pointer: this row is a drop target. */
  dropProps: (localIndex: number, row: TRow, windowStart: number) => {
    onDragOver: (event: DragEvent<HTMLElement>) => void;
    onDrop: (event: DragEvent<HTMLElement>) => void;
  };
  /** Keyboard: Space lifts / drops, arrows move, Escape cancels. */
  handleKeyDown: (event: KeyboardEvent<HTMLElement>, rowId: string, localIndex: number, row: TRow, windowStart: number, rowCount: number) => void;
  /** Mobile: swap with the neighbour. */
  moveBy: (localIndex: number, delta: -1 | 1, row: TRow, windowStart: number, rowCount: number) => void;
  /** Indicator attributes for a row. */
  rowAttrs: (rowId: string, localIndex: number) => {
    "data-dragging"?: "";
    "data-drop"?: "before" | "after";
  };
}
/**
 * Per-row digest so a memoized row repaints when IT is lifted or is the drop
 * target, and bails out when the drag is happening to someone else.
 */
declare function rowReorderSignature<TRow>(reorder: RowReorderState<TRow> | undefined, rowId: string, localIndex: number): string | null;
/**
 * Headless row reorder. Inert until the host passes {@link RowReorderHandler};
 * omit it and this hook still runs (Rules of Hooks) but every builder no-ops.
 */
declare function useRowReorder<TRow>(options: {
  enabled: boolean;
  onRowReorder?: RowReorderHandler<TRow>;
  labels: RowReorderLabels; /** Look up a row in the current source by its rendered index. */
  rowAt: (localIndex: number) => TRow | undefined;
}): RowReorderState<TRow>;
//#endregion
//#region src/rows/useRowExpansion.d.ts
/** Expansion state + actions returned by {@link useRowExpansion}. */
interface RowExpansionState {
  /** Ids of the currently expanded rows. */
  expandedIds: ReadonlySet<string>;
  /** Whether a row is expanded. */
  isExpanded: (id: string) => boolean;
  /** Toggle a row's detail panel. */
  toggle: (id: string) => void;
}
/**
 * Headless row-expansion state for `renderRowDetail`: multiple rows may be
 * open at once, keyed by row id so expansion survives sorting and paging
 * (a row that leaves the page simply re-opens when it returns).
 *
 * @param defaultExpandedIds - Row ids whose panel starts open.
 */
declare function useRowExpansion(defaultExpandedIds?: readonly string[]): RowExpansionState;
//#endregion
//#region src/tree/useTreeExpansion.d.ts
/** Tree expansion state and the actions that change it. */
interface TreeExpansionState {
  /** Ids of the currently expanded nodes. */
  expandedIds: ReadonlySet<string>;
  /** Whether a node is expanded. */
  isExpanded: (id: string) => boolean;
  /** Open or close one node. */
  toggle: (id: string) => void;
  /** Open a specific node — what "reveal this row" needs. */
  expand: (id: string) => void;
  /** Open every node in `ids`. */
  expandAll: (ids: readonly string[]) => void;
  /** Fold everything. */
  collapseAll: () => void;
}
/**
 * Headless expansion state for a tree.
 *
 * @param controlled - The host's pair, when it holds the state.
 * @returns The state; uncontrolled unless `expandedIds` is given.
 */
declare function useTreeExpansion(controlled?: {
  expandedIds?: readonly string[];
  onExpandedIdsChange?: (ids: string[]) => void;
}): TreeExpansionState;
//#endregion
//#region src/pagination/paginationMath.d.ts
/** Derived pagination figures for a paged view. */
interface PaginationInfo {
  /** Total number of pages (always ≥ 1). */
  totalPages: number;
  /** The page clamped into `[1, totalPages]`. */
  safePage: number;
  /** 1-based index of the first row on the page (0 when empty). */
  fromIndex: number;
  /** 1-based index of the last row on the page (0 when empty). */
  toIndex: number;
}
/**
 * Compute page count and the visible "from–to" range for a paged view.
 *
 * @param input - Current `page`, `limit`, and `total`.
 * @returns The derived {@link PaginationInfo}.
 */
declare function computePagination(input: {
  page: number;
  limit: number;
  total: number;
}): PaginationInfo;
/** One slot in a numbered pager: a page number, or a gap where pages were elided. */
type PaginationItem = number | "ellipsis";
/**
 * A pager slot paired with a stable React key — page numbers key on themselves,
 * ellipses on their semantic side (`ellipsis-left` / `ellipsis-right`). Use this
 * instead of indexing into {@link paginationItems} so list keys never depend on
 * the array position.
 */
interface PaginationSlot {
  /** The page number or `"ellipsis"` marker. */
  item: PaginationItem;
  /** A stable, position-free React key for this slot. */
  key: string;
}
/**
 * Build the keyed pager slots (see {@link PaginationSlot}) for a numbered pager.
 * Wraps {@link paginationItems}, assigning each ellipsis a `left`/`right` side
 * key in encounter order — at most two ellipses ever appear, so the side is a
 * stable identity that does not rely on the array index.
 *
 * @param page - The current (1-based) page.
 * @param totalPages - Total page count (coerced to ≥ 1).
 * @param siblings - Pages to show on each side of the current page.
 * @returns Keyed pager slots.
 */
declare function paginationSlots(page: number, totalPages: number, siblings?: number): PaginationSlot[];
/**
 * Build the page-number sequence for a numbered pager — the first and last
 * (boundary) pages, the current page with `siblings` neighbours on each side,
 * and an `"ellipsis"` marker wherever a run of pages is elided. Mirrors the
 * `boundaries: 1` / `siblings: 1` defaults of the kit `<Pagination>` widgets so
 * every adapter — including the hand-rendered unstyled and Chakra pagers — lays
 * pages out identically.
 *
 * @param page - The current (1-based) page.
 * @param totalPages - Total page count (coerced to ≥ 1).
 * @param siblings - Pages to show on each side of the current page.
 * @returns Ordered page numbers interleaved with `"ellipsis"` gaps.
 */
declare function paginationItems(page: number, totalPages: number, siblings?: number): PaginationItem[];
//#endregion
//#region src/utils/mergeProps.d.ts
/**
 * Any props object a prop-getter can produce or accept for merging.
 *
 * @internal — prop-getter plumbing. Consumers use the prop-getters from
 * `useDataTable`, not this merge helper directly.
 */
type Props = Record<string, unknown>;
/**
 * Merge a prop-getter's own props with caller overrides (the
 * Downshift/Radix pattern). Event handlers (`onX`) are composed so both
 * run; `className` strings are concatenated; `style` objects are merged.
 * Everything else is overridden by the caller's value.
 *
 * @param base - The prop-getter's own props.
 * @param overrides - Optional caller-supplied props to merge on top.
 * @returns The merged props object.
 *
 * @internal — prop-getter plumbing. Consumers use the prop-getters from
 * `useDataTable`, not this merge helper directly.
 */
declare function mergeProps<T extends Props>(base: T, overrides?: Props): T;
//#endregion
//#region src/labels.d.ts
/**
 * English default strings. Consumers override any subset via the
 * `labels` option; {@link resolveLabels} merges their overrides on top.
 */
declare const defaultLabels: Required<TableLabels>;
/**
 * Merge caller overrides over {@link defaultLabels}. Undefined entries in
 * the override are ignored, so partial `labels` objects are safe.
 *
 * @param overrides - A partial set of label overrides.
 * @returns A fully-populated, immutable label set.
 */
declare function resolveLabels(overrides: TableLabels | undefined): Required<TableLabels>;
//#endregion
//#region src/useDataTable/useDataTable.d.ts
/** Options for {@link useDataTable}. */
interface UseDataTableOptions<TRow> {
  /** The data + state contract, from `useFrontendData` / `useQuerySource`. */
  source: TableSource<TRow>;
  /** Column definitions. */
  columns: ColumnDef<TRow>[];
  /**
   * Make the columns share the container's width instead of overflowing it.
   * Columns with `flex` take that share; columns with a `width` keep it.
   */
  fitColumns?: boolean;
  /** User widths from the column layout, which win over everything else. */
  columnWidths?: Readonly<Record<string, number>>;
  /** Stable React key extractor for a row. */
  rowKey: (row: TRow) => string;
  /** Accessible label for the table element. */
  tableLabel?: string;
  /** Pre-translated label overrides (merged over English defaults). */
  labels?: TableLabels;
  /** Text direction. Defaults to `"ltr"`. */
  dir?: Direction;
  /** Render the mobile (card) layout. Defaults to `false`. */
  forceMobile?: boolean;
  /**
   * Active locale — drives per-column `i18n` data-path resolution for
   * bare-key columns, exactly as it does under `<DataTable>`.
   */
  locale?: string;
  /** Number of leading desktop-visible columns always shown on mobile cards. */
  mobileIdentityColumns?: number;
  /** Search debounce in ms. Defaults to 300. */
  searchDebounceMs?: number;
  /** Bulk actions — enabling these turns on selection. */
  bulkActions?: BulkAction[];
  /** Selection id extractor; defaults to `rowKey` when bulk actions exist. */
  selectionGetId?: (row: TRow) => string;
  /** Controlled selection value (see {@link BaseDataTableProps.selectedIds}). */
  selectedIds?: readonly string[];
  /** Change handler for the controlled selection. */
  onSelectedIdsChange?: (selectedIds: string[]) => void;
  /** Per-filter-key chip label resolvers (drives the chip strip). */
  filterLabels?: Readonly<Record<string, ChipLabelResolver>>;
  /** Enable shift-click multi-column sorting (see BaseDataTableProps). */
  multiSort?: boolean;
}
/** Everything a headless consumer needs to render a table. */
interface UseDataTableResult<TRow> {
  /** The materialised rows for the current slice. */
  rows: readonly TRow[];
  /** Whether there are no rows and nothing is loading. */
  isEmpty: boolean;
  /** Columns visible for the current layout. */
  columns: ColumnDef<TRow>[];
  /** Whether the mobile (card) layout is active. */
  isMobile: boolean;
  /**
   * Sort-by select options auto-derived from the sortable columns. Adapters
   * render these as the mobile sort affordance (no clickable headers there)
   * when the caller passes no explicit `sortByOptions`.
   */
  sortByOptions: SortByOption[];
  /** Resolved labels (English defaults + overrides). */
  labels: Required<TableLabels>;
  /** Text direction. */
  dir: Direction;
  /** Derived pagination figures. */
  pagination: PaginationInfo;
  /** Active sort column key. */
  sortBy: string | undefined;
  /** Active sort direction. */
  sortDir: SortDirection | undefined;
  /** Advance the sort cycle for a column. */
  toggleSort: (key: string) => void;
  /** The controlled search input value. */
  searchValue: string;
  /** Update the search input value. */
  setSearchValue: (next: string) => void;
  /** Selection state, or `null` when no bulk actions are configured. */
  selection: SelectionState | null;
  /** Removable filter chips derived from `filterLabels` + the source. */
  filterChips: ActiveFilterChip[];
  /** Number of active filter chips (drives the Filters badge). */
  activeFilterCount: number;
  /** The underlying source (for pagination setters, fetchNextPage, etc.). */
  source: TableSource<TRow>;
  getTableProps: (props?: Props) => TableElementProps;
  getHeaderRowProps: (props?: Props) => Props;
  getHeaderCellProps: (column: ColumnDef<TRow>, props?: Props) => CellElementProps;
  getSortButtonProps: (column: ColumnDef<TRow>, props?: Props) => SortButtonElementProps;
  getRowProps: (row: TRow, index: number, props?: Props) => RowElementProps;
  getCellProps: (column: ColumnDef<TRow>, props?: Props) => CellElementProps;
  getSearchInputProps: (props?: Props) => SearchInputElementProps;
  /**
   * The row's stable React key. Kept OUT of {@link getRowProps} so its
   * result spreads clean — React forbids spreading a `key`.
   */
  getRowKey: (row: TRow) => string;
  /**
   * A cell's rendered content: the column's `Cell` component when set,
   * else its (resolved) `accessor` value — no optional chaining needed.
   */
  getCellContent: (column: ColumnDef<TRow>, row: TRow, rowIndex: number) => ReactNode;
}
/** Props from {@link UseDataTableResult.getTableProps}. */
interface TableElementProps extends Props {
  role: string;
  dir?: Direction;
  "aria-label": string;
}
/**
 * Props from {@link UseDataTableResult.getRowProps}. Spread-clean by
 * contract: never contains `key` — read {@link UseDataTableResult.getRowKey}
 * for the React key.
 */
interface RowElementProps extends Props {
  role: string;
  /** The structural part name every kit's body row carries. */
  "data-adapttable-part": "row";
  /** The row's id, so an event can be traced back to the row it happened in. */
  "data-row-id": string;
  "data-index": number;
  "aria-selected"?: boolean;
}
/** Props from {@link UseDataTableResult.getSortButtonProps}. */
interface SortButtonElementProps extends Props {
  type: "button";
  disabled: boolean;
  onClick: (event?: {
    shiftKey?: boolean;
  }) => void;
  "data-sort-index"?: number;
  "aria-label": string;
}
/** Props from {@link UseDataTableResult.getCellProps} / `getHeaderCellProps`. */
interface CellElementProps extends Props {
  role: string;
  style?: CSSProperties;
  "data-sort-index"?: number;
}
/** Props from {@link UseDataTableResult.getSearchInputProps}. */
interface SearchInputElementProps extends Props {
  type: string;
  role: string;
  value: string;
  placeholder: string;
  "aria-label": string;
  onChange: (event: {
    currentTarget: {
      value: string;
    };
  }) => void;
}
/**
 * The headless entry point. Combines a {@link TableSource} with columns,
 * sorting, a debounced search input, selection, and filter chips, and
 * returns derived state plus accessible prop-getters so consumers can
 * render any markup with any UI kit.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseDataTableOptions}.
 * @returns Derived state and prop-getters — see {@link UseDataTableResult}.
 */
declare function useDataTable<TRow>(options: UseDataTableOptions<TRow>): UseDataTableResult<TRow>;
//#endregion
//#region src/layout/SidePanelChrome.d.ts
/** One panel in the side panel's strip. */
interface SidePanelEntry {
  /** Stable identity, used for the open-panel state and the URL. */
  key: string;
  /** The tab's caption, already localized. */
  label: string;
  /** What the panel shows when it is the selected one. */
  content: ReactNode;
}
/** Props an adapter's panel frame receives. */
interface SidePanelFrameProps {
  /** The tab strip and the panel body, in order. */
  readonly children: ReactNode;
  /** Which edge the panel is docked to, already resolved for direction. */
  readonly side: "start" | "end";
  readonly className?: string;
}
/** Props an adapter's tab button receives. */
interface SidePanelTabProps {
  readonly panel: SidePanelEntry;
  readonly selected: boolean;
  /** Spread onto the button: role, tabindex, aria wiring, id and keys. */
  readonly buttonProps: {
    readonly id: string;
    readonly role: "tab";
    readonly type: "button";
    readonly tabIndex: number;
    readonly "aria-selected": boolean;
    readonly "aria-controls": string;
    readonly "data-adapttable-part": "side-panel-tab";
    readonly onClick: () => void;
    readonly onKeyDown: (event: KeyboardEvent<HTMLElement>) => void;
  };
}
/** Props an adapter's close control receives. */
interface SidePanelCloseProps {
  readonly label: string;
  readonly onClose: () => void;
}
/** Adapter-owned rendering for {@link SidePanelChrome}. */
interface SidePanelSlots {
  /** The docked frame around everything. */
  readonly Frame: (props: SidePanelFrameProps) => ReactNode;
  /** One tab in the strip. Omitted when there is only one panel. */
  readonly Tab: (props: SidePanelTabProps) => ReactNode;
  /** The control that closes the panel. */
  readonly Close: (props: SidePanelCloseProps) => ReactNode;
}
/** What the side panel needs to render. */
interface SidePanelChromeProps {
  /** The panels, in tab order. Rendering nothing when empty. */
  panels: readonly SidePanelEntry[];
  /** Which panel is showing. */
  openPanel: string;
  /** Show a different panel. */
  onOpenPanel: (key: string) => void;
  /** Close the panel entirely. */
  onClose: () => void;
  /** Which edge to dock to. Defaults to `"end"`. */
  side?: "start" | "end";
  /** Labels; falls back to the built-in English. */
  labels?: TableLabels;
  /** A unique id root, so two tables on a page do not collide. */
  idPrefix?: string;
  /** A kit's own class for the frame. */
  className?: string;
  /** Adapter-owned visible components. */
  slots: SidePanelSlots;
}
/**
 * Renders the side panel, or nothing when there are no panels to show.
 *
 * @param props - The panels, which one is open, and the kit's slots.
 * @returns The docked panel.
 */
declare function SidePanelChrome(props: Readonly<SidePanelChromeProps>): import("react").JSX.Element | null;
/** What {@link SidePanelLayout} arranges. */
interface SidePanelLayoutProps {
  /** The table itself — everything the panel sits beside. */
  body: ReactNode;
  /** The rendered side panel, or nothing when none is open. */
  panel?: ReactNode;
  /** Which edge the panel is docked to. Defaults to `"end"`. */
  side?: "start" | "end";
}
/**
 * Put the table and its panel side by side.
 *
 * This is structure, not appearance — a flex row and a `min-width: 0` so the
 * table can still scroll horizontally inside it — which is why it lives in
 * core rather than in eight copies. Without a panel it renders the body
 * alone and adds no element at all, so a table that never asks for one has
 * exactly the DOM it always had.
 *
 * It exists as a component rather than as a ternary in each adapter for a
 * reason worth stating: the same "if the host asked for it, wrap; otherwise
 * do not" shape written eight times is eight chances to differ, and one
 * kit's copy already tripped a complexity limit when the status bar took
 * that form.
 *
 * @param props - The body, the panel, and which side it docks to.
 * @returns The arranged region.
 */
declare function SidePanelLayout(props: Readonly<SidePanelLayoutProps>): import("react").JSX.Element;
//#endregion
//#region src/layout/useFullscreen.d.ts
/** What {@link useFullscreen} returns. */
interface FullscreenState {
  /** Whether the table is the fullscreen element right now. */
  active: boolean;
  /** Whether the browser will allow it at all. */
  supported: boolean;
  /** Go fullscreen, or leave. */
  toggle: () => void;
  /** Leave, if it is on. */
  exit: () => void;
  /**
   * Where overlays must portal while fullscreen is on, and `undefined`
   * otherwise. Hand this to each kit's portal target — Mantine's
   * `portalProps`, MUI's `container`, antd's `getPopupContainer` — or the
   * kit's menus will render into a document nobody can see.
   */
  container: HTMLElement | undefined;
}
/**
 * Promote a table to fullscreen, and say where overlays should go.
 *
 * @param element - The table's root. Nothing happens without one.
 * @returns The state, the toggle, and the portal container.
 */
declare function useFullscreen(element: HTMLElement | null): FullscreenState;
//#endregion
//#region src/url/useTableUrlState.d.ts
/** Options for {@link useTableUrlState}. */
interface UseTableUrlStateOptions {
  /**
   * URL-state backend. Defaults to the browser History API. Supply a
   * router-specific adapter (react-router / Next.js) to integrate with an
   * existing navigation stack.
   */
  urlAdapter?: UrlStateAdapter;
  /**
   * When `false`, state is kept in a component-local memory store instead
   * of the URL — the table still works fully, it just isn't shareable.
   * Defaults to `true`.
   */
  urlSync?: boolean;
  /** Initial values applied when the URL has no value for a key. */
  defaults?: Partial<TableQueryParams> & {
    extra?: ExtraFilters;
  };
  /** Extra-filter keys whose values are parsed as numbers. */
  numberExtraKeys?: readonly string[];
  /** Extra-filter keys whose values are comma-separated arrays. */
  arrayExtraKeys?: readonly string[];
  /**
   * Namespace for this table's URL params, so multiple tables can share one
   * URL without colliding. With `urlKey="left"` the params become
   * `left.q`, `left.page`, `left.f_status`, … Omit for the bare keys.
   */
  urlKey?: string;
}
/** State + setters returned by {@link useTableUrlState}. */
interface UseTableUrlStateResult extends TableStateMutators {
  /** Current 1-based page. */
  page: number;
  /** Current page size. */
  limit: number;
  /**
   * Page size applied when the URL has no `limit` param (`defaults.limit`,
   * or 25). Stable across `setLimit` so the rows-per-page list can keep it.
   */
  defaultLimit: number;
  /** Current committed search term. */
  search: string;
  /** Active sort column key, if any. */
  sortBy: string | undefined;
  /** Active sort direction, if any. */
  sortDir: SortDirection | undefined;
  /** Active single-level row-grouping column key, if any. */
  groupBy: string | undefined;
  /** The extra-filter bag. */
  extra: ExtraFilters;
  /** Nested AND/OR filter tree, when one is in the URL. */
  filterTree: QueryFilterGroup | undefined;
}
/**
 * Headless URL-synced table state. Keeps page / limit / search / sort and
 * an arbitrary `extra` filter bag in the query string (or a local store
 * when disabled), so reloads, shared links, and back/forward all restore
 * the exact slice. Decoupled from any router via {@link UrlStateAdapter}.
 *
 * `defaults` apply only while the URL is silent about a key. When the user
 * explicitly clears a defaulted value (clearing the search, removing a
 * filter chip, clear-all), the hook records the clearing as an EMPTY-valued
 * param (`q=`, `sortBy=`, `f_status=`) so the default does not instantly
 * resurrect. Without a default for the key the param is simply deleted, so
 * URLs stay clean in the common case.
 *
 * @param options - See {@link UseTableUrlStateOptions}.
 * @returns The current state and its setters.
 */
declare function useTableUrlState(options?: UseTableUrlStateOptions): UseTableUrlStateResult;
//#endregion
//#region src/source/useServerData.d.ts
/**
 * One consolidated snapshot of everything a server query needs.
 *
 * The fields below the baseline come from {@link QueryExtensions} and are all
 * optional: a source receives one only after declaring it can answer it
 * (`supports`), so an endpoint written before a capability existed keeps
 * receiving exactly the query it was written against.
 */
interface TableQuery extends QueryExtensions {
  /** 1-based page. */
  page: number;
  /** Page size. */
  limit: number;
  /** Committed (debounced) search term. */
  search: string;
  /** Active sort column key, if any. */
  sortBy: string | undefined;
  /** Active sort direction, if any. */
  sortDir: SortDirection | undefined;
  /** The multi-sort chain (empty unless multi-sort is in use). */
  sortLevels: readonly SortLevel[];
  /** The active filter values. */
  filters: ExtraFilters;
}
/** Options for {@link useServerData}. */
interface UseServerDataOptions<TRow> extends Pick<UseTableUrlStateOptions, "urlAdapter" | "urlSync" | "defaults" | "numberExtraKeys" | "arrayExtraKeys" | "urlKey"> {
  /** The current page of rows, exactly as the server returned them. */
  rows: readonly TRow[];
  /** Total row count across all pages (drives the pager). */
  total: number;
  /**
   * Cursor pagination: the token the last response returned for the page
   * after the one on screen, or `null` when that was the last page.
   *
   * Only read when the source declares `supports.cursor`. With it, position
   * comes from the token rather than an offset, so rows that shift while the
   * user reads never duplicate or skip an entry — the failure mode
   * offset-based paging cannot avoid.
   *
   * A cursor is opaque, so the table only ever hands back one the server
   * gave it. That makes "next" always possible, "back" possible for pages
   * already visited, and a jump to an arbitrary unvisited page impossible —
   * the honest shape of cursor pagination, not a limitation to work around.
   */
  nextCursor?: string | null;
  /** Whether a request is currently in flight. */
  loading?: boolean;
  /** Forwarded error to display. */
  error?: Error | null;
  /** Pagination mode. Defaults to `"auto"` (mobile → infinite). */
  paginationMode?: PaginationMode;
  /** Force the resolved mobile state instead of a media query (test/SSR seam). */
  forceMobile?: boolean;
  /**
   * What this endpoint can answer beyond the baseline query. Declare a
   * capability and the matching field starts arriving in `onQueryChange`;
   * leave it out and the field is never sent, with a development warning if
   * the UI wanted it. See {@link QuerySupport}.
   */
  supports?: QuerySupport;
  /**
   * The tree nodes the reader has open, when the hierarchy lives on the server.
   * Sent as `query.expandedIds` only if the source declares
   * `supports: { tree: true }`, so the response can carry the children of every
   * open branch alongside the page. Hold the same array in the table's
   * `expandedIds` and one piece of state drives both.
   */
  expandedIds?: readonly string[];
  /**
   * Filter keys to ask the server for distinct-value counts. Sent as
   * `query.facets` only when `supports.facets` is set.
   */
  facetKeys?: readonly string[];
  /**
   * Distinct-value counts from the last fetch. Surfaces on the source
   * so a checklist can render without holding the full result set.
   */
  facets?: FacetMap;
  /**
   * Fired with the consolidated {@link TableQuery} whenever it changes —
   * including once on mount with the URL-restored values. The previous
   * call's `signal` is aborted when a newer query supersedes it; forward it
   * to `fetch` and out-of-order responses die at the source.
   */
  onQueryChange?: (query: TableQuery, info: {
    signal: AbortSignal;
  }) => void | Promise<void>;
}
/**
 * The hand-rolled-fetch server tier: the table owns the query state (URL,
 * widgets, chips, debounce) and emits ONE consolidated event per real
 * change; the caller's only job is to run the request and hand back
 * `rows` + `total`. No query library required — and the full
 * `useQuerySource` tier remains for callers who want one.
 *
 * Implements the shared source contract: `isLoading` covers the first
 * load only, `isFetching` any in-flight request, and in infinite mode
 * `fetchNextPage` APPENDS the next page's rows to those on screen
 * (accumulating across `onQueryChange` round-trips) instead of replacing
 * them.
 *
 * @typeParam TRow - The row type.
 */
declare function useServerData<TRow>(options: UseServerDataOptions<TRow>): TableSource<TRow>;
//#endregion
//#region src/source/useTableData.d.ts
/** Options for {@link useTableData}. */
interface UseTableDataOptions<TRow> extends Pick<UseTableUrlStateOptions, "urlAdapter" | "urlSync" | "defaults" | "urlKey"> {
  /** Full-control tier: a prebuilt source (e.g. `useQuerySource`). */
  source?: TableSource<TRow>;
  /** Frontend tier: the raw rows; the table filters/sorts/pages them. */
  data?: readonly TRow[];
  /** Server tier: total row count across all pages. */
  total?: number;
  /** Server tier: request in flight. */
  loading?: boolean;
  /** Forwarded error. */
  error?: Error | null;
  /**
   * Explicit data mode. `"server"` makes `onQueryChange` the data
   * contract (the caller fetches); `"frontend"` keeps the table's own
   * data processing and turns `onQueryChange` into a pure notification.
   * Absent, the tier is inferred exactly as before: `data` alone →
   * frontend; `data` + `onQueryChange` → server; `source` → source tier.
   */
  mode?: "frontend" | "server";
  /** Server tier: see {@link UseServerDataOptions.onQueryChange}. */
  onQueryChange?: NonNullable<Parameters<typeof useServerData<TRow>>[0]["onQueryChange"]>;
  /** Columns — their `filter` shorthands feed the runtime. */
  columns: readonly ColumnDef<TRow>[];
  /** Table-level filters: declarative array, or JSX for a hand-drawn form. */
  filters?: readonly FilterDef<TRow>[] | ReactNode;
  /**
   * Extra or replacement filter types merged onto the built-in registry.
   * A spec whose `type` matches a built-in replaces it.
   */
  filterTypes?: readonly FilterTypeSpec[];
  /** Extra client-side predicate AND-ed with the declarative ones. */
  filterFn?: (row: TRow, extra: ExtraFilters) => boolean;
  /** Frontend tier: pagination mode (defaults to `"auto"`). */
  paginationMode?: PaginationMode;
  /** Frontend tier: searchable-text projector. */
  getSearchText?: (row: TRow) => string;
  /** Frontend tier: sort-value resolver. */
  getSortValue?: (row: TRow, columnKey: string) => SortableValue;
  /** Active locale — drives per-column `i18n` path resolution. */
  locale?: string;
  /**
   * Server tier: what this endpoint can answer. `supports.facets`
   * unlocks `query.facets` (checklist keys, or {@link facetKeys}).
   */
  supports?: QuerySupport;
  /**
   * Server tier: keys to send as `query.facets`. Defaults to every
   * `checklist` definition when omitted.
   */
  facetKeys?: readonly string[];
  /** Server tier: distinct-value counts from the last fetch. */
  facets?: FacetMap;
}
/** Result of {@link useTableData}. */
interface UseTableDataResult<TRow> {
  /** The resolved source, whichever tier provided it. */
  source: TableSource<TRow>;
  /** The merged declarative-filter runtime (defs, chips, URL keys, predicate). */
  runtime: FilterRuntime<TRow>;
}
/**
 * The public `mode` prop surface, shared by every batteries-included
 * `<DataTable>`: a discriminated union so `mode="server"` REQUIRES
 * `onQueryChange` at compile time, while `mode="frontend"` (or no mode
 * at all) keeps it optional — as a pure notification and as the v1-style
 * inference trigger respectively.
 *
 * @typeParam TRow - The row type.
 */
type DataModeProps<TRow> = {
  /** The table owns the query state; the CALLER fetches. */mode: "server"; /** The data contract: run the request, hand back `data` + `total`. */
  onQueryChange: NonNullable<UseServerDataOptions<TRow>["onQueryChange"]>;
} | {
  /**
   * The table processes `data` itself. Omit `mode` for the inferred
   * tiers (`data` + `onQueryChange` still means server).
   */
  mode?: "frontend";
  /**
   * With `mode="frontend"`: a pure notification, fired on every
   * committed sort / filter / page / search change and never on
   * mount. Without `mode`: providing it selects the server tier.
   */
  onQueryChange?: NonNullable<UseServerDataOptions<TRow>["onQueryChange"]>;
};
/** True when the `filters` prop is the declarative array form. */
declare function isDeclarativeFilters<TRow>(filters: readonly FilterDef<TRow>[] | ReactNode): filters is readonly FilterDef<TRow>[];
/**
 * Resolve the table's data tier from what the caller passed:
 *
 * - `source` — full control (query-library integration), used as-is;
 * - `data` + `onQueryChange` — server mode: the table owns the query state
 *   and emits consolidated change events; the caller fetches;
 * - `data` alone — frontend mode: filtering/sorting/paging are automatic,
 *   with the declarative filters' predicate already applied.
 *
 * All three run through the same declarative-filter runtime, so column
 * `filter` shorthands and the `filters` array drive chips and URL parsing
 * regardless of tier.
 *
 * @typeParam TRow - The row type.
 */
declare function useTableData<TRow>(options: UseTableDataOptions<TRow>): UseTableDataResult<TRow>;
//#endregion
//#region src/state/errorState.d.ts
/** What the error chrome is describing, and what it can do about it. */
interface TableErrorState {
  /** The failure to surface. */
  error: Error;
  /**
   * Ask the source to try again, or `undefined` when it cannot — a static
   * `data` array has nothing to re-fetch, so no retry is offered rather than
   * one that does nothing.
   */
  retry?: () => void;
  /** Whether a retry is already in flight. */
  retrying: boolean;
}
/**
 * A replaceable piece of chrome: a node, or a function that builds one from
 * what the built-in was showing.
 *
 * @typeParam TState - What the built-in had to work with.
 */
type Slot<TState> = ReactNode | ((state: TState) => ReactNode);
/**
 * Resolve a slot the host may have replaced.
 *
 * @param slot - The host's replacement, if any.
 * @param state - What the built-in chrome was showing.
 * @returns The host's node, or `undefined` when they left the built-in alone.
 */
declare function fillSlot<TState>(slot: Slot<TState> | undefined, state: TState): ReactNode;
/**
 * The error state a source is in, or `undefined` when it is fine.
 *
 * Every adapter derives this the same way, so it is derived once here — the
 * retry in particular, which is only offered when the source can actually
 * perform one.
 *
 * @param source - The table's source.
 * @returns The state, or `undefined` when there is no failure to report.
 */
declare function tableErrorState<TRow>(source: TableSource<TRow>): TableErrorState | undefined;
//#endregion
//#region src/tree/nestedTable.d.ts
/** Row density, as the table's own prop spells it. */
type Density$1 = "comfortable" | "compact";
/**
 * The props a nested table must be mounted with, handed to the host's `table`
 * callback to spread onto the kit's own component.
 */
interface NestedTableDefaults {
  /**
   * Never true. Two tables writing `?page=` fight over one URL, and the loser
   * silently resets while the reader is using it.
   */
  urlSync: false;
  /**
   * Off by default: a second search box inside a row reads as chrome rather
   * than as a feature. Spread these first and pass `searchable` after to keep
   * it.
   */
  searchable: boolean;
  /** The parent's density, so the child matches rather than guessing. */
  density: Density$1 | undefined;
  /** The parent's labels, so a nested table is localized like its parent. */
  labels: TableLabels | undefined;
  /** The accessible name, also used on the region around it. */
  tableLabel: string;
}
/** A row's nested table. */
interface NestedTable {
  /**
   * Accessible name for the nested table and its region — the only thing a
   * screen-reader user has to go on once focus is inside it. Name it after the
   * row it belongs to ("Orders for Ada Lovelace"), not after the feature.
   */
  label?: string;
  /**
   * Mount the kit's own table with these defaults:
   * `(defaults) => <DataTable {...defaults} data={row.orders} columns={cols} rowKey={id} />`.
   * The child rows keep their own type — the closure holds it, so nothing is
   * erased at a prop boundary.
   */
  table: (defaults: NestedTableDefaults) => ReactNode;
}
/** A host's declaration: the nested table for a row, or nothing. */
type NestedTableFor<TRow> = (row: TRow) => NestedTable | undefined;
/** What the parent contributes to its nested tables. */
interface NestedTableParent {
  /** The parent's density. */
  density?: Density$1;
  /** The parent's labels. */
  labels?: TableLabels;
}
/**
 * The defaults a table inside a row is mounted with.
 *
 * @param label - The nested table's accessible name.
 * @param parent - What the parent table contributes.
 * @returns Props to spread onto the kit's own table.
 */
declare function nestedTableDefaults(label: string, parent?: NestedTableParent): NestedTableDefaults;
/**
 * Turn a nested-table declaration into the detail renderer the table already
 * knows how to place under a row.
 *
 * @typeParam TRow - The parent row type.
 * @param options - The declaration, the host's own panel, and the parent chrome.
 * @returns A `renderRowDetail`, or `undefined` when neither is declared.
 */
declare function nestedTableDetail<TRow>(options: {
  nestedTable: NestedTableFor<TRow> | undefined; /** The host's own detail panel, used for rows with no nested table. */
  renderRowDetail?: (row: TRow) => ReactNode;
  parent?: NestedTableParent;
}): ((row: TRow) => ReactNode) | undefined;
//#endregion
//#region src/columns/useColumnLayoutStorageState.d.ts
/** The subset of the Web `Storage` API the hook needs (injectable for tests). */
type LayoutStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
/** Options for {@link useColumnLayoutStorageState}. */
interface UseColumnLayoutStorageStateOptions {
  /** Storage key for this table's layout, e.g. `"people-table-columns"`. */
  storageKey: string;
  /** Storage backend. Defaults to `localStorage`; memory-only under SSR. */
  storage?: LayoutStorage;
  /** Layout applied when storage carries no saved layout yet. */
  defaultColumnLayout?: Partial<ColumnLayoutState>;
}
/** State + change handler returned by {@link useColumnLayoutStorageState}. */
interface UseColumnLayoutStorageStateResult {
  /** Current layout — from storage, or the default when storage is empty. */
  layout: ColumnLayoutState;
  /** Persist a new layout. Wire to `onColumnLayoutChange`. */
  onLayoutChange: (next: ColumnLayoutState) => void;
}
/**
 * Column layout persisted to `localStorage` (or any injected storage) — the
 * "user preference" counterpart to {@link useColumnLayoutUrlState}'s
 * shareable links. A layout set back to the exact default removes the stored
 * entry, so defaults can evolve in later releases. SSR-safe: without a
 * browser the layout stays in memory for that render.
 *
 * ```tsx
 * const { layout, onLayoutChange } = useColumnLayoutStorageState({
 *   storageKey: "people-table-columns",
 * });
 * <DataTable columnLayout={layout} onColumnLayoutChange={onLayoutChange} … />
 * ```
 *
 * @param options - See {@link UseColumnLayoutStorageStateOptions}.
 * @returns The current layout and a change handler that persists it.
 */
declare function useColumnLayoutStorageState(options: UseColumnLayoutStorageStateOptions): UseColumnLayoutStorageStateResult;
//#endregion
//#region src/url/useSavedViews.d.ts
/** One captured view: a name plus the table's own URL params. */
interface SavedView {
  name: string;
  /** The table-scoped query string (only this table's params). */
  search: string;
  /**
   * Whether this is the view the table opens with. At most one view carries
   * it — setting it on another clears the first, because "default" that can
   * be true twice is not a default.
   */
  isDefault?: boolean;
  /**
   * Who the view is for. `"private"` is the default and needs no storage
   * beyond this browser; `"team"` is one a store shares with other people.
   */
  visibility?: SavedViewVisibility;
  /**
   * The schema this view was written at. Absent means version 1 — the shape
   * that predates versioning.
   */
  version?: number;
  /**
   * Whether this reader may change it. A team view someone else owns arrives
   * read-only, and the panel must show it as such rather than offering
   * controls that will fail — a disabled control is information; a control
   * that silently does nothing is a bug the user is blamed for.
   */
  readOnly?: boolean;
}
/** Who a saved view is for. */
type SavedViewVisibility = "private" | "team";
/**
 * The schema a view is written at today.
 *
 * A saved view outlives the code that saved it — that is the whole point of
 * saving one — so it carries the version it was written at and the table
 * upgrades what it reads. Views stored before versioning existed have no
 * number and are treated as version 1, which is what they are.
 */
declare const SAVED_VIEW_VERSION = 2;
/**
 * Bring one stored view up to date, or return `null` to drop it.
 *
 * Called for every view whose `version` is behind {@link SAVED_VIEW_VERSION},
 * oldest first, after the built-in migration has run. Dropping is a real
 * answer: a view whose columns no longer exist restores a table nobody asked
 * for, and silently applying it is worse than losing it.
 */
type SavedViewMigration = (view: SavedView, from: number) => SavedView | null;
/**
 * Somewhere to keep views other than this browser.
 *
 * Async on purpose: the whole point is a server, and a synchronous interface
 * would have to be faked by every implementation. `localStorage` remains the
 * zero-config default, so a table that never passes a store keeps working
 * offline with no server at all.
 */
interface SavedViewsStore {
  /** Every view this reader can see, in the order to show them. */
  list: () => Promise<readonly SavedView[]>;
  /** Create or replace one. */
  save: (view: SavedView) => Promise<void>;
  /** Delete one by name. */
  remove: (name: string) => Promise<void>;
  /**
   * Persist the ORDER of the list — names only, in the order a later
   * {@link SavedViewsStore.list} should answer with.
   *
   * Order belongs to the list, not to any one view, so it has nowhere to go
   * through `save`. It travels as names rather than views for the same reason
   * `save` takes one view at a time: a whole-list write would carry every
   * view's contents with it and overwrite whatever someone else changed
   * meanwhile. Names carry the ordering and nothing else.
   *
   * Optional, so a store written before this existed keeps compiling and
   * keeps working — saving, renaming, removing and switching the default all
   * go through `save` and `remove` as before. What such a store cannot do is
   * remember an order: `move` reorders the list on screen for the session,
   * and the next `list()` decides the order again. Implement this when
   * reordering has to survive a reload.
   *
   * Called after the `save` and `remove` writes of the same operation have
   * settled, so a rename's new name is already known by the time its place in
   * the list arrives.
   */
  reorder?: (names: readonly string[]) => Promise<void>;
}
/** Options for {@link useSavedViews}. */
interface UseSavedViewsOptions {
  /** Storage key for the view list, e.g. `"people-table-views"`. */
  storageKey: string;
  /** Storage backend. Defaults to `localStorage`; memory-only under SSR. */
  storage?: LayoutStorage;
  /**
   * Keep views somewhere other than this browser — a server, usually. Given
   * one, it replaces `storage` entirely: two sources of truth for the same
   * list is how a view comes back after being deleted.
   */
  store?: SavedViewsStore;
  /** What `save` marks a new view as. Defaults to `"private"`. */
  visibility?: SavedViewVisibility;
  /**
   * Upgrade views saved by an older version of your table — renamed columns,
   * retired filters. Runs after the built-in migration; return `null` to drop
   * a view rather than restore a table nobody asked for.
   */
  migrate?: SavedViewMigration;
  /** The table's URL-state backend (same one the table uses). */
  urlAdapter?: UrlStateAdapter;
  /** The table's URL namespace — must match the table's `urlKey`. */
  urlKey?: string;
  /**
   * Mirror of the table's URL-sync switch. When `false` (and no explicit
   * `urlAdapter` is given) views capture and apply against an in-memory
   * backend instead of the address bar — matching a table mounted with
   * URL sync off.
   * @defaultValue true
   */
  urlSync?: boolean;
}
/** Result of {@link useSavedViews}. */
interface UseSavedViewsResult {
  /** The saved views, in save order. */
  views: readonly SavedView[];
  /** Capture the table's CURRENT state under a name (replaces same-name). */
  save: (name: string) => void;
  /** Apply a saved view to the table (other tables' params untouched). */
  apply: (name: string) => void;
  /** Remove a saved view. */
  remove: (name: string) => void;
  /**
   * Rename a view, keeping its place in the list. A no-op when the name is
   * unknown or the new name is taken — silently merging two views is how a
   * rename loses one.
   */
  rename: (from: string, to: string) => void;
  /**
   * Move a view one step through the list. Past either end does nothing
   * rather than wrapping, and a view this reader may not change does not move
   * at all. With a `store`, the new order reaches it through
   * {@link SavedViewsStore.reorder}; a store without that member reorders for
   * the session only.
   */
  move: (name: string, delta: -1 | 1) => void;
  /**
   * Make a view the default, or clear the default by passing its own name
   * again. Only one view can hold it.
   */
  setDefault: (name: string) => void;
  /** The default view, when one is set. */
  defaultView: SavedView | undefined;
  /**
   * Read the list again — after someone else has changed a shared view, say.
   * Loading happens on mount and when `storageKey` changes; a `store` or a
   * `migrate` written inline changes identity on every render, so neither can
   * be allowed to trigger it. Refreshing is therefore something the host asks
   * for rather than something identity accidentally causes.
   */
  reload: () => void;
}
/**
 * Headless saved views: capture the table's current URL state (search,
 * sort, page, filters, column layout — ONLY this table's params) under a
 * name, persist the list, and re-apply on demand without touching other
 * tables sharing the URL. Wire it to any menu in the `toolbar` slot.
 */
declare function useSavedViews({
  storageKey,
  storage,
  store,
  visibility,
  migrate,
  urlAdapter,
  urlKey,
  urlSync
}: UseSavedViewsOptions): UseSavedViewsResult;
//#endregion
//#region src/useDataTable/useSearchInput.d.ts
/** A controlled, debounced search input bound to a committed value. */
interface SearchInputState {
  /** The live (uncommitted) input value. */
  value: string;
  /** Update the live input value. */
  setValue: (next: string) => void;
}
/**
 * Bridge a fast-typing search box to a slower committed search value.
 * Local input updates immediately; the trimmed value is flushed to
 * `setSearch` after the debounce, and external `search` changes (back
 * button, deep link, clear-all) mirror back into the input.
 *
 * @param search - The committed search value (from a source).
 * @param setSearch - Commit a new search value.
 * @param debounceMs - Debounce delay; defaults to 300.
 * @returns The controlled input state.
 */
declare function useSearchInput(search: string, setSearch: (next: string) => void, debounceMs?: number): SearchInputState;
//#endregion
//#region src/columns/columnText.d.ts
/**
 * The text for one cell — never `undefined`, so a caller never has to decide
 * what to say when a column declines to answer.
 *
 * @typeParam TRow - The row type.
 * @param column - The column being read.
 * @param row - The row being read.
 * @returns The cell as text, or `""` when the column holds nothing readable.
 */
declare function columnText<TRow>(column: ColumnDef<TRow>, row: TRow): string;
//#endregion
//#region src/columns/computed.d.ts
/** How a computed column is declared. */
interface ComputedColumnSpec<TRow, TValue> {
  /** Column key — also the filter/sort key, as with any column. */
  key: string;
  /** Header content. Defaults to the humanized key, like any column. */
  header?: ReactNode;
  /**
   * The inputs this column reads. The value is recomputed when any of them
   * changes and reused when none do.
   *
   * List every field `value` touches. Anything left out is a stale cell that
   * only appears once the data changes underneath it.
   */
  deps: (row: TRow) => readonly unknown[];
  /** The derivation itself. Runs once per row per distinct set of deps. */
  value: (row: TRow) => TValue;
  /**
   * How the value is displayed. Without one, primitives and dates render as
   * text and anything else renders as empty — an object has no useful reading,
   * so a value that is not a primitive wants a formatter.
   *
   * Formatting lives here rather than in `accessor` so that sorting,
   * filtering and export keep seeing the underlying value.
   */
  format?: (value: TValue, row: TRow) => ReactNode;
  /**
   * Anything else a column can be — `sortable`, `align`, `width`, `filter`,
   * `hideOnMobile`, and the rest. `accessor`, `sortValue` and `exportValue`
   * are derived and cannot be overridden here.
   */
  column?: Omit<ColumnDef<TRow>, "key" | "header" | "accessor" | "sortValue" | "exportValue">;
}
/**
 * Build a derived column: computed once per row, cached until its declared
 * dependencies change, and consistent across display, sorting, filtering and
 * export.
 *
 * Define columns at module level, or memoise them. The cache lives inside the
 * column this returns, so rebuilding the column on every render throws the
 * cache away with it — the values stay correct, but nothing is ever reused.
 * This is the same rule {@link ColumnDef.Cell} already asks for.
 *
 * @typeParam TRow - The row type.
 * @typeParam TValue - What the derivation produces.
 */
declare function computed<TRow extends object, TValue = SortableValue>(spec: ComputedColumnSpec<TRow, TValue>): ColumnDef<TRow>;
//#endregion
//#region src/columns/resolveColumns.d.ts
/**
 * The data path a column reads for the active locale: the exact locale tag
 * first (`"ar-EG"`), then its primary subtag (`"ar"`), then the key itself.
 * Works for flat per-language fields and nested objects alike — both are
 * just paths.
 */
declare function localizedColumnPath(column: Pick<ColumnDef<unknown>, "key" | "i18n">, locale: string | undefined): string;
/**
 * Fill a column's declarative defaults: a missing `header` is humanized from
 * the key, and a column without `accessor`/`Cell` reads the row by its
 * locale-resolved data path (`i18n` map, else `key` — dot paths reach nested
 * values). Client-side sorting follows the generated accessor, so localized
 * columns sort by the localized text. Already-complete columns pass through
 * untouched, so the resolution is idempotent and cheap to repeat.
 */
declare function resolveColumns<TRow>(columns: readonly ColumnDef<TRow>[], locale?: string): ColumnDef<TRow>[];
//#endregion
//#region src/filters/filterBuiltins.d.ts
/** Built-in types — the registry's first consumers. */
declare const builtInFilterSpecs: readonly FilterTypeSpec[];
/**
 * Default registry: every built-in type, nothing else.
 *
 * It builds its own specs rather than reading {@link builtInFilterSpecs}.
 * Both are pure so a plain table shakes them out, and a pure binding is free
 * to land in a different chunk from the one that reads it — which happened
 * the moment a new entry point changed the chunk layout, and handed this an
 * empty spec list. With no cross-binding there is no order to get wrong.
 */
declare const defaultFilterRegistry: FilterTypeRegistry;
/** Merge host `filterTypes` onto the built-ins (same `type` replaces). */
declare function resolveFilterRegistry(extras?: readonly FilterTypeSpec[]): FilterTypeRegistry;
//#endregion
//#region src/filters/filterChrome.d.ts
/** How the table presents filters — one container, never stacked. */
type FilterChromeMode = "popover" | "drawer" | "header";
/**
 * Resolve the single filter chrome. `headerFilters` is an alias for
 * `"header"`. Header mode wins when both are passed so a host cannot
 * mount the toolbar overlay and the header row at once.
 */
declare function resolveFilterMode(mode?: FilterChromeMode, headerFilters?: boolean): FilterChromeMode;
/**
 * Whether the toolbar still shows Filters. Header mode hides that button
 * for the simple form (the icons own those fields) but keeps it when the
 * AND/OR tree is on — the tree has no column of its own.
 */
declare function toolbarShowsFilters(mode: FilterChromeMode, hasForm: boolean, hasFilterTree: boolean): boolean;
/**
 * Whether the per-field form mounts inside Filters. Header icons own those
 * fields; `filterFields={false}` keeps only the AND/OR tree.
 */
declare function showSimpleFilterFields(headerFiltersOn: boolean, filterFields?: boolean): boolean;
//#endregion
//#region src/filters/filterTreeCodec.d.ts
/** URL param for the versioned tree (`ft=1.{…}`). */
declare const FILTER_TREE_PARAM = "ft";
/** Current encoding version. Unknown versions are dropped, never reinterpreted. */
declare const FILTER_TREE_VERSION = 1;
/** True when a tree has at least one condition (nested groups count). */
declare function isActiveFilterTree(tree: QueryFilterGroup | undefined): tree is QueryFilterGroup;
/**
 * Parse a stored `ft` value. Missing, malformed, or unknown-version
 * strings return `undefined` so an old or hand-edited link never
 * silently becomes a different query.
 */
declare function parseFilterTree(raw: string | null | undefined): QueryFilterGroup | undefined;
/** Encode a tree for the URL. Empty / undefined trees omit the param. */
declare function serializeFilterTree(tree: QueryFilterGroup | undefined): string | undefined;
//#endregion
//#region src/filters/filterTree.d.ts
/**
 * Project one tree condition onto the extra-filter bag the existing
 * per-def predicate already understands.
 */
declare function conditionToExtra<TRow>(def: FilterDef<TRow>, condition: QueryCondition, registry?: FilterTypeRegistry): ExtraFilters;
/**
 * Evaluate a tree against one row. An empty / missing tree matches
 * every row. Unknown condition keys match (stale links do not hide data).
 */
declare function evaluateFilterTree<TRow>(tree: QueryFilterGroup | undefined, row: TRow, defs: readonly FilterDef<TRow>[], registry?: FilterTypeRegistry): boolean;
//#endregion
//#region src/filters/filterTreeMutations.d.ts
type FilterTreeNode = QueryCondition | QueryFilterGroup;
/** An empty AND group — the tree a first "Add condition" starts from. */
declare function emptyFilterTree(): QueryFilterGroup;
/** Set the combinator on the group at `path`. */
declare function setFilterTreeCombinator(tree: QueryFilterGroup, path: readonly number[], combinator: QueryFilterGroup["combinator"]): QueryFilterGroup;
/** Append a condition to the group at `path`. */
declare function addFilterTreeCondition(tree: QueryFilterGroup | undefined, path: readonly number[], condition: QueryCondition): QueryFilterGroup;
/** Append a nested AND group to the group at `path`. */
declare function addFilterTreeGroup(tree: QueryFilterGroup | undefined, path: readonly number[]): QueryFilterGroup;
/** Replace the node at `path` (path must name a child, not the root). */
declare function replaceFilterTreeNode(tree: QueryFilterGroup, path: readonly number[], next: FilterTreeNode): QueryFilterGroup;
/**
 * Remove the node at `path`. Removing the last root child returns
 * `undefined` so the URL drops `ft`.
 */
declare function removeFilterTreeNode(tree: QueryFilterGroup, path: readonly number[]): QueryFilterGroup | undefined;
/** Walk every leaf, with the path to that leaf. */
declare function walkFilterTreeConditions(tree: QueryFilterGroup | undefined, path?: readonly number[]): {
  condition: QueryCondition;
  path: readonly number[];
}[];
//#endregion
//#region src/filters/headerFilterOverlay.d.ts
declare const SESSION_ATTR = "data-adapttable-header-filter";
interface HeaderFilterSessionProps {
  readonly [SESSION_ATTR]: string;
}
/**
 * Whether this write is a finished, single-control value — the only case
 * {@link bindHeaderFilterDismiss} will close the overlay when `closeOnSelect`
 * is on. Operator-only writes, typed terms, and multi-select toggles are
 * incomplete: another control is still waiting.
 */
declare function headerFilterFieldIsComplete<TRow>(def: FilterDef<TRow>, extra: ExtraFilters, registry?: FilterTypeRegistry): boolean;
/**
 * Wrap a filter source so a complete write can dismiss the overlay.
 * Off unless `closeOnSelect` is true — the default is stay open.
 */
declare function bindHeaderFilterDismiss<TRow>(source: FilterFormSource<TRow>, options: {
  def: FilterDef<TRow>;
  closeOnSelect?: boolean;
  dismiss: () => void;
  registry?: FilterTypeRegistry;
}): FilterFormSource<TRow>;
/**
 * Dismiss on a true outside press or Escape. Nested kit dropdowns (and a
 * focused native `<select>` whose OS list is open) are not outside.
 */
declare function usePointerDismiss(open: boolean, dismiss: () => void, insideSelector: string): void;
/** Open state + a source that honours {@link bindHeaderFilterDismiss}. */
declare function useHeaderFilterOverlay<TRow>(props: {
  source: FilterFormSource<TRow>;
  def: FilterDef<TRow>;
  closeOnSelect?: boolean;
  registry?: FilterTypeRegistry;
}, options?: {
  nestedSelector?: string;
  pointerDismiss?: boolean;
}): {
  open: boolean;
  setOpen: (open: boolean) => void;
  source: FilterFormSource<TRow>;
  sessionProps: HeaderFilterSessionProps;
  resetKey: number;
};
//#endregion
//#region src/filters/relativeDates.d.ts
/**
 * Relative date tokens. The URL and Saved Views store the token, never a
 * resolved calendar day — "last 7 days" stays the last 7 days tomorrow.
 * {@link resolveRelativeRange} is the only place a token becomes a window.
 */
/** Named windows that need no extra number. */
declare const RELATIVE_NAMED: readonly ["today", "yesterday", "tomorrow", "thisWeek", "thisMonth", "previousMonth"];
/** A stored relative-date token (`last:7`, `today`, …). */
type RelativeDateToken = (typeof RELATIVE_NAMED)[number] | `last:${number}` | `next:${number}`;
/** Inclusive local-time window a token resolves to. */
interface RelativeDateRange {
  startMs: number;
  endMs: number;
}
/**
 * Parse a stored token. Unknown strings (including ISO dates) return
 * `undefined` so a historical absolute bound is never treated as relative.
 */
declare function parseRelativeToken(raw: string | undefined): RelativeDateToken | undefined;
/** True when `raw` is a relative token, not an absolute date. */
declare function isRelativeDateToken(raw: string | undefined): boolean;
/**
 * Resolve a token against `now` (defaults to the current instant). The
 * frontend predicate and the server query path must both call this so a
 * shared link and a live table agree.
 */
declare function resolveRelativeRange(raw: string | undefined, now?: number | Date): RelativeDateRange | undefined;
/** Build a counted token (`last:7`). `n` below 1 becomes 1. */
declare function countedRelativeToken(kind: "last" | "next", n: number): RelativeDateToken;
/** Named window or a counted last/next kind (the N lives beside the select). */
type RelativePreset = (typeof RELATIVE_NAMED)[number] | "last" | "next";
/** Presets offered by the relative-date widget, in display order. */
declare const RELATIVE_PRESETS: readonly RelativePreset[];
/** `TableLabels` key for each relative preset. */
declare const RELATIVE_PRESET_LABEL_KEYS: {
  readonly today: "relToday";
  readonly yesterday: "relYesterday";
  readonly tomorrow: "relTomorrow";
  readonly thisWeek: "relThisWeek";
  readonly thisMonth: "relThisMonth";
  readonly previousMonth: "relPreviousMonth";
  readonly last: "relLastN";
  readonly next: "relNextN";
};
/** Split a stored token into the widget's preset + N (N defaults to 7). */
declare function splitRelativeToken(raw: string): {
  preset: RelativePreset;
  n: number;
};
/** Join a widget preset + N back into the stored token. */
declare function joinRelativeToken(preset: RelativePreset, n: number): RelativeDateToken;
/** Chip / select wording for a stored token. */
declare function relativeTokenLabel(raw: string, labels: {
  relToday: string;
  relYesterday: string;
  relTomorrow: string;
  relThisWeek: string;
  relThisMonth: string;
  relPreviousMonth: string;
  relLastN: string;
  relNextN: string;
}): string;
//#endregion
//#region src/filters/useFilterOptions.d.ts
/** Resolved choices for a select/multiSelect control. */
interface ResolvedFilterOptions {
  /** The choices to render (empty while an async loader is in flight). */
  options: readonly FilterOption[];
  /** True while an async loader is fetching. */
  loading: boolean;
}
/**
 * Resolve a definition's option source for the auto-built form: arrays are
 * used as-is, async loaders run once on mount (kit forms show their native
 * loading affordance meanwhile), and a leftover `"auto"` — possible only on
 * the server/source tiers, where there is no full dataset to derive from —
 * resolves to no options with a development warning.
 */
declare function useFilterOptions<TRow>(def: Pick<FilterDef<TRow>, "key" | "options">): ResolvedFilterOptions;
//#endregion
//#region src/filters/useFilterTreeChips.d.ts
/** Build one chip label for a tree leaf. */
declare function filterTreeChipLabel<TRow>(condition: QueryCondition, defs: readonly FilterDef<TRow>[], labels: Required<TableLabels>): string;
/** Options for {@link useFilterTreeChips}. */
interface UseFilterTreeChipsOptions<TRow> {
  readonly tree: QueryFilterGroup | undefined;
  readonly defs: readonly FilterDef<TRow>[];
  readonly labels: Required<TableLabels>;
  readonly setFilterTree?: (tree: QueryFilterGroup | undefined) => void;
}
/** Flatten the tree into removable chips. */
declare function useFilterTreeChips<TRow>(options: UseFilterTreeChipsOptions<TRow>): readonly ActiveFilterChip[];
//#endregion
//#region src/find/findMatches.d.ts
/** What a find needs to know. */
interface FindMatchesOptions<TRow> {
  /** What to look for. An empty or blank query matches nothing. */
  query: string;
  /** The rows the browser holds, in table order. */
  rows: readonly TRow[];
  /** The columns as rendered — matches are addressed by their index. */
  columns: readonly ColumnDef<TRow>[];
  /** Where the rendered window starts in the dataset. Zero unless paged. */
  firstRowIndex?: number;
}
/**
 * Every cell whose text contains the query, in reading order.
 *
 * Case-insensitive, because nobody types the case of what they are looking
 * for. Only the LOADED rows are searched: a find cannot honestly claim a hit
 * in a row the browser has never seen, and saying "3 of 17" about rows that
 * are not there would be worse than saying nothing.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link FindMatchesOptions}.
 * @returns The matching cells, in absolute addresses.
 */
declare function findMatches<TRow>(options: FindMatchesOptions<TRow>): GridCell[];
/** A cell address as a string, for set membership without a nested scan. */
declare function matchKey(cell: GridCell): string;
/**
 * The match keys as a set, so a cell can ask "am I a match" in constant time.
 *
 * A table of 500 rows × 12 columns asks that question 6,000 times per render;
 * scanning an array each time is the difference between a find that feels
 * instant and one that stutters.
 *
 * @param matches - The matches, from {@link findMatches}.
 * @returns Their keys.
 */
declare function matchKeySet(matches: readonly GridCell[]): ReadonlySet<string>;
/**
 * Step through the matches, wrapping at both ends.
 *
 * Wrapping is what a find does — reaching the last hit and pressing next
 * returns to the first, which is why a browser's find bar says "1 of 17"
 * again rather than stopping.
 *
 * @param index - Where the walk is now.
 * @param total - How many matches there are.
 * @param step - `1` for next, `-1` for previous.
 * @returns The next index, or `-1` when there is nothing to step through.
 */
declare function stepMatch(index: number, total: number, step: number): number;
//#endregion
//#region src/focus/clipboardRange.d.ts
/** What a copy needs to know: the rectangle, and the data under it. */
interface ClipboardRangeOptions<TRow> {
  /** The selected rectangle, in absolute addresses. */
  range: CellRange;
  /** The rows the browser holds, in table order. */
  rows: readonly TRow[];
  /** The columns as rendered — a range's column indices address these. */
  columns: readonly ColumnDef<TRow>[];
  /** Where the rendered window starts in the dataset. Zero unless paged. */
  firstRowIndex?: number;
  /** Include a header row naming each column. Defaults to `false`. */
  headers?: boolean;
}
/**
 * The selected rectangle as tab-separated text, ready for the clipboard.
 *
 * Rows outside what the browser holds are skipped rather than written blank: a
 * range can only cover loaded rows, and inventing empty ones would paste holes
 * into someone's spreadsheet.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link ClipboardRangeOptions}.
 * @returns TSV text; an empty string when the range covers nothing loaded.
 */
declare function clipboardRangeText<TRow>(options: ClipboardRangeOptions<TRow>): string;
/**
 * Write text to the clipboard, reporting whether it landed.
 *
 * The async Clipboard API is unavailable outside a secure context and can be
 * refused by permission, so this answers with a boolean rather than throwing:
 * a copy that silently did nothing is the thing worth avoiding, and the caller
 * needs to know in order to say so.
 *
 * @param text - What to write.
 * @returns Whether the clipboard accepted it.
 */
declare function writeClipboardText(text: string): Promise<boolean>;
/**
 * Read text from the clipboard, or `null` when the browser will not give it.
 *
 * Reading is the more restricted half: Safari and Firefox gate `readText`
 * behind a permission or refuse it outside a user gesture. `null` says "no
 * text", never "empty paste", so a caller can tell the difference and say so.
 *
 * @returns The clipboard's text, or `null` when it is unavailable.
 */
declare function readClipboardText(): Promise<string | null>;
//#endregion
//#region src/focus/fillRange.d.ts
/** Which way a fill runs. Fills are one-axis, as in every spreadsheet. */
type FillDirection = "down" | "up" | "right" | "left";
/**
 * Which way a drag from the selection's corner to `to` is filling.
 *
 * A pointer wanders, so the axis is decided by the LARGER overflow rather than
 * by whichever edge was crossed first — otherwise a drag two rows down and one
 * column across would fill sideways because of a stray pixel.
 *
 * @param source - The selected rectangle the fill starts from.
 * @param to - The cell the pointer has reached.
 * @returns The direction, or `null` when `to` is still inside the selection.
 */
declare function fillDirection(source: CellRange, to: GridCell): FillDirection | null;
/**
 * The rectangle a fill would cover — the selection plus what the drag reached.
 *
 * This is what gets highlighted while dragging, so the preview and the commit
 * can never disagree about which cells are involved.
 *
 * @param source - The selected rectangle.
 * @param to - The cell the pointer has reached.
 * @returns The union rectangle, or the source itself when nothing is added.
 */
declare function fillTargetRange(source: CellRange, to: GridCell): CellRange;
/** What a fill needs to know to become edits. */
interface FillRangeOptions<TRow> {
  /** The selected rectangle the values come from. */
  source: CellRange;
  /** The cell the drag reached, or the far end of a keyboard fill. */
  to: GridCell;
  /** The rows the browser holds, in table order. */
  rows: readonly TRow[];
  /** The columns as rendered — a range's column indices address these. */
  columns: readonly ColumnDef<TRow>[];
  /** Where the rendered window starts in the dataset. Zero unless paged. */
  firstRowIndex?: number;
}
/**
 * Turn a fill gesture into the edits it implies.
 *
 * Only cells OUTSIDE the selection are written: the source is what is being
 * carried, not something to overwrite with itself. Cells beyond the loaded rows
 * or the rendered columns are dropped rather than invented, and a column that
 * is not editable is skipped.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link FillRangeOptions}.
 * @returns The edits, in reading order.
 */
declare function fillRangeEdits<TRow>(options: FillRangeOptions<TRow>): CellEdit<TRow>[];
//#endregion
//#region src/focus/pasteRange.d.ts
/**
 * Parse clipboard text into a grid of raw strings.
 *
 * Quoted fields keep their tabs and newlines: a spreadsheet writes `"a\tb"` for
 * a cell containing a tab, and splitting naively would turn one cell into two
 * and shift every column after it.
 *
 * @param text - The clipboard's text.
 * @returns Rows of raw cell strings; empty when there is nothing to paste.
 */
declare function parseClipboardTable(text: string): string[][];
/** What a paste needs to know to become edits. */
interface PasteRangeOptions<TRow> {
  /** The clipboard's text. */
  text: string;
  /** Where the paste starts — its top-left cell is the anchor. */
  range: CellRange;
  /** The rows the browser holds, in table order. */
  rows: readonly TRow[];
  /** The columns as rendered — a range's column indices address these. */
  columns: readonly ColumnDef<TRow>[];
  /** Where the rendered window starts in the dataset. Zero unless paged. */
  firstRowIndex?: number;
}
/**
 * Turn clipboard text into the edits it implies, starting at the selection's
 * top-left cell.
 *
 * The clipboard's shape wins over the selection's: pasting a 3×2 block into a
 * single selected cell writes 3×2, which is what every spreadsheet does. Cells
 * falling outside the loaded rows or the rendered columns are dropped rather
 * than invented — a paste must never write into a row the browser has not got.
 *
 * A column that is not editable is skipped: paste is an edit, and an edit into a
 * read-only column is not one.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link PasteRangeOptions}.
 * @returns The edits, in row-major order.
 */
declare function pasteRangeEdits<TRow>(options: PasteRangeOptions<TRow>): CellEdit<TRow>[];
/** The two ways a table can receive a paste. */
interface CellPasteHandlerOptions<TRow> {
  /** Takes the batch whole — one transaction, one undo entry. */
  onCellPaste?: (edits: CellEdit<TRow>[]) => void;
  /** The ordinary inline-edit channel, used one edit at a time. */
  onCellEdit?: (row: TRow, key: string, nextValue: unknown) => void;
}
/**
 * Resolve who receives a paste — `onCellPaste`, or `onCellEdit` one cell at a
 * time. See {@link batchEditHandler} for why the default is the edit channel.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link CellPasteHandlerOptions}.
 * @returns The handler, or `undefined` when the table takes no edits at all —
 *   which leaves Ctrl/Cmd+V to the browser.
 */
declare function cellPasteHandler<TRow>(options: CellPasteHandlerOptions<TRow>): ((edits: CellEdit<TRow>[]) => void) | undefined;
/** The two ways a table can receive a fill. */
interface CellFillHandlerOptions<TRow> {
  /** Takes the batch whole — one transaction, one undo entry. */
  onCellFill?: (edits: CellEdit<TRow>[]) => void;
  /** The ordinary inline-edit channel, used one edit at a time. */
  onCellEdit?: (row: TRow, key: string, nextValue: unknown) => void;
}
/**
 * Resolve who receives a fill — `onCellFill`, or `onCellEdit` one cell at a
 * time. See {@link batchEditHandler} for why the default is the edit channel.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link CellFillHandlerOptions}.
 * @returns The handler, or `undefined` when the table takes no edits at all —
 *   which is also when the fill handle is not rendered.
 */
declare function cellFillHandler<TRow>(options: CellFillHandlerOptions<TRow>): ((edits: CellEdit<TRow>[]) => void) | undefined;
//#endregion
//#region src/props.d.ts
/**
 * Where a host's own toolbar controls go.
 *
 * The toolbar reads Search · custom · Filters · Saved views · Columns ·
 * Undo/Redo · Export · Add · Rows per page, and that order is the same in
 * every kit. These name the two places outside it, so a control can be
 * put before everything or after everything without an adapter having to
 * know what the control is.
 */
interface ToolbarSlots {
  /** Ahead of the search input. */
  start?: ReactNode;
  /** After every built-in control, before the rows-per-page select. */
  end?: ReactNode;
}
/**
 * A side panel docked beside the table.
 *
 * Controlled, because the control that opens it is yours: a table settings
 * button in `toolbarSlots`, an item in your own app bar, a route. The
 * table never invents a trigger for it, and `open` is the panel's key or
 * `null` for closed.
 */
interface SidePanelOptions {
  /** The panels, in tab order. */
  panels: readonly SidePanelEntry[];
  /** Which panel is showing, or `null` when the panel is closed. */
  open: string | null;
  /** Called with the panel to show, or `null` when it should close. */
  onOpenChange: (key: string | null) => void;
  /**
   * Which edge to dock to. `"end"` (default) is the right in a
   * left-to-right table and the left in a right-to-left one.
   */
  side?: "start" | "end";
}
/**
 * The UI-agnostic prop surface shared by every AdaptTable adapter's
 * `<DataTable>`. Adapters extend this with kit-specific extras (slots,
 * classNames, animation, …) so the common contract lives in one place.
 *
 * @typeParam TRow - The row type.
 */
interface BaseDataTableProps<TRow> {
  /** Data + state contract from `useFrontendData` / `useQuerySource`. */
  source: TableSource<TRow>;
  /** Column definitions. A parent with `children` is a column group. */
  columns: ColumnInput<TRow>[];
  /** Stable React key extractor for a row. */
  rowKey: (row: TRow) => string;
  /** Trailing per-row actions. */
  rowActions?: RowAction<TRow>[];
  /**
   * How the trailing actions column renders. Omit or `"buttons"` for the
   * horizontal strip. `"menu"` collapses visible actions into a 3-dot menu
   * using each kit's own Menu. {@link BaseDataTableProps.renderRowActions}
   * wins over this.
   */
  rowActionsLayout?: RowActionsLayout;
  /**
   * Replace the trailing actions cell (desktop and mobile cards). Receives
   * the resolved action list (host + built-in duplicate / delete / pin).
   * When set, `rowActionsLayout` is ignored. The column still only appears
   * when there are row actions (or row-mode editing).
   */
  renderRowActions?: RowActionsRenderer<TRow>;
  /** Accessible label for the table. */
  tableLabel?: string;
  /** Placeholder for the search input. */
  searchPlaceholder?: string;
  /** Options for a mobile sort-by select. */
  sortByOptions?: SortByOption[];
  /** Pre-translated label overrides. */
  labels?: TableLabels;
  /** Text direction. Defaults to `"ltr"`. */
  dir?: Direction;
  /**
   * Active locale tag (e.g. `"ar"`, `"ar-EG"`). Drives per-column `i18n`
   * data-path resolution; labels stay a separate concern (`labels`).
   */
  locale?: string;
  /**
   * Row density — independent of column pinning. `"comfortable"` (default) is
   * the roomy layout; `"compact"` tightens row height/padding. Each adapter
   * maps it to its kit's table size.
   */
  density?: "comfortable" | "compact";
  /**
   * Replace a mobile card's body with your own layout.
   *
   * The card's shell stays: list-item semantics, the selection checkbox, the
   * expand and tree toggles, reorder controls, row actions and the detail
   * panel all render around what you return, so a custom card cannot drop the
   * parts that make the list usable. The `card` argument hands you the fields
   * the built-in would have laid out — column, label and rendered value,
   * editors included — so this is a layout decision, not a re-implementation.
   *
   * Omit it and the built-in card renders, byte for byte.
   */
  renderCard?: MobileCardRenderer<TRow>;
  /** Force the mobile layout (otherwise resolved from the viewport). */
  forceMobile?: boolean;
  /**
   * The width, in pixels, at or below which the card layout takes over.
   * Defaults to 768 — a phone in portrait.
   *
   * Raise it when the table lives in a sidebar or a split pane, where the
   * viewport says "desktop" while the table has a phone's width to work
   * with. Lower it when the table is the whole page and its columns are
   * narrow enough to survive.
   */
  mobileBreakpoint?: number;
  /**
   * Initial state applied while the URL is silent about a key — e.g.
   * `defaults={{ limit: 10, sortBy: "name" }}`. The user's own changes
   * (and explicit URL params) always win.
   */
  defaults?: Partial<TableQueryParams> & {
    extra?: ExtraFilters;
  };
  /**
   * Debounce for committing the search input to the source, in
   * milliseconds. Defaults to 300.
   */
  searchDebounceMs?: number;
  /**
   * Pagination mode: `"paged"`, `"infinite"`, or `"auto"` (the default —
   * mobile resolves to infinite, desktop to paged). `virtualize` applies
   * in infinite mode; on a paged desktop table it is inert.
   */
  paginationMode?: PaginationMode;
  /**
   * How many leading desktop-visible columns anchor the mobile identity
   * block. Never overrides an explicit `hideOnMobile: true` — the
   * author's hide always wins.
   */
  mobileIdentityColumns?: number;
  /** Hover-prefetch callback fired on desktop row mouse-enter. */
  prefetch?: (row: TRow) => void;
  /**
   * Row activation — fires on row click and on Enter when the row has focus.
   * Interactive children (action buttons, the selection checkbox, links)
   * keep their own behaviour and never trigger it.
   */
  onRowClick?: (row: TRow) => void;
  /** Called whenever the materialized source rows change. */
  onRowsChange?: (rows: readonly TRow[]) => void;
  /**
   * Inline cell-edit channel. Providing this (together with per-column
   * `editable`) activates editing — omit it and the table never opens an
   * editor, even if columns declare `editable`. The table never mutates
   * rows; apply `nextValue` in your own state / mutation.
   *
   * Return a promise and the cell shows it is saving until that promise
   * settles, and shows why if it rejects — with an undo when
   * {@link BaseDataTableProps.onEditRollback} says how to put the row back.
   */
  onCellEdit?: (row: TRow, key: string, nextValue: unknown) => unknown;
  /**
   * Cut — Ctrl/Cmd+X, after the clipboard has accepted the copy. Requires
   * `cellNavigation`.
   *
   * The table clears nothing itself: what a cut removes is your decision, and
   * emptying cells before the clipboard took them would lose the data outright.
   */
  onCellCut?: (range: CellRange) => void;
  /**
   * Paste — Ctrl/Cmd+V, with the clipboard already parsed into ordinary cell
   * edits. Requires `cellNavigation`.
   *
   * Omit it and every edit goes through `onCellEdit`, so a table that can be
   * edited can be pasted into with nothing extra wired. Provide it to take the
   * batch whole — one server round trip, one undo entry.
   *
   * Cells landing outside the loaded rows or the rendered columns are dropped
   * rather than invented, and a column that is not `editable` is skipped.
   */
  onCellPaste?: (edits: CellEdit<TRow>[]) => void;
  /**
   * Fill — the handle dragged from the selection's corner, or Ctrl/Cmd+D.
   * Requires `cellNavigation`.
   *
   * Same contract as `onCellPaste`: omit it and every edit goes through
   * `onCellEdit`, so the handle appears as soon as the table can be edited.
   * Provide it to take the batch whole.
   */
  onCellFill?: (edits: CellEdit<TRow>[]) => void;
  /**
   * Show what the selected cells add up to — count, sum, average, min and max
   * — in a strip below the table. Requires `cellNavigation`.
   *
   * The count covers every selected cell; the arithmetic covers the numeric
   * ones, so a rectangle spanning a name and a budget still has a sum. A
   * single cell shows nothing: it has no total worth reading.
   */
  selectionStats?: boolean;
  /**
   * Remember edits so they can be undone — Ctrl/Cmd+Z, Ctrl/Cmd+Shift+Z or
   * Ctrl+Y with `cellNavigation`, and `table.editHistory` for your own buttons.
   * Pass `{ depth }` to change how many gestures are kept (50 by default).
   *
   * An undo does not rewrite your data: it COMMITS the previous value back
   * through `onCellEdit`, so whatever you wrapped around editing runs on the
   * way back exactly as it ran on the way out. One gesture is one entry, so a
   * paste of two hundred cells undoes in a single press.
   */
  editHistory?: boolean | {
    depth?: number;
  };
  /**
   * Show a find bar over the table — Ctrl/Cmd+F with `cellNavigation`, or
   * `table.find.setOpen(true)` from a control of your own.
   *
   * Find is not search: it leaves every row where it is and walks the cells
   * whose text contains the query, marking them for the kit to paint. It reads
   * what a cell SHOWS, and searches the loaded rows only — a hit it cannot take
   * you to would be a lie.
   */
  findInTable?: boolean;
  /**
   * Conditional per-row class: `(row, index) => "overdue"` — appended to the
   * adapter's own row classes on desktop rows and mobile cards alike.
   */
  rowClassName?: (row: TRow, index: number) => string | undefined;
  /**
   * Conditional per-row inline style: `(row, index) => ({ background })`.
   * Applied on desktop rows and mobile cards alike. Omit and nothing is set.
   */
  rowStyle?: RowStyle<TRow>;
  /**
   * Row height in px — a constant, or `(row, index) => number`. Sets the
   * row's height and the virtualizer's `estimateSize`. `measureElement`
   * still reports what the browser laid out.
   */
  rowHeight?: RowHeight<TRow>;
  /**
   * Row expansion: render a detail panel under a row. Its presence enables
   * the leading expand chevron on desktop rows and the detail section on
   * mobile cards; multiple rows may be open, keyed by row id.
   */
  renderRowDetail?: (row: TRow) => ReactNode;
  /**
   * Row ids whose detail panel (or nested table) starts open. Uncontrolled
   * initial state — later toggles own the set. Omit and every row starts
   * closed.
   */
  defaultExpandedRowIds?: readonly string[];
  /**
   * A real table under a row instead of a blank panel. Name it after the row
   * and mount the kit's own `<DataTable>` with the defaults handed in:
   *
   * ```tsx
   * nestedTable={(row) => ({
   *   label: `Orders for ${row.name}`,
   *   table: (defaults) => (
   *     <DataTable
   *       {...defaults}
   *       data={row.orders}
   *       columns={orderColumns}
   *       rowKey={(order) => order.id}
   *     />
   *   ),
   * })}
   * ```
   *
   * It is the same component the page uses, so sorting, selection, keyboard
   * navigation and accessibility come with it. The defaults are the ones a
   * table inside a row cannot do without — no URL state to fight its parent's
   * over, no second search box, the parent's density and labels.
   *
   * Return `undefined` for a row that has no nested table; with
   * `renderRowDetail` also set, those rows fall back to it.
   */
  nestedTable?: NestedTableFor<TRow>;
  /**
   * Gate a commit on a rule no single cell can answer — an end date before its
   * start, a total that must match its parts. Receives the row the edit WOULD
   * produce, not the stored one; return a message for a row-level problem, a map
   * of column key → message to mark individual cells, or nothing to allow it.
   * May be async.
   */
  validateRow?: RowValidator<TRow>;
  /**
   * Put a row back the way it was after a rejected save.
   *
   * A table that applies an edit optimistically has already shown the new
   * value, so a rejection has to restore the old one — and only the host can
   * write to its own rows. Without this the cell is marked failed and the value
   * stays put, which is right for a table that refetches instead.
   */
  onEditRollback?: (previous: TRow, columnKey: string) => void;
  /** Turn a rejected save into the sentence its cell shows. */
  formatEditError?: (error: unknown) => string;
  /**
   * Mark cells whose change nobody has confirmed yet — `data-dirty` on the cell
   * and on its row, so a reader can see what is still at risk. A cell clears
   * when its save resolves, when a rollback undoes it, or when the table is told
   * the value settled (`table.editing.dirty.confirm`).
   *
   * Off by default: a mark is a claim about what the server has agreed to, and a
   * table whose host never says would be guessing.
   */
  dirtyIndicators?: boolean;
  /**
   * Edit a whole row at once instead of a cell at a time: every field opens
   * together, holds its draft, and reaches the host as ONE patch when the reader
   * saves. Requires {@link BaseDataTableProps.onRowEdit}.
   *
   * The right unit for a row whose fields constrain each other — a start and an
   * end date cannot be edited one at a time without passing through a state that
   * is invalid on the way.
   */
  rowEditing?: boolean;
  /**
   * Take everything a row edit changed, as one patch of parsed values keyed by
   * column. The table never writes to a row.
   *
   * Return a promise and the row's controls show it is saving, exactly as a cell
   * does.
   */
  onRowEdit?: (row: TRow, patch: Readonly<Record<string, unknown>>) => unknown;
  /**
   * Change many rows and save them together: every editable cell is a field,
   * nothing is sent until the reader saves, and one Cancel puts it all back.
   * The shape of a review pass — walk a list correcting values, write once.
   * Requires {@link BaseDataTableProps.onBatchEdit}.
   */
  batchEditing?: boolean;
  /**
   * Take every pending row at once, as a list of `{ row, rowId, patch }`. Called
   * once per save, which is what lets a host make the whole batch one request.
   */
  onBatchEdit?: (edits: readonly BatchRowEdit<TRow>[]) => unknown;
  /**
   * Observe an editor opening. Fires for cell, row and batch units. The
   * handler cannot change the outcome — throwing is swallowed.
   */
  onEditStart?: EditEventHandler<TRow>;
  /**
   * Observe a cancel (Escape, Cancel, throwing a batch away). Not fired when
   * a successful commit merely closes the editor.
   */
  onEditCancel?: EditEventHandler<TRow>;
  /**
   * Observe a value reaching the host. Fires after parse and validation, at
   * the same moment as `onCellEdit` / `onRowEdit` / `onBatchEdit`.
   */
  onEditCommit?: EditEventHandler<TRow>;
  /**
   * Observe a validator refusing a value. The editor stays open with the
   * message; this is how analytics hears about it.
   */
  onValidationFail?: EditEventHandler<TRow>;
  /**
   * Observe a save promise rejecting. The cell is already marked failed;
   * this is the side-effect channel.
   */
  onEditError?: EditEventHandler<TRow>;
  /**
   * A row changed underneath an open editor. Return `"keep"` or `"take"` to
   * resolve it; return nothing and {@link BaseDataTableProps.editConflictPolicy}
   * decides. The default policy is `"ask"`.
   */
  onEditConflict?: EditConflictHandler<TRow>;
  /**
   * What to do when a live update disagrees with an open editor and the host
   * did not choose. `"ask"` (default) surfaces Keep mine / Take theirs.
   */
  editConflictPolicy?: EditConflictPolicy;
  /**
   * Host version of a row. When set, any version change under an open editor
   * is a conflict, not only a change to the edited column.
   */
  rowVersion?: (row: TRow) => string | number;
  /**
   * Add a row — an Add control appears in the toolbar as soon as this is set.
   * The host makes the row and stores it; it reaches the table through the
   * source like every other row, so it is editable, filterable and counted
   * from the moment it lands.
   */
  onAddRow?: () => unknown;
  /**
   * Copy a row — a Duplicate action appears on every row. What a copy means
   * (which fields carry over, which reset, what id it gets) is the host's.
   */
  onDuplicateRow?: (row: TRow) => unknown;
  /** Remove a row. A Delete row action appears as soon as this is set. */
  onDeleteRow?: (row: TRow) => unknown;
  /**
   * Reorder a row — a drag handle appears in a reserved leading column as
   * soon as this is set. `from` / `to` are dataset-relative (page offset
   * included), and `row` is the one that moved. The table never mutates the
   * array; apply the move with `applyRowReorder` or your own write.
   *
   * Keyboard: Space lifts, arrows move, Space drops, Escape cancels.
   * Grouping or a tree refuses this with a `devWarn` — nested order is not
   * a flat splice. Mobile cards get up/down buttons rather than a grip.
   */
  onRowReorder?: (from: number, to: number, row: TRow) => void;
  /**
   * Controlled row pins. `{ top, bottom }` lists of row ids that render
   * outside the virtual window — sticky above and below the scroll box —
   * so they are not drawn twice. Omit for the internal (uncontrolled)
   * lists. Grouping or a tree refuses this with a `devWarn`.
   *
   * Mobile cards get the same pin actions but no sticky chrome: a card
   * list is not a grid.
   */
  pinnedRowIds?: RowPinState;
  /**
   * Pin-list change channel. Uncontrolled: an observer. Controlled: apply
   * the next lists to accept. Setting this (or {@link BaseDataTableProps.pinnedRowIds})
   * is what arms the feature — omit both and nothing renders.
   */
  onPinnedRowIdsChange?: (next: RowPinState) => void;
  /**
   * Per-cell row/column span. Return `{ colSpan, rowSpan }` for the origin;
   * covered cells are omitted from the row's cell list. Column-level
   * `colSpan` / `rowSpan` on the column def are the same
   * thing when every row of a column shares a rule. Omit both and every
   * kit still maps one cell per column.
   *
   * Mobile cards ignore geometry — a card is a list of fields. Spans are
   * derived from data, so nothing is written to the URL.
   */
  getCellSpan?: GetCellSpan<TRow>;
  /**
   * How a spanned cell is painted. Omit / `"merged"` is the spreadsheet look
   * (centered content, one fill). `"plain"` keeps today's 1×1 chrome so a
   * host can style a calendar-style bar on `data-cell-span`.
   */
  cellSpanAppearance?: CellSpanAppearance;
  /**
   * Host-injected separator and full-width rows, spliced into the body
   * by `beforeRowId`. Omit the list and nothing is inserted. Extras are
   * content, not table state — nothing is written to the URL. Mobile
   * cards keep the same slots.
   */
  extraRows?: readonly ExtraRow[];
  /**
   * Delete without a confirmation dialog. Off by default — a delete is
   * destructive and the table cannot undo it.
   */
  confirmDeleteRow?: boolean;
  /**
   * How an edit is applied to a row for {@link BaseDataTableProps.validateRow}
   * to judge. Defaults to a shallow spread keyed by the column key, which is
   * right when a column key IS the field; pass this when a column reads a
   * nested path.
   */
  applyEdit?: (row: TRow, columnKey: string, value: unknown) => TRow;
  /**
   * Footer summary: map the CURRENT page's rows to per-column summary cells
   * (`{ budget: <b>{total}</b> }`). Rendered as a table footer row aligned
   * under its columns; keys absent from the result render empty cells.
   */
  summaryRow?: (rows: readonly TRow[]) => Partial<Record<string, ReactNode>>;
  /**
   * Free slot under the table (above the pager). Not the column-aligned
   * summary row — that is {@link BaseDataTableProps.summaryRow}.
   */
  tableFooter?: ReactNode;
  /**
   * Row grouping by column key — one key, or an ordered list for nested
   * groups: `groupBy={["team", "status"]}` puts each status inside its team,
   * and every header carries the count and aggregates of its whole subtree.
   *
   * Its presence (or `source.groupBy`) arms grouping chrome — omit it and the
   * table never inserts group header rows (package DNA: opt-in). Frontend tier
   * only; server-paginated sources get a devWarn and grouping is ignored.
   */
  /**
   * Hierarchical rows: a row's children, for nested data.
   *
   * A tree is declared by the DATA — a folder contains files, a task has
   * subtasks — which is why it is not grouping: grouping answers a question
   * the reader asked and re-answers it when they change the question.
   *
   * Its presence arms the tree; omit it (and `getParentId`) and the table
   * renders a flat list exactly as before.
   */
  getChildren?: (row: TRow) => readonly TRow[] | undefined;
  /** Hierarchical rows the other way round: a flat table with a parent column. */
  getParentId?: (row: TRow) => string | undefined;
  /**
   * Whether a row has children that have not been fetched yet — a server tree
   * knows there is more before the browser does.
   */
  hasChildren?: (row: TRow) => boolean;
  /**
   * Which column carries the chevron and the indent. Defaults to the first
   * rendered column, which is where a reader looks for a tree.
   */
  treeColumn?: string;
  /**
   * Fetch a node's children when the reader opens it — a tree of any size
   * arrives one branch at a time. Pair it with `hasChildren` so a node the
   * browser has not fetched still shows a chevron. Resolve once the children
   * are in the data the table reads; the table re-walks the hierarchy itself
   * and needs nothing back. Its node carries a loading flag until then, and a
   * rejection leaves the node closed and clickable so a retry is the same
   * gesture as the first attempt.
   */
  onLoadChildren?: (row: TRow) => void | Promise<void>;
  /** Controlled tree expansion: the ids currently open. */
  expandedIds?: readonly string[];
  /** Fired after the table opens or closes a node. */
  onExpandedIdsChange?: (ids: string[]) => void;
  groupBy?: string | readonly string[] | null;
  /**
   * Notification fired AFTER the grouping change is applied — the table
   * always performs the change itself. Take full control (e.g. a fully
   * controlled `groupBy`) through `source.setGroupBy` instead.
   *
   * Receives the keys as a list, empty when grouping was cleared.
   */
  onGroupByChange?: (groupBy: readonly string[]) => void;
  /**
   * Per-group aggregate cells — **same signature as {@link summaryRow}**.
   * Called with each group's leaf rows. Omit for headers without subtotals.
   */
  /**
   * Close every group with a footer row carrying its aggregates — the totals
   * read at the bottom of the group as well as the top, which is where a long
   * group's reader is by the time they need them.
   *
   * Needs `groupAggregates`: a footer with nothing to total is a blank row.
   * Nested groups each get their own, innermost first. The table's own
   * grand total is `summaryRow`, which already totals the whole set.
   */
  groupFooters?: boolean;
  /**
   * Order groups within their parent: `"label"`, `"label-desc"`, `"count"`,
   * `"count-desc"`, or your own comparator over `{ value, label, level,
   * groupBy, leafRows }`.
   *
   * To sort groups by an aggregate, compare the same rows the aggregate reads
   * — `(a, b) => total(b.leafRows) - total(a.leafRows)` sorts by total
   * descending. Without this, groups keep the order the source's own sort
   * produced.
   */
  groupSort?: GroupSort<TRow>;
  /**
   * Show at most this many top-level groups at a time, with a row offering the
   * rest. A table grouped by customer can have ten thousand groups, and
   * rendering all of them to fill one screen is the mistake virtualization
   * exists to avoid.
   */
  groupPageSize?: number;
  /**
   * Show at most this many rows inside each group, with a "load more in this
   * group" row beneath them.
   */
  groupRowPageSize?: number;
  /**
   * Called when a reader asks for more rows inside a group — the hook a server
   * tier needs, since the rest of that group is not in the browser yet. The
   * table reveals what it already holds either way.
   */
  onGroupLoadMore?: (groupKey: string) => void;
  /**
   * Keep only the groups this answers true for, at every level — the group
   * equivalent of a filter, working on aggregates rather than cells:
   * `(g) => total(g.leafRows) > 10_000`.
   *
   * A dropped group takes its leaves with it. Row filters still run first, so
   * this decides which of the SURVIVING rows' groups are worth showing.
   */
  groupFilter?: (group: GroupNode<TRow>) => boolean;
  groupAggregates?: (rows: readonly TRow[]) => Partial<Record<string, ReactNode>>;
  /**
   * Controlled collapsed group keys (ephemeral — not URL-synced).
   * Uncontrolled: internal {@link useGroupCollapse}.
   */
  collapsedGroupIds?: readonly string[];
  onCollapsedGroupIdsChange?: (ids: string[]) => void;
  /** Disable the built-in search box. */
  /**
   * Render the search input. Positive polarity — `false` hides it.
   * @defaultValue true
   */
  searchable?: boolean;
  /**
   * Opt into multi-column sorting: shift-click (or shift-Enter) on a header
   * adds the column to the sort chain (asc → desc → removed); a plain click
   * still single-sorts. Sorted headers expose `data-sort-index` for badges.
   */
  multiSort?: boolean;
  /** Render the built-in "Columns" menu (show/hide, pin, reorder). */
  enableColumnMenu?: boolean;
  /** Enable drag/keyboard column resize handles. Defaults to false (opt-in). */
  resizableColumns?: boolean;
  /** Controlled column layout (hidden/order/pinned/widths). */
  columnLayout?: ColumnLayoutState;
  /** Change handler for the controlled column layout. */
  onColumnLayoutChange?: (next: ColumnLayoutState) => void;
  /** Initial column layout for the uncontrolled mode. */
  defaultColumnLayout?: Partial<ColumnLayoutState>;
  /**
   * Column-group headers gain a collapse toggle. Each group decides what
   * remains: an arrow stub, `collapsedKey`, or `collapsedRender`. State
   * lives on `columnLayout.collapsedGroups` and the URL (`colGroupCollapse`).
   * Omit and group headers stay static.
   */
  collapsibleColumnGroups?: boolean;
  /**
   * Fixed-height scroll box (px). Enables sideways scrolling + column pinning;
   * the header and pinned columns pin within this box. Omit for page scroll.
   */
  maxHeight?: number;
  /** Virtualize long infinite lists. Defaults to false. */
  virtualize?: boolean;
  /**
   * Window the COLUMNS as well as the rows, for tables that are wide rather
   * than long: a hundred columns render as the two dozen a reader can see,
   * plus a margin, with the rest held open by two spacer cells.
   *
   * Needs a horizontal scroll container, so it applies with `maxHeight` or
   * pinned columns. Pinned columns are never windowed out — they are on screen
   * by definition — and the spacers are logical, so a wide RTL table scrolls
   * the right way.
   *
   * Not available in the Ant Design adapter, which renders through antd's own
   * `<Table>`: that component owns its column rendering, and windowing it from
   * outside would fight it rather than help.
   */
  virtualizeColumns?: boolean;
  /**
   * Make the columns share the container's width instead of overflowing it.
   *
   * Columns with a `flex` take that share of the space; columns with a `width`
   * keep it; everything else divides what is left equally. `minWidth` and
   * `maxWidth` are respected either way, so a column never shrinks below what
   * it needs to be read.
   */
  fitColumns?: boolean;
  /** Desktop row-size estimate in px. */
  estimateRowSize?: number;
  /** Mobile card-size estimate in px. */
  estimateCardSize?: number;
  /** Extra rows/cards rendered before and after the virtual window. */
  virtualOverscan?: number;
  /**
   * Override for window-mode virtualization's scroll offset.
   *
   * When omitted, the list's document offset is measured so a table below
   * page chrome does not open with a blank gap. Pass a value only when you
   * already know that offset (tests, or a table whose position is fixed).
   */
  virtualScrollMargin?: number;
  /**
   * The table's filters. Pass a declarative array and the adapter builds the
   * form with kit-native widgets (each definition also drives URL parsing,
   * chips and — on frontend data — the row predicate); pass JSX to draw the
   * form yourself. Column-level `filter` shorthands merge in; a `filters`
   * entry with the same key wins.
   */
  filters?: readonly FilterDef<TRow>[] | ReactNode;
  /**
   * Extra or replacement filter types merged onto the built-in registry.
   * A spec whose `type` matches a built-in replaces it. Omit and only
   * the built-ins are available.
   */
  filterTypes?: readonly FilterTypeSpec[];
  /**
   * Resolved filter definitions, used to label AND/OR tree chips. The
   * shell sets this from the declarative `filters` array; hosts that
   * call `useTableChrome` directly can pass the same defs the builder
   * receives.
   */
  filterDefs?: readonly FilterDef<TRow>[];
  /**
   * How the filter container opens. One mode at a time — never stacked.
   * `"popover"` (default) anchors a light card under the Filters button
   * (no backdrop); `"drawer"` slides in a side panel with a real backdrop;
   * `"header"` is the compact per-column row and hides the toolbar button.
   * `headerFilters` is an alias for `"header"`.
   */
  filtersMode?: "popover" | "drawer" | "header";
  /** Per-filter-key chip label resolvers. */
  filterLabels?: Readonly<Record<string, ChipLabelResolver>>;
  /** Extra chips driven by non-URL state, merged with the derived chips. */
  extraChips?: readonly ActiveFilterChip[];
  /** Override the active-filter count (defaults to the chip count). */
  activeFilterCount?: number;
  /**
   * Notification fired AFTER the filters are cleared (drawer, chip strip,
   * no-results CTA) — the table always performs the clear itself. Take
   * full control through `source.clearExtras` instead.
   */
  onClearFilters?: () => void;
  /**
   * Alias for `filtersMode="header"`: a per-column filter icon on the
   * header, bound to the same defs and extra bag as the panel. Desktop
   * only. Hides the toolbar Filters button unless `source.setFilterTree`
   * is set (the AND/OR tree has no column of its own). Omit the prop and
   * nothing extra renders.
   */
  headerFilters?: boolean;
  /**
   * Close a header-filter popover after a finished single-control write
   * (a select/boolean value, or a valueless operator such as "Is empty").
   * Off by default — picking an operator on a field that still has a value
   * input must not dismiss the overlay. Outside click and Escape always close.
   */
  closeHeaderFilterOnSelect?: boolean;
  /**
   * Mount the per-field Filters form. Default on. Pass `false` to keep only
   * the AND/OR tree in that chrome — the field list is gone, not hidden.
   */
  filterFields?: boolean;
  /** Bulk actions — enabling these turns on row selection. */
  bulkActions?: BulkAction[];
  /** Selection id extractor; defaults to `rowKey`. */
  selectionGetId?: (row: TRow) => string;
  /**
   * Controlled selection. When provided, the table reads the selection from
   * this value and reports every change request through `onSelectionChange`
   * — the same controlled/uncontrolled split as `columnLayout`. Omit it for
   * the internal (uncontrolled) selection.
   */
  selectedIds?: readonly string[];
  /**
   * Selection change channel. Uncontrolled: an observer that fires with the
   * selected ids whenever the set changes — once on mount with the initial
   * (empty) selection, on every toggle/select-all, and on the automatic
   * reset when the search or a filter changes (the result set changed, so
   * stale ids never linger). Controlled (`selectedIds` provided): the
   * change-request handler — apply the ids to your state to accept.
   */
  onSelectionChange?: (selectedIds: string[]) => void;
  /**
   * Opt-in CSV export toolbar button. Pass `true` for defaults
   * (`export.csv`, current page) or an options object for filename/scope.
   * Omit or `false` to hide the button.
   */
  exportCsv?: boolean | ExportCsvOptions<TRow>;
  /**
   * Opt into keyboard cell navigation.
   *
   * The table becomes ONE tab stop whose interior is reachable by arrow keys,
   * Home/End, Ctrl+Home/End and PageUp/PageDown, with `role="grid"`, absolute
   * `aria-rowindex` / `aria-colindex`, and a live region naming the focused
   * cell. Enter or F2 opens the editor when `onCellEdit` is set.
   *
   * Off by default, and off means absent: no role change, no `tabIndex`, no key
   * handler, no live region. Applies to the desktop table layout — mobile cards
   * are a list, not a grid, and keep their list semantics.
   */
  cellNavigation?: boolean;
  /**
   * Offer a checkbox in every column header that selects that column.
   * Defaults to false, and needs {@link cellNavigation} to do anything.
   *
   * Ctrl/Cmd+click on a header already selects a column, and that gesture is
   * unchanged. It is also unreachable on a touch device — there is no Ctrl key
   * to hold — and undiscoverable to anyone who has not been told about it. This
   * is the same selection behind a control a finger can hit and a screen reader
   * can name. On a hovering pointer it holds its space and fades in on hover or
   * focus, so a wide header row is not a row of checkboxes; where there is no
   * hover it is always visible.
   */
  columnSelectionCheckbox?: boolean;
  /** Inline toolbar slot for custom controls (view toggles, etc.). */
  toolbar?: ReactNode;
  /**
   * Named regions of the toolbar, for controls that have to sit somewhere
   * specific rather than in the middle.
   *
   * `toolbar` is the middle region and stays exactly what it was: content
   * between the search input and the built-in buttons. These two are the
   * ends, which is where an app's own view switcher or a "back" control
   * belongs — ahead of everything, or after it.
   *
   * ```tsx
   * <DataTable
   *   toolbarSlots={{ start: <BackButton />, end: <HelpLink /> }}
   *   …
   * />
   * ```
   */
  toolbarSlots?: ToolbarSlots;
  /**
   * Let the user choose the row density from the toolbar. Defaults to off.
   *
   * The `density` prop is what the table renders; this is the control that
   * changes it. Pair it with `useDensityUrlState` and the choice survives a
   * reload and travels in a shared link.
   */
  densityChooser?: boolean;
  /** Called when the user picks a density. */
  onDensityChange?: (next: "comfortable" | "compact") => void;
  /**
   * A fullscreen toggle in the toolbar. Defaults to off.
   *
   * Fullscreen hides everything outside the table, which is what makes it
   * useful and also what breaks overlays: a menu portalled to
   * `document.body` is inside the part being hidden. The table's own
   * overlays are re-pointed at the fullscreen element while it is on.
   *
   * The button hides itself where the browser will not allow fullscreen at
   * all — an embedded webview, a sandboxed frame — because a control that
   * cannot work is worse than no control.
   */
  fullscreen?: boolean;
  /**
   * Open the print dialog on the current view.
   *
   * What gets printed is the host's: `printTable` opens a browser dialog and
   * `downloadExportFile` cannot, so the table asks and the host decides.
   * Wire this and it becomes a command in the palette and an entry anywhere
   * else commands are listed. Add {@link printButton} for a toolbar control
   * as well — opt-in chrome either way, never a permanent button.
   *
   * ```tsx
   * import { printTable } from "@adapttable/core/pdf";
   *
   * <DataTable onPrint={() => printTable({ rows, columns })} … />
   * ```
   */
  onPrint?: () => void;
  /**
   * A command palette, opened with Cmd/Ctrl+K. Defaults to off.
   *
   * It lists the table's own actions — print, export, clear filters, each
   * appearing only when wired — and anything you add. Its entries are the
   * same objects the context menus take, so an action is written once and
   * offered in both places rather than drifting between them.
   *
   * ```tsx
   * <DataTable
   *   commandPalette={{
   *     commands: [{ key: "audit", label: "Open audit log", onSelect: open }],
   *     shortcuts: [{ chord: "ctrl+shift+p", command: "command-palette" }],
   *   }}
   *   …
   * />
   * ```
   */
  commandPalette?: boolean | CommandPaletteOptions;
  /**
   * Right-click menus for headers, rows and cells. Defaults to off.
   *
   * `true` takes the built-in entries — sort, filter, pin and hide on a
   * header; copy and cut on a cell — each appearing only when the handler
   * behind it is wired and the column allows it. Pass `{ items }` to append
   * your own, which land behind a divider so a custom action is never
   * mistaken for a built-in one.
   *
   * Every route in works: right-click, Shift+F10 and the menu key for the
   * keyboard, and a long press for touch. Escape closes and puts focus back
   * where it came from.
   */
  contextMenu?: boolean | ContextMenuOptions<TRow>;
  /**
   * Dock a settings panel beside the table.
   *
   * A popover is right for a control you touch once. It is wrong for
   * setting a table up — choosing columns, building a filter — because
   * that is iterative, and a popover closes when you look away with the
   * rows behind it. Omit this and nothing renders and nothing is bundled.
   *
   * ```tsx
   * const [panel, setPanel] = useState<string | null>(null);
   *
   * <DataTable
   *   toolbarSlots={{
   *     end: <button onClick={() => setPanel("filters")}>Settings</button>,
   *   }}
   *   sidePanel={{
   *     panels: [{ key: "filters", label: "Filters", content: <MyFilters /> }],
   *     open: panel,
   *     onOpenChange: setPanel,
   *   }}
   *   …
   * />
   * ```
   */
  sidePanel?: SidePanelOptions;
  /**
   * Show a status bar under the table. Defaults to false.
   *
   * It reads how many rows are on screen, how many are selected, and what
   * a multi-cell selection adds up to — the line a spreadsheet user
   * glances at without thinking. The sums appear only with
   * `selectionStats` armed; the counts are always there.
   */
  statusBar?: boolean;
  /**
   * Show Undo and Redo buttons in the toolbar. Defaults to false.
   *
   * The keyboard shortcuts and `table.editHistory` are the always-on path
   * — this is the visible one, for an app whose users will not find
   * Ctrl+Z. The buttons render only when `editHistory` is armed, and
   * disable rather than disappear when there is nothing to undo or redo,
   * so the toolbar does not change width as the user works.
   */
  undoRedoButtons?: boolean;
  /**
   * Show a Print button in the toolbar. Defaults to false.
   *
   * The palette command is the always-on path once {@link onPrint} is wired
   * — this is the visible one, for an app whose users will not reach for
   * Cmd/Ctrl+K. It renders only when both are set: a button that opens
   * nothing would be worse than no button, so the option alone draws
   * nothing and the handler alone stays a command.
   */
  printButton?: boolean;
  /** Confirmation handler for actions; defaults to `window.confirm`. */
  confirm?: ConfirmHandler;
  /** Number of skeleton rows while loading. Defaults to the page size. */
  skeletonRows?: number;
  /**
   * Top inset in px for the sticky header (`stickyHeader`) — e.g. the
   * height of an app bar it must clear. When the toolbar pins with the
   * header it parks at this inset too. Defaults to 0.
   */
  stickyTop?: number;
  /** Keep the desktop table header sticky while scrolling. Defaults to false (opt-in). */
  stickyHeader?: boolean;
  /**
   * Keep the toolbar (search, page size) sticky with the header.
   * Defaults to `stickyHeader` on page-scroll tables; pass `false` to
   * let the toolbar scroll away. Has no effect when the table already
   * scrolls in a box (`maxHeight`, or antd's native virtual scroller) —
   * the toolbar already sits outside that scroller.
   */
  stickyToolbar?: boolean;
  /** Scroll back to the table when search/filter/page changes. Defaults to true. */
  scrollToTopOnChange?: boolean;
  /** Extra gap below sticky chrome when scrolling back. Defaults to 8. */
  scrollTopGap?: number;
}
//#endregion
//#region src/rows/useHighlight.d.ts
/** One highlighted cell. */
interface HighlightedCell {
  rowId: string;
  columnKey: string;
}
/** What {@link useHighlight} returns. */
interface HighlightState {
  /** Mark a row. Repeating it restarts the clock rather than stacking. */
  flashRow: (rowId: string) => void;
  /** Mark one cell. */
  flashCell: (cell: HighlightedCell) => void;
  /** Drop every mark now. */
  clear: () => void;
  /** Whether this row is marked. */
  isRowHighlighted: (rowId: string) => boolean;
  /** Whether this cell is marked. */
  isCellHighlighted: (rowId: string, columnKey: string) => boolean;
  /**
   * Whether the mark should animate. False when the user asked for reduced
   * motion — the mark still appears, it simply does not move.
   */
  animated: boolean;
}
/**
 * Highlight rows and cells for a moment.
 *
 * @param enabled - Off unless the host asked; every call is then inert.
 * @returns The controls and the current marks.
 */
declare function useHighlight(enabled: boolean): HighlightState;
//#endregion
//#region src/source/queryKey.d.ts
/** Options for {@link tableQueryKey} and {@link tableQueryBaseKey}. */
interface TableQueryKeyOptions {
  /**
   * Namespace for this table, so two tables on one page never share a cache
   * entry. Defaults to `"table"` — name it when there is more than one.
   */
  scope?: string;
}
/**
 * The key for one page of a view: stable across renders, distinct per page.
 *
 * @param query - The query the table emitted.
 * @param options - See {@link TableQueryKeyOptions}.
 */
declare function tableQueryKey(query: TableQuery, options?: TableQueryKeyOptions): readonly unknown[];
/**
 * The key shared by every page of a view — what to invalidate after a write.
 *
 * @param query - The query the table emitted.
 * @param options - See {@link TableQueryKeyOptions}.
 */
declare function tableQueryBaseKey(query: TableQuery, options?: TableQueryKeyOptions): readonly unknown[];
//#endregion
//#region src/url/useDensityUrlState.d.ts
/** The two layouts a table has. */
type Density = "comfortable" | "compact";
/** What {@link useDensityUrlState} needs. */
interface UseDensityUrlStateOptions {
  urlAdapter?: UrlStateAdapter;
  urlSync?: boolean;
  urlKey?: string;
  /** The density before anyone has chosen one. Defaults to comfortable. */
  defaultDensity?: Density;
}
/** The controlled pair to spread onto the table. */
interface UseDensityUrlStateResult {
  density: Density;
  onDensityChange: (next: Density) => void;
}
/**
 * Keep the table's density in the URL.
 *
 * @param options - See {@link UseDensityUrlStateOptions}.
 * @returns The controlled pair to spread onto the table.
 */
declare function useDensityUrlState(options?: UseDensityUrlStateOptions): UseDensityUrlStateResult;
//#endregion
//#region src/editing/editHistory.d.ts
/** One undoable gesture: what it wrote, and what was there before. */
interface EditHistoryEntry<TRow> {
  /** The edits the gesture made, in the order it made them. */
  redo: readonly CellEdit<TRow>[];
  /** The values those cells held before it — the inverse, in the same order. */
  undo: readonly CellEdit<TRow>[];
}
/** What {@link useEditHistory} needs. */
interface UseEditHistoryOptions<TRow> {
  /** Off unless the host asked for it; when false nothing is recorded. */
  enabled: boolean;
  /** How many gestures to remember. Defaults to 50. */
  depth?: number;
  /** The columns, for reading a cell's value before it changes. */
  columns: readonly ColumnDef<TRow>[];
  /** The host's commit channel — every replay goes back out through it. */
  onCellEdit?: (row: TRow, key: string, nextValue: unknown) => unknown;
}
/** What {@link useEditHistory} returns. */
interface EditHistoryState<TRow> {
  /**
   * Whether the host armed a history at all.
   *
   * `canUndo` answers "is there something to put back", which is false
   * both when the feature is off and when nothing has been edited yet.
   * Chrome that should not exist without a history needs the other
   * question, and this is it.
   */
  enabled: boolean;
  /** Whether anything can be undone right now. */
  canUndo: boolean;
  /** Whether anything can be redone right now. */
  canRedo: boolean;
  /**
   * Put the last gesture back, through the host's own commit channel.
   *
   * @returns How many cells were restored; zero when there was nothing to undo.
   */
  undo: () => number;
  /**
   * Do the last undone gesture again.
   *
   * @returns How many cells were rewritten; zero when there was nothing to redo.
   */
  redo: () => number;
  /** Forget everything — what a host calls when the data is replaced. */
  clear: () => void;
  /**
   * Record a batch as ONE gesture and apply it. Returns the edits so a caller
   * can keep chaining; applies nothing when history is off, in which case the
   * caller's own handler still runs.
   */
  record: (edits: readonly CellEdit<TRow>[]) => void;
}
/**
 * The value a cell holds right now, unstringified.
 *
 * The editor's seed is a string because an input needs one; an undo needs the
 * VALUE, so that putting back the number 10 does not put back `"10"`. Same
 * priority the editor uses otherwise: an explicit `editValue`, then
 * `sortValue`, then the key's data path.
 *
 * @typeParam TRow - The row type.
 * @param row - The row being read.
 * @param column - The column being read.
 * @returns The current value, in whatever type the row holds it.
 */
declare function readCellValue<TRow>(row: TRow, column: ColumnDef<TRow>): unknown;
/**
 * Remember edits so they can be replayed backwards.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseEditHistoryOptions}.
 * @returns The history controls; inert when `enabled` is false.
 */
declare function useEditHistory<TRow>(options: UseEditHistoryOptions<TRow>): EditHistoryState<TRow>;
/** The props a table needs for its history — the `editHistory` prop, resolved. */
interface TableEditHistoryProps<TRow> {
  /** The `editHistory` prop as the host wrote it. */
  editHistory?: boolean | {
    depth?: number;
  };
  /** The columns, for reading a cell's value before it changes. */
  columns: readonly ColumnDef<TRow>[];
  /** The host's commit channel. */
  onCellEdit?: (row: TRow, key: string, nextValue: unknown) => unknown;
}
/**
 * The history a `<DataTable>` runs, plus the commit channel to hand the chrome.
 *
 * The returned `onCellEdit` records each inline commit as a one-cell gesture
 * before passing it on. Batch routes (paste, fill) must NOT go through it —
 * they record themselves through {@link asGesture}, so that two hundred pasted
 * cells undo in one press rather than two hundred.
 *
 * Both the shell and the antd adapter build their chrome this way, and this is
 * the one place the rule lives.
 *
 * @typeParam TRow - The row type.
 * @param props - See {@link TableEditHistoryProps}.
 * @returns The history state and the commit channel to give the chrome.
 */
declare function useTableEditHistory<TRow>(props: TableEditHistoryProps<TRow>): {
  history: EditHistoryState<TRow>;
  onCellEdit: ((row: TRow, key: string, nextValue: unknown) => unknown) | undefined;
};
/**
 * Wrap a batch handler so the whole batch is one undo entry.
 *
 * Recording happens before the handler runs: the inverse is read from the rows
 * as they are NOW, and a host that applies the edits synchronously would
 * otherwise have already changed them.
 *
 * @typeParam TRow - The row type.
 * @param apply - The resolved handler, or `undefined` when nothing receives it.
 * @param record - The history recorder.
 * @returns The wrapped handler, or `undefined` when there was none to wrap.
 */
declare function asGesture<TRow>(apply: ((edits: CellEdit<TRow>[]) => void) | undefined, record: (edits: readonly CellEdit<TRow>[]) => void): ((edits: CellEdit<TRow>[]) => void) | undefined;
//#endregion
//#region src/rows/rowMutations.d.ts
/** How a table asks for a row to be added, copied or removed. */
interface RowMutationHandlers<TRow> {
  /**
   * Add a row. Setting this puts an Add control in the toolbar; the host makes
   * the row and stores it, and it reaches the table through the source like
   * every other row — editable, filterable and countable from the moment it
   * lands, with nothing about it special.
   */
  onAddRow?: () => unknown;
  /**
   * Copy a row. Setting this puts a Duplicate action on every row; what a copy
   * means — which fields carry over, which are reset, what id it gets — is the
   * host's, because only the host knows.
   */
  onDuplicateRow?: (row: TRow) => unknown;
  /**
   * Remove a row. Setting this puts a Delete action on every row, behind a
   * confirmation dialog unless {@link RowMutationHandlers.confirmDeleteRow} is
   * `false`.
   */
  onDeleteRow?: (row: TRow) => unknown;
  /**
   * Delete without asking first. Off by default: a delete is destructive and
   * the table cannot undo it. Hosts whose own UI already confirms — or whose
   * delete is reversible — turn it off.
   */
  confirmDeleteRow?: boolean;
}
/** Row-mutation state: the toolbar's control and the per-row actions. */
interface RowMutationsState<TRow> {
  /** Whether an Add control should render. */
  canAdd: boolean;
  /** Ask for a new row. Inert without `onAddRow`. */
  addRow: () => void;
  /**
   * Duplicate and Delete, in that order — empty when the host wired neither.
   * Appended to the host's own `rowActions`, so a delete stays last.
   */
  actions: readonly RowAction<TRow>[];
}
/** What {@link useRowMutations} needs. */
interface UseRowMutationsOptions<TRow> extends RowMutationHandlers<TRow> {
  /** Resolved labels, for the action names and the delete dialog. */
  labels: Required<TableLabels>;
}
/** The key of the synthesized duplicate action. */
declare const DUPLICATE_ROW_ACTION_KEY = "adapttable:duplicate-row";
/** The key of the synthesized delete action. */
declare const DELETE_ROW_ACTION_KEY = "adapttable:delete-row";
/**
 * Headless add / duplicate / delete wiring.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseRowMutationsOptions}.
 * @returns The state; every action is absent until its handler is wired.
 */
declare function useRowMutations<TRow>(options: UseRowMutationsOptions<TRow>): RowMutationsState<TRow>;
//#endregion
//#region src/useTableChrome.d.ts
/**
 * The shared prop surface every adapter's toolbar sub-component needs.
 * Adapters render kit-specific markup from this; extracting it keeps the
 * identical shape from being re-declared (and flagged as duplication) in
 * each adapter.
 *
 * @typeParam TRow - The row type.
 */
interface ToolbarChromeProps<TRow> {
  /** The headless table state + prop-getters. */
  table: UseDataTableResult<TRow>;
  /** Render the search input (default `true`). */
  searchable?: boolean;
  /** Placeholder for the search input. */
  searchPlaceholder?: string;
  /** Options for an explicit sort-by control. */
  sortByOptions?: SortByOption[];
  /** Extra caller-supplied toolbar content, in the middle region. */
  toolbar?: ReactNode;
  /** Caller-supplied content for the two ends of the toolbar. */
  toolbarSlots?: ToolbarSlots;
  /**
   * Put the last edit back. Set only when the host asked for the buttons
   * (`undoRedoButtons`) AND `editHistory` is armed, so an adapter renders
   * the pair on presence and never has to check two things.
   */
  onUndo?: () => void;
  /** Do the last undone edit again. Present with {@link onUndo}. */
  onRedo?: () => void;
  /**
   * Whether there is anything to undo. The button is disabled, not
   * hidden — a control that vanishes moves the ones beside it, and a
   * toolbar that reflows while someone is working is worse than a button
   * that is briefly unavailable.
   */
  canUndo?: boolean;
  /** Whether there is anything to redo. */
  canRedo?: boolean;
  /** `labels.undoEdit` — the undo button's caption. */
  undoLabel?: string;
  /** `labels.redoEdit` — the redo button's caption. */
  redoLabel?: string;
  /**
   * Open the print dialog. Set only when the host asked for the button
   * (`printButton`) AND wired `onPrint`, so an adapter renders on presence
   * and never has to check two things.
   */
  onPrint?: () => void;
  /** `labels.print` — the print button's caption. */
  printLabel?: string;
  /** The density the table is rendering, when the chooser is shown. */
  density?: "comfortable" | "compact";
  /** Change it. Present iff the host asked for the chooser. */
  onDensityChange?: (next: "comfortable" | "compact") => void;
  /** Toggle fullscreen. Present iff asked for AND the browser allows it. */
  onToggleFullscreen?: () => void;
  /** Whether the table is fullscreen right now, for the button's state. */
  isFullscreen?: boolean;
  /** Whether a filters affordance should render. */
  hasFilters: boolean;
  /** Number shown on the filters badge. */
  activeFilterCount: number;
  /** Whether the filter container is open (drives `aria-expanded`). */
  filtersOpen: boolean;
  /** Toggle the filter container (popover and drawer alike). */
  onToggleFilters: () => void;
  /**
   * Bind to the trigger's `onPointerDown` (see
   * {@link useFilterTriggerToggle}) so a click on the open trigger CLOSES
   * the popover instead of racing the kit's outside-close and reopening.
   */
  onFiltersTriggerPointerDown?: () => void;
  /** Whether to show the rows-per-page control (infinite mode). */
  showRowsPerPage: boolean;
  /**
   * Built saved-views menu node, when the `savedViews` prop opts in. Renders
   * ahead of {@link columnMenu} so every adapter's toolbar reads
   * Filters · Saved views · Columns · Export CSV.
   */
  savedViewsMenu?: ReactNode;
  /** Built column-menu node, when `enableColumnMenu` is set. */
  columnMenu?: ReactNode;
  /**
   * When set, render the Export CSV toolbar button and call this on click.
   * Built by {@link makeExportCsvHandler} from the `exportCsv` prop.
   */
  onExportCsv?: () => void;
  /**
   * True while a host-handled export (`exportCsv.request`) is still running.
   *
   * Adapters disable the Export button and mark it busy, so the same export
   * cannot be started twice and the user can see that something is happening.
   * Always false for the built-in browser export, which is synchronous.
   */
  exportBusy?: boolean;
  /**
   * What the last export did — `"idle"`, `"busy"`, `"done"` or `"failed"` —
   * for a kit whose button shows more than a spinner.
   */
  exportStatus?: ExportStatus;
  /**
   * Live-region text for the last export's outcome, empty until there is one.
   * Adapters render it through `ExportAnnouncer` beside the button: a download
   * is silent, so without it a screen-reader user cannot tell a finished export
   * from a failed one.
   */
  exportAnnouncement?: string;
  /**
   * The export button's caption, naming the format it produces — CSV by
   * default, the writer's format otherwise, localized either way. Adapters
   * render this rather than `labels.exportCsv`, so a button never names a file
   * the user is not getting.
   */
  exportLabel?: string;
  /**
   * When set, render an Add-row control and call this on click. Present iff
   * the host wired `onAddRow`, so the toolbar needs no second guard.
   */
  onAddRow?: () => void;
  /** The Add control's caption, already localized. */
  addRowLabel?: string;
  /** Text direction, for adapters whose toolbar needs explicit RTL hints. */
  dir?: "ltr" | "rtl";
}
/**
 * The shared prop surface every adapter's bulk-action bar needs. Extracted
 * so the identical shape isn't re-declared (and flagged as duplication) in
 * each adapter's chrome.
 */
interface BulkBarChromeProps {
  /** Current selection state. */
  selection: SelectionState;
  /**
   * Total rows in the filtered set — drives the "select all N matching"
   * banner when a full page is selected and more rows match elsewhere.
   */
  total: number;
  /** Caller-supplied bulk actions. */
  bulkActions: BulkAction[];
  /** Confirmation handler for actions that declare a `confirm` block. */
  confirm: ConfirmHandler;
  /** Resolved labels. */
  labels: Required<TableLabels>;
}
/**
 * Which body region a `DataTable` should render. Named `TableBodyRegion`
 * (not `TableBody`) so it never collides with MUI's `TableBody` component
 * in consumer imports.
 */
type TableBodyRegion = "skeleton" | "empty" | "mobile" | "desktop";
/** The shared, UI-agnostic orchestration result for an adapter table. */
interface TableChrome<TRow> {
  /**
   * The source as the VIEW sees it. Identical to the caller's source —
   * except with grouping armed, where the table renders the full filtered
   * set and this facade presents that set (full rows, one page, matching
   * total) so footer numbers, select-all scope and page-scope CSV export
   * agree with the screen. Adapters read THIS, never the raw source.
   */
  source: TableSource<TRow>;
  /** The headless table state + prop-getters. */
  table: UseDataTableResult<TRow>;
  /** Resolved mobile layout flag. */
  isMobile: boolean;
  /** Resolved confirmation handler. */
  confirm: ConfirmHandler;
  /** Row id extractor (selection id, falling back to rowKey). */
  getRowId: (row: TRow) => string;
  /** Derived chips: label-driven merged with caller `extraChips`. */
  mergedChips: readonly ActiveFilterChip[];
  /** Active filter count (override, or merged chip count). */
  activeFilterCount: number;
  /** Whether the resolved pagination mode is `"paged"`. */
  isPaged: boolean;
  /**
   * The table root. Owned here so the width that drives progressive column
   * hiding is measured on the table itself, in both wiring paths.
   */
  rootRef: RefObject<HTMLDivElement | null>;
  /** Column keys progressive hiding gave up at the current width. */
  droppedColumns: readonly string[];
  /** Which body region to render. */
  body: TableBodyRegion;
  /**
   * The load failure to show in place of the body, or `undefined` when the
   * source is fine. Derived here so every adapter offers a retry on exactly
   * the same terms — one the source can actually perform.
   */
  errorState?: TableErrorState;
  /**
   * Why the body is empty: `"noResults"` when an active search/filter
   * produced zero rows (offer a clear-filters CTA), `"noData"` when the
   * source itself is empty. Only meaningful while `body === "empty"`.
   */
  emptyVariant: "noData" | "noResults";
  /**
   * A background refresh is in flight (`isFetching` without `isLoading`):
   * rows on screen are potentially stale. Adapters show a subtle,
   * non-blocking indicator (thin progress bar / `aria-busy`).
   */
  isRefreshing: boolean;
  /**
   * Clear-filters handler: the caller's `onClearFilters`, falling back to
   * `source.clearExtras` — so chips, the drawer and the no-results CTA can
   * always offer a working "clear".
   */
  clearFilters: () => void;
  /**
   * Row-detail bundle — present iff `renderRowDetail` is set, so ONE guard
   * narrows both the renderer and the expansion state (no correlated
   * optionals to re-check).
   */
  detail?: {
    /** The caller's detail-panel renderer. */render: (row: TRow) => ReactNode; /** Expansion state for the chevrons. */
    expansion: RowExpansionState;
  };
  /**
   * Inline editing bundle — present iff either channel is set (`onCellEdit`
   * for per-cell commits, `rowEditing` + `onRowEdit` for row-level ones), so
   * ONE guard narrows the host channel, the state machine, validation, save
   * state, dirty marks and row mode. Pass neither and editing stays fully
   * dormant: no UI, no keyboard.
   */
  editing?: EditableCellEditing<TRow>;
  /**
   * Adding, duplicating and deleting rows. Always present: `canAdd` says
   * whether the toolbar's Add control renders, and the duplicate and delete
   * actions are already folded into {@link TableChrome.rowActions}, so an
   * adapter that renders row actions gets both for free.
   */
  rowMutations: RowMutationsState<TRow>;
  /**
   * The row actions to render — the host's, plus duplicate and delete when
   * those are wired, and `undefined` when the reader hid the actions column.
   * Adapters read THIS rather than the `rowActions` prop.
   */
  rowActions?: RowAction<TRow>[];
  /**
   * Whether an actions column exists at all, hidden or not — what the column
   * menu offers, and the one figure a hidden column must not change.
   */
  hasRowActions: boolean;
  /**
   * Whether a reorder column exists at all, hidden or not — what the column
   * menu offers. False when grouping or a tree is armed (reorder is refused).
   */
  hasRowReorder: boolean;
  /**
   * Headless row-reorder state. Present iff the host passed `onRowReorder`,
   * grouping/tree are off, and the column is visible. Adapters read THIS.
   */
  rowReorder?: RowReorderState<TRow>;
  /**
   * Headless row-pin state. Present iff the host passed `pinnedRowIds` or
   * `onPinnedRowIdsChange`, and grouping/tree are off.
   */
  rowPinning?: RowPinningState<TRow>;
  /**
   * Tree bundle — present iff the host declared a hierarchy (`getChildren` or
   * `getParentId`). A tree and a grouping are different models and can both be
   * dormant; a table that arms both renders the tree, since the rows' own
   * shape outranks a derived one.
   */
  tree?: {
    /** The flattened hierarchy, in render order. */entries: readonly TreeEntry<TRow>[]; /** Which nodes are open. */
    expansion: TreeExpansionState; /** Which column carries the chevron and the indent. */
    columnKey?: string;
  };
  /**
   * Row-grouping bundle — present iff an effective `groupBy` is set AND the
   * source can supply a full filtered set (`allFilteredRows`). Omit
   * `groupBy` and grouping stays fully dormant (package DNA: opt-in).
   */
  grouping?: {
    /** The grouping keys in order — one entry for a flat group, more for nested. */groupBy: readonly string[];
    collapsed: GroupCollapseState;
    aggregates?: GroupAggregatesFn<TRow>; /** Flat group-header + leaf entries for adapters to render. */
    entries: readonly GroupedFlatEntry<TRow>[];
    setGroupBy: (key: GroupByInput) => void; /** Open every group. */
    expandAll: () => void; /** Close every group, at every level. */
    collapseAll: () => void;
    /**
     * Show the tree down to `depth` and no further — `0` leaves only the
     * outermost headers, `1` opens the first level inside them.
     */
    collapseToDepth: (depth: number) => void; /** Reveal the next page of groups, or of one group's rows. */
    showMore: (entry: {
      scope: "groups" | "rows";
      groupKey?: string;
    }) => void;
  };
  /**
   * The rows the editing layer must treat as present: the grouped leaf set
   * (in render order) while grouping renders the full filtered set, the
   * page slice otherwise. Adapters pass THIS — never `source.rows` — as the
   * `rows` context for editable cells, so an edit on a row outside the
   * current page slice survives and Tab-advance follows the rendered order.
   */
  editingRows: readonly TRow[];
  /** Whether the paged footer should render. */
  showFooter: boolean;
  /** User column-layout state + mutators (visibility, order, …). */
  columnLayout: UseColumnLayoutResult<TRow>;
  /** Tree groups for the declared columns — collapse options, header align. */
  columnGroups: ReadonlyMap<string, ColumnGroupRecord<TRow>>;
  /** All declared columns (pre layout/device filtering) for the column menu. */
  allColumns: ColumnDef<TRow>[];
  /**
   * Opted-in features that cannot run. Empty when everything the host
   * asked for can. Adapters show these on the status bar (when it is
   * on) and as `data-adapttable-notices` on the root; the matching
   * control already looks off, disabled, or one-page.
   */
  featureNotices: readonly FeatureNotice[];
}
/**
 * Run the shared orchestration every adapter `<DataTable>` needs: resolve
 * the layout + confirm handler, build the headless table, merge filter
 * chips, compute the active-filter count, and decide which body region and
 * footer to show. Adapters then render their kit-specific markup from this.
 *
 * @typeParam TRow - The row type.
 * @param props - The adapter's {@link BaseDataTableProps}.
 * @returns The {@link TableChrome} orchestration result.
 */
/**
 * The undo/redo half of a toolbar's props, or nothing at all.
 *
 * Two conditions have to hold — the host asked for the buttons, and there
 * is a history for them to drive — and resolving both here means an
 * adapter renders the pair on `onUndo` being present and never has to
 * know that `editHistory` exists. Off, the object is empty and the props
 * are absent, which is what keeps an opted-out toolbar identical.
 */
/**
 * The density chooser and the fullscreen toggle, or nothing.
 *
 * Both resolve to present-or-absent rather than present-and-disabled, so an
 * adapter renders on presence. The fullscreen half folds in whether the
 * browser will allow it at all: a toggle that cannot work is worse than no
 * toggle, and an embedded webview is a real place where it cannot.
 */
interface ViewControlsToolbar {
  density?: "comfortable" | "compact";
  onDensityChange?: (next: "comfortable" | "compact") => void;
  onToggleFullscreen?: () => void;
  isFullscreen?: boolean;
}
declare function viewControlsToolbar(props: {
  densityChooser?: boolean;
  density?: "comfortable" | "compact";
  onDensityChange?: (next: "comfortable" | "compact") => void;
  fullscreen?: boolean;
}, fullscreen: {
  supported: boolean;
  active: boolean;
  toggle: () => void;
}): ViewControlsToolbar;
declare function undoRedoToolbar<TRow>(wanted: boolean | undefined, history: EditHistoryState<TRow>, labels: TableLabels): Partial<ToolbarChromeProps<TRow>>;
/** The print button's half of a toolbar's props. */
interface PrintToolbar {
  onPrint?: () => void;
  printLabel?: string;
}
/**
 * The print button's half of a toolbar's props, or nothing at all.
 *
 * Two conditions again — the host asked for the button, and there is a handler
 * for it to call — resolved here so an adapter renders on `onPrint` being
 * present. `onPrint` alone stays what it has always been: a palette command.
 *
 * Not generic, unlike {@link undoRedoToolbar}: neither prop mentions the row
 * type, and a `Partial<ToolbarChromeProps<TRow>>` return with no `TRow` in the
 * arguments infers `unknown` and widens the whole spread at every call site.
 */
declare function printToolbar(wanted: boolean | undefined, onPrint: (() => void) | undefined, labels: TableLabels): PrintToolbar;
declare function useTableChrome<TRow>(props: BaseDataTableProps<TRow>): TableChrome<TRow>;
/** Result of {@link useChromeBodyData}. */
interface ChromeBodyData<TRow> {
  /** Row/card window virtualization state (disabled unless eligible). */
  virtualization: TableVirtualization<TRow>;
  /**
   * When grouping is armed, the (possibly virtual-windowed) flat entries
   * adapters should render. `undefined` when grouping is dormant.
   */
  groupingEntries?: readonly GroupedFlatEntry<TRow>[];
  /**
   * When a tree is armed, the (possibly virtual-windowed) entries adapters
   * should render. `undefined` when the table is flat.
   */
  treeEntries?: readonly TreeEntry<TRow>[];
  /** Sentinel ref that auto-loads the next page in infinite mode. */
  loadMoreRef: RefObject<HTMLDivElement | null>;
  /** Whether the load-more affordance applies (infinite mode, no error). */
  canLoadMore: boolean;
  /**
   * Attach to the `maxHeight` scroll box (when one renders) so the virtual
   * window tracks the box's scrolling instead of the page's. Harmless to
   * attach when virtualization is off.
   */
  virtualScrollRef: RefCallback<HTMLElement>;
  /** Top-pinned rows, removed from the virtual window. */
  pinnedTopRows: readonly TRow[];
  /** Bottom-pinned rows, removed from the virtual window. */
  pinnedBottomRows: readonly TRow[];
}
/**
 * The shared data-flow wiring between {@link useTableChrome} and an
 * adapter's body: window virtualization (eligible only for real rows in
 * infinite mode) and the infinite-scroll sentinel. Extracted because four
 * adapters repeated this block verbatim; antd opts out (it scrolls inside
 * its own `<Table>` container).
 *
 * @typeParam TRow - The row type.
 * @param chrome - The {@link useTableChrome} result.
 * @param props - The adapter's {@link BaseDataTableProps}.
 * @returns Virtualization state + the load-more sentinel.
 */
declare function useChromeBodyData<TRow>(chrome: TableChrome<TRow>, props: BaseDataTableProps<TRow>): ChromeBodyData<TRow>;
/**
 * The shared scroll-restoration wiring every adapter `<DataTable>` needs:
 * when search / sort / page / filters change, scroll the table back below
 * the sticky chrome. Extracted so the identical block isn't repeated (and
 * flagged as duplication) in each adapter.
 *
 * @typeParam TRow - The row type.
 * @param ref - The adapter's root element.
 * @param chrome - The {@link useTableChrome} result.
 * @param props - The adapter's {@link BaseDataTableProps}.
 */
declare function useChromeScrollReset<TRow>(ref: RefObject<HTMLElement | null>, chrome: TableChrome<TRow>, props: BaseDataTableProps<TRow>): void;
/** Pointer/click handlers returned by {@link useFilterTriggerToggle}. */
interface FilterTriggerToggle {
  onPointerDown: () => void;
  onClick: () => void;
}
declare function useFilterTriggerToggle(open: boolean, setOpen: (next: boolean | ((current: boolean) => boolean)) => void): FilterTriggerToggle;
//#endregion
//#region src/utils/humanizeKey.d.ts
/**
 * Default column-header text from a key: the last dot-path segment, split on
 * camelCase / snake_case / kebab-case boundaries and title-cased.
 * `"hiredAt"` → `"Hired At"`, `"department.name"` → `"Name"`,
 * `"first_name"` → `"First Name"`. An empty/undefined `key` returns `""` so a
 * transiently-malformed column key can never crash a render.
 */
declare function humanizeKey(key: string): string;
//#endregion
//#region src/utils/localeTag.d.ts
/**
 * ONE locale-tag resolution for everything locale-shaped: label presets
 * (`@adapttable/i18n`) and per-column `i18n` data paths resolve through
 * the same rules, so `locale="ar_EG"` can never pick Arabic labels while
 * missing the Arabic column paths.
 */
/** Normalize a BCP-47-ish tag: trim, `_` → `-`, lower-case. */
declare function normalizeLocaleTag(locale: string): string;
/**
 * Resolve a locale against a set of available tags: the exact tag first
 * (case- and separator-insensitive), then its primary subtag. Returns the
 * ORIGINAL available tag so callers can index their own maps with it.
 */
declare function resolveLocaleTag(available: Iterable<string>, locale: string): string | undefined;
//#endregion
//#region src/utils/path.d.ts
/**
 * Safe dot-path lookup: `getPath(row, "department.name")`. Returns
 * `undefined` for any missing segment instead of throwing, so declarative
 * column keys can reach nested API payloads without optional-chaining
 * ceremony in user code. Also tolerates an empty/undefined `path` (returns
 * `undefined`) so a transiently-malformed column key can never crash a render.
 */
declare function getPath(value: unknown, path: string): unknown;
//#endregion
//#region src/url/routerAdapter.d.ts
/** What {@link routerUrlAdapter} needs from the router. */
interface RouterUrlAdapterOptions {
  /**
   * The current query string, WITHOUT the leading `"?"`. Must come from the
   * router's own reactive source — `useSearchParams().toString()`,
   * `location.search.slice(1)` — so it changes when the route does.
   */
  search: string;
  /**
   * Go to a new query string. `push` adds a history entry; the default is a
   * replace, because a table's every keystroke is not a page a user wants to
   * walk back through.
   */
  navigate: (search: string, options: {
    push: boolean;
  }) => void;
}
/**
 * Build a `UrlStateAdapter` from a router's search string and navigate.
 *
 * Memoize it on `search` — the adapter is a value, and rebuilding it is how
 * the table learns the route changed.
 *
 * @example React Router
 * ```tsx
 * const [params] = useSearchParams();
 * const navigate = useNavigate();
 * const adapter = useMemo(
 *   () =>
 *     routerUrlAdapter({
 *       search: params.toString(),
 *       navigate: (search, { push }) =>
 *         navigate({ search }, { replace: !push }),
 *     }),
 *   [params, navigate]
 * );
 * ```
 *
 * @example Next.js App Router
 * ```tsx
 * const searchParams = useSearchParams();
 * const pathname = usePathname();
 * const router = useRouter();
 * const adapter = useMemo(
 *   () =>
 *     routerUrlAdapter({
 *       search: searchParams.toString(),
 *       navigate: (search, { push }) => {
 *         const url = search ? `${pathname}?${search}` : pathname;
 *         (push ? router.push : router.replace)(url, { scroll: false });
 *       },
 *     }),
 *   [searchParams, pathname, router]
 * );
 * ```
 *
 * @param options - The router's current search, and how to navigate.
 * @returns An adapter to hand the table as `urlAdapter`.
 */
declare function routerUrlAdapter({
  search,
  navigate
}: RouterUrlAdapterOptions): UrlStateAdapter;
//#endregion
//#region src/url/useColumnLayoutUrlState.d.ts
/** Options for {@link useColumnLayoutUrlState}. */
interface UseColumnLayoutUrlStateOptions {
  /** URL-state backend. Defaults to the browser History API. */
  urlAdapter?: UrlStateAdapter;
  /** When `false`, keep the layout in a local memory store. Defaults `true`. */
  urlSync?: boolean;
  /** Layout applied when the URL carries no column layout yet. */
  defaultColumnLayout?: Partial<ColumnLayoutState>;
  /**
   * Namespace for this table's params, so multiple tables can share one URL
   * (`left.colHide`, `right.colPin`, …). Omit for the bare keys.
   */
  urlKey?: string;
}
/** State + change handler returned by {@link useColumnLayoutUrlState}. */
interface UseColumnLayoutUrlStateResult {
  /** Current layout — from the URL, or the default when the URL is empty. */
  layout: ColumnLayoutState;
  /** Persist a new layout into the URL. Wire to `onColumnLayoutChange`. */
  onLayoutChange: (next: ColumnLayoutState) => void;
}
/**
 * Headless URL-synced column layout. Mirrors {@link useTableUrlState} for the
 * column dimension: which columns are hidden, pinned, reordered, or resized is
 * kept in the query string (or a local store when disabled), so reloads,
 * shared links, and re-mounts restore the exact layout. Feed the result into
 * a table's `columnLayout` / `onColumnLayoutChange`.
 *
 * `defaultColumnLayout` applies only while the URL carries no layout. When the user
 * explicitly empties the layout (e.g. unhides the last default-hidden
 * column), an empty `colHide=` marker records that emptiness — deleting every
 * param would resurrect the default on the next read. A change back to the
 * exact default clears the params instead, keeping shared URLs clean.
 *
 * @param options - See {@link UseColumnLayoutUrlStateOptions}.
 * @returns The current layout and a change handler that persists it.
 */
declare function useColumnLayoutUrlState(options?: UseColumnLayoutUrlStateOptions): UseColumnLayoutUrlStateResult;
//#endregion
//#region src/source/useFrontendData.d.ts
/** Options for {@link useFrontendData}. */
interface UseFrontendDataOptions<TRow> extends Pick<UseTableUrlStateOptions, "urlAdapter" | "urlSync" | "defaults" | "numberExtraKeys" | "arrayExtraKeys" | "urlKey"> {
  /** The source array. Filtered / sorted / sliced internally by state. */
  data: readonly TRow[];
  /**
   * How a row's id is derived — the same function {@link applyRowPatches}
   * used. Defaults to `String(row.id)` when the row has an `id`.
   */
  getRowId?: (row: TRow) => string;
  /**
   * Project a row to its searchable text. Defaults to a flatten of the
   * row's own values; override to reach nested fields.
   */
  getSearchText?: (row: TRow) => string;
  /**
   * Resolve a row's sort value for a column key. Falls back to the
   * matching column's `sortValue`.
   */
  getSortValue?: (row: TRow, columnKey: string) => SortableValue;
  /** Columns — read for per-column `sortValue` when sorting. */
  columns?: readonly ColumnDef<TRow>[];
  /**
   * Client-side filter predicate applied after search. Receives the active
   * `extra` filter bag (driven by the filter drawer's `setExtra` calls), so a
   * filter UI filters the rows with no extra wiring. Omit for no filtering.
   */
  filterFn?: (row: TRow, extra: ExtraFilters) => boolean;
  /**
   * Evaluate the URL's AND/OR filter tree against a row. Omit and the
   * tree is stored but not applied (server tiers send it instead).
   */
  filterTreeFn?: (row: TRow, tree: QueryFilterGroup) => boolean;
  /** Pagination mode. Defaults to `"auto"` (mobile → infinite). */
  paginationMode?: PaginationMode;
  /** Forwarded error to display (e.g. from a query that produced `data`). */
  error?: Error | null;
  /** Forwarded refetch. */
  refetch?: () => Promise<unknown> | void;
  /** Forwarded fetching flag. */
  isFetching?: boolean;
  /** Forwarded loading flag. */
  isLoading?: boolean;
  /**
   * Force the resolved mobile state instead of using a media query.
   * Primarily a testing/SSR seam.
   */
  forceMobile?: boolean;
}
/** Default searchable-text projector: flatten a row's own values. */
declare function defaultSearchText<TRow>(row: TRow): string;
/** Default row id: `String(row.id)` when the row has a string/number id. */
declare function defaultFrontendRowId<TRow>(row: TRow): string;
/**
 * In-memory {@link TableSource}: reads URL/local state and filters, sorts,
 * and slices a caller-supplied array. The mirror of `useQuerySource` —
 * the table cannot tell which produced it.
 *
 * A {@link rowPatchLog} on `data` continues the live {@link IncrementalView}
 * so only touched rows re-run search, filters and sort. Spreading the
 * patched array drops the log and falls back to a full rebuild.
 *
 * @typeParam TRow - The row item type.
 * @param options - See {@link UseFrontendDataOptions}.
 * @returns A {@link TableSource} over the in-memory data.
 */
declare function useFrontendData<TRow>(options: UseFrontendDataOptions<TRow>): TableSource<TRow>;
//#endregion
//#region src/source/useQuerySource.d.ts
/**
 * The minimal shape `useQuerySource` reads from a `useInfiniteQuery`
 * result. Declared structurally so `@tanstack/react-query` stays an
 * optional, type-only peer dependency (no runtime import).
 *
 * @typeParam TPage - The page type returned by each fetch.
 */
interface InfiniteQueryLike<TPage> {
  data: {
    pages: TPage[];
    pageParams: unknown[];
  } | undefined;
  isLoading: boolean;
  isFetching: boolean;
  isFetchingNextPage: boolean;
  hasNextPage: boolean;
  fetchNextPage: () => Promise<unknown> | void;
  refetch: () => Promise<unknown> | void;
  error: Error | null;
}
/** Project a fetched page to its rows (and optional total). */
type PageSelector<TRow, TPage> = (page: TPage) => {
  rows: readonly TRow[];
  total?: number;
  facets?: FacetMap;
};
/** Options for {@link useQuerySource}. */
interface UseQuerySourceOptions<TRow, TParams extends TableQueryParams, TPage> extends Pick<UseTableUrlStateOptions, "urlAdapter" | "urlSync" | "defaults" | "numberExtraKeys" | "arrayExtraKeys" | "urlKey"> {
  /**
   * The caller's paginated-query hook, built on `useInfiniteQuery`. It
   * receives the merged params and must return an {@link InfiniteQueryLike}.
   */
  usePaginatedQuery: (params: Partial<TParams>) => InfiniteQueryLike<TPage>;
  /** Page → `{ items, total }` selector. Defaults to reading {@link PaginatedResponse}. */
  selectPage?: PageSelector<TRow, TPage>;
  /**
   * Static params merged into every query call (e.g. a parent scope id).
   * The live table state always wins on collision: `page`, `limit`,
   * `search`, `sortBy`, `sortDir`, `groupBy` and `filters` come from the
   * table itself and can never be overridden here — seed state through
   * `defaults` instead.
   */
  baseParams?: Partial<TParams>;
  /** Pagination mode. Defaults to `"auto"` (mobile → infinite). */
  paginationMode?: PaginationMode;
  /** Final scrubber on the merged params before they reach the query. */
  sanitizeParams?: (params: Partial<TParams>) => Partial<TParams>;
  /** Force the resolved mobile state instead of a media query (test/SSR seam). */
  forceMobile?: boolean;
  /**
   * What the endpoint can answer, exactly as {@link useServerData} takes it.
   * Only a declared capability is ever sent; an undeclared one is dropped
   * before the request rather than sent and ignored.
   */
  supports?: QuerySupport;
  /**
   * Aggregates to ask the server for — `[{ key: "budget", fn: "sum" }]`.
   *
   * Sent only when the source declares `supports.aggregates`. With grouping
   * armed the server computes them per group; without it, over the whole
   * result set.
   */
  aggregates?: readonly QueryAggregate[];
  /**
   * The tree nodes the reader has open, when the hierarchy lives on the server.
   * Sent as `expandedIds` only if the source declares
   * `supports: { tree: true }`, so the response can carry the children of every
   * open branch alongside the page. Hold the same array in the table's
   * `expandedIds` and one piece of state drives both.
   */
  expandedIds?: readonly string[];
  /**
   * The token that opens the NEXT page, read from the page the query just
   * returned — pass it and declare `supports: { cursor: true }` to page by
   * cursor instead of by offset.
   *
   * Rows inserted or deleted mid-read shift every offset after them, which is
   * how an offset pager duplicates or skips rows; a cursor names a position in
   * the result rather than a distance into it.
   */
  nextCursor?: (page: TPage) => string | null | undefined;
  /**
   * Filter keys to ask the server for distinct-value counts. Sent as
   * `query.facets` only when `supports.facets` is set.
   */
  facetKeys?: readonly string[];
}
/**
 * Server-paginated {@link TableSource}. Wraps a caller's
 * `useInfiniteQuery` hook and exposes the uniform contract: flattening
 * pages in infinite mode, returning the latest page in paged mode, and
 * keeping query params in sync with URL state.
 *
 * @returns A {@link TableSource} backed by the server query.
 */
declare function useQuerySource<TRow, TParams extends TableQueryParams = TableQueryParams, TPage = PaginatedResponse<TRow>>(options: UseQuerySourceOptions<TRow, TParams, TPage>): TableSource<TRow>;
//#endregion
//#region src/filters/countFilters.d.ts
/** Numeric comparison operators for count/usage filters. */
declare const COUNT_OPERATORS: readonly ["eq", "gte", "lte", "gt", "lt", "between"];
/** Numeric comparison operator. */
type CountOperator = (typeof COUNT_OPERATORS)[number];
/** State for one operator-driven count filter. */
interface CountFilterState {
  op?: CountOperator;
  value?: number;
  from?: number;
  to?: number;
}
/** Symbols used in compact chip labels. */
declare const COUNT_OPERATOR_SYMBOL: Record<CountOperator, string>;
/** Whether a count-filter state is complete enough to affect a query. */
declare function isCountFilterComplete(state: CountFilterState): boolean;
/** Convert a state update to URL-extra values for one bucket. */
declare function countFilterExtra(bucket: string, state: CountFilterState): ExtraFilters;
/** URL-extra update that clears every value for one bucket. */
declare function clearCountFilterExtra(bucket: string): ExtraFilters;
/** Rehydrate one bucket's count-filter state from an extra-filter bag. */
declare function countFilterStateFromExtra(bucket: string, extra: Readonly<Record<string, FilterValue>>): CountFilterState;
/**
 * Remove incomplete count filters from backend params while preserving any
 * unrelated params. This lets a UI keep partial state in the URL without
 * sending invalid operator/value pairs to an API.
 */
declare function sanitizeCountFilterParams<P extends Record<string, unknown>>(params: P, buckets: readonly string[]): P;
/** Build a compact chip label for a complete count filter. */
declare function countFilterChipLabel(label: string, state: CountFilterState): string | undefined;
//#endregion
//#region src/filters/useExtraChips.d.ts
/** Options for {@link useExtraChips}. */
interface UseExtraChipsOptions {
  /** A source's `extra` bag. */
  readonly extra: ExtraFilters;
  /** A source's `setExtra` setter. */
  readonly setExtra: (key: string, value: FilterValue) => void;
  /**
   * Map of filter key → label resolver. Only keys present here become
   * chips. Memoise this on the caller side when the resolver closes over
   * `t`/lookup data so the chip list stays stable across renders.
   */
  readonly labels: Readonly<Record<string, ChipLabelResolver>>;
}
/**
 * Convenience wrapper over {@link useActiveFilterChips} that reads a
 * source's `extra` bag, applies the label resolvers, and wires each
 * chip's removal back to `setExtra`. The caller only declares the labels.
 *
 * @param options - See {@link UseExtraChipsOptions}.
 * @returns The derived chips.
 */
declare function useExtraChips({
  extra,
  setExtra,
  labels
}: UseExtraChipsOptions): ActiveFilterChip[];
//#endregion
//#region src/sort/cycleSort.d.ts
/**
 * Advance the three-step sort cycle for a column header click:
 * inactive → ascending → descending → cleared.
 *
 * @param current - The current sort pair (both fields unset when inactive).
 * @param key - The column key that was clicked.
 * @returns The next sort state.
 */
declare function nextSort(current: Partial<SortLevel>, key: string): Partial<SortLevel>;
//#endregion
//#region src/columns/autoSizeColumns.d.ts
/**
 * The width a column needs for its widest rendered cell.
 *
 * Cells are found by the `data-column-key` every adapter's cells carry, so this
 * needs no per-kit knowledge and works the same in a table of divs.
 *
 * @param root - The table element (or any ancestor of its cells).
 * @param key - The column key to measure.
 * @returns The width in pixels, clamped to the resize bounds, or `null` when
 *   the column has no cells on screen to measure.
 */
declare function measureColumnWidth(root: Element | null, key: string): number | null;
/**
 * Size every rendered column to its content.
 *
 * @param root - The table element.
 * @param keys - The columns to size, in any order.
 * @param setWidth - The layout mutator that persists each width.
 * @returns How many columns were sized — zero when nothing was measurable.
 */
declare function autoSizeColumns(root: Element | null, keys: readonly string[], setWidth: (key: string, width: number) => void): number;
//#endregion
//#region src/columns/columnHeader.d.ts
/** Default header caption: the explicit header, else a humanized key. */
declare function columnHeaderLabel<TRow>(column: ColumnDef<TRow>): ReactNode;
/** Build the controller a custom header receives. */
declare function columnHeaderController<TRow>(column: ColumnDef<TRow>, extras?: {
  sortDir?: "asc" | "desc";
  sortIndex?: number;
  toggleSort?: (event?: {
    shiftKey?: boolean;
  }) => void;
}): ColumnHeaderController;
/** Custom `renderHeader`, or the default caption. */
declare function resolveColumnHeader<TRow>(column: ColumnDef<TRow>, controller: ColumnHeaderController): ReactNode;
/** Custom `renderFooter`, or the summary value as-is. */
declare function resolveColumnFooter<TRow>(column: ColumnDef<TRow>, value: ReactNode): ReactNode;
/** True when any column wants a footer cell of its own. */
declare function columnsHaveFooter<TRow>(columns: readonly ColumnDef<TRow>[]): boolean;
//#endregion
//#region src/columns/visibleColumns.d.ts
/** Which layout a table is rendering in. */
type TableLayout = "desktop" | "mobile";
/**
 * Resolve the columns visible for a layout.
 *
 * - Desktop: drops `hideOnDesktop` columns.
 * - Mobile: drops `hideOnMobile` columns, but the first three declared
 *   desktop-visible columns WITHOUT an explicit `hideOnMobile` surface so
 *   every card keeps a minimum identity block — an explicit hide always
 *   wins over the identity default. Mobile-only columns (`hideOnDesktop`
 *   without `hideOnMobile`) render here — they exist precisely for the
 *   card layout.
 *
 * @typeParam TRow - The row type.
 * @param columns - All declared columns.
 * @param layout - The current layout.
 * @returns The columns to render, in declared order.
 */
declare function visibleColumns<TRow>(columns: readonly ColumnDef<TRow>[], layout: TableLayout, mobileIdentityColumns?: number): ColumnDef<TRow>[];
//#endregion
//#region src/layout/useHorizontalOverflow.d.ts
/** Result of {@link useHorizontalOverflow}. */
interface HorizontalOverflow<E extends HTMLElement> {
  /** Callback ref for the wrapper element to measure. */
  ref: (node: E | null) => void;
  /** True while the wrapper's content is wider than the wrapper. */
  overflowing: boolean;
}
/**
 * Whether an element's content overflows it horizontally, kept current via
 * `ResizeObserver`. Adapters use it to turn the table wrapper into a
 * horizontal scroller ONLY when the table is actually wider than its
 * container — an unconditional `overflow-x: auto` would make the wrapper a
 * scroll container and trap page-scroll sticky headers even when nothing
 * overflows. Under SSR (no `ResizeObserver`) it stays `false`.
 */
declare function useHorizontalOverflow<E extends HTMLElement>(): HorizontalOverflow<E>;
//#endregion
//#region src/hooks/useColorScheme.d.ts
/**
 * Resolve a color-scheme preference to a concrete `"light"` or `"dark"`.
 * `"auto"` follows the OS via `prefers-color-scheme`; an explicit
 * preference is returned unchanged. Adapters map the result to their
 * theming (Mantine/MUI/Chakra color schemes, or a `data-theme` attribute
 * + CSS variables for the unstyled adapter).
 *
 * @param preference - `"light" | "dark" | "auto"`. Defaults to `"auto"`.
 * @returns The resolved scheme, `"light"` or `"dark"`.
 */
declare function useColorScheme(preference?: ColorScheme): "light" | "dark";
//#endregion
//#region src/hooks/useDebounce.d.ts
/**
 * Debounce a rapidly-changing value. The returned value only updates
 * after `delay` ms have elapsed without a new change.
 *
 * @typeParam T - The value type.
 * @param value - The source value.
 * @param delay - Debounce delay in milliseconds. Defaults to 300.
 * @returns The debounced value.
 */
declare function useDebounce<T>(value: T, delay?: number): T;
//#endregion
//#region src/hooks/useInfiniteScroll.d.ts
/** Options for {@link useInfiniteScroll}. */
interface UseInfiniteScrollOptions {
  /** Whether more pages remain to be fetched. */
  hasNextPage: boolean;
  /** Whether a page fetch is currently in flight. */
  isFetchingNextPage: boolean;
  /** Loads the next page; called when the sentinel scrolls into view. */
  fetchNextPage: () => void;
  /**
   * Master switch. When `false` the observer is never attached (e.g. in
   * paged mode, or when the consumer wants explicit "Load more" only).
   * @defaultValue true
   */
  enabled?: boolean;
  /**
   * `IntersectionObserver` root margin — how far before the sentinel enters
   * the viewport the next page is prefetched.
   * @defaultValue "200px"
   */
  rootMargin?: string;
  /**
   * The current number of rendered rows. Pass `source.rows.length` so the
   * observer re-arms after each page loads: when freshly-loaded content is
   * still shorter than the viewport the sentinel stays in view, and
   * re-observing re-fires the callback to keep loading until the viewport
   * fills or there is no next page. Omit to disable this auto-continue.
   */
  itemCount?: number;
}
/**
 * Auto-loads the next page when a sentinel element scrolls near the viewport,
 * turning a paginated {@link TableSource} into true infinite scroll. Attach
 * the returned ref to a small element rendered after the last row.
 *
 * SSR- and jsdom-safe: when `IntersectionObserver` is unavailable it no-ops,
 * so an accompanying "Load more" button remains the fallback. The latest
 * `fetchNextPage` is read from a ref, so passing a fresh closure each render
 * never re-subscribes the observer.
 *
 * @typeParam TElement - The sentinel element type.
 * @param options - See {@link UseInfiniteScrollOptions}.
 * @returns A ref to attach to the sentinel element.
 */
declare function useInfiniteScroll<TElement extends HTMLElement = HTMLDivElement>(options: UseInfiniteScrollOptions): RefObject<TElement | null>;
//#endregion
//#region src/hooks/useIsMobile.d.ts
/**
 * Whether the viewport is at or below the mobile breakpoint.
 *
 * The default is 768px — a phone in portrait. Raise it when the table lives
 * in a sidebar or a split pane, where the viewport says "desktop" but the
 * table has a phone's width to work with; lower it when the table is the
 * whole page and the columns are narrow enough to survive.
 *
 * @param px - The breakpoint in pixels. Defaults to 768.
 * @returns `true` on viewports at or below it.
 */
declare function useIsMobile(px?: number): boolean;
//#endregion
//#region src/hooks/useMediaQuery.d.ts
/**
 * SSR-safe `matchMedia` hook built on `useSyncExternalStore`. Returns
 * `false` on the server and before hydration, then the live match.
 *
 * @param query - A CSS media query string, e.g. `"(max-width: 768px)"`.
 * @param defaultValue - Value used when `matchMedia` is unavailable (SSR).
 * @returns Whether the query currently matches.
 */
declare function useMediaQuery(query: string, defaultValue?: boolean): boolean;
//#endregion
//#region src/hooks/usePrefersReducedMotion.d.ts
/**
 * Whether the user has requested reduced motion. Animation hooks gate on
 * this so AdaptTable never animates against an accessibility preference.
 *
 * @returns `true` when the user prefers reduced motion.
 */
declare function usePrefersReducedMotion(): boolean;
//#endregion
//#region src/hooks/useScrollToTableTop.d.ts
/** Options for {@link useScrollToTableTop}. */
interface UseScrollToTableTopOptions {
  /** Table/container element to bring back below sticky chrome. */
  ref: RefObject<HTMLElement | null>;
  /** Dependency values that represent table view changes. */
  deps: readonly unknown[];
  /** Master switch. Defaults to true. */
  enabled?: boolean;
  /** Sticky top offset in px. Defaults to 0. */
  offset?: number;
  /** Extra breathing room below the sticky chrome. Defaults to 8px. */
  gap?: number;
  /** Scroll behavior. Defaults to smooth. */
  behavior?: ScrollBehavior;
}
/**
 * Scroll the table back below sticky chrome after search/filter/page changes.
 * The initial render is skipped so deep links and restored browser positions
 * are not disturbed on first paint.
 */
declare function useScrollToTableTop({
  ref,
  deps,
  enabled,
  offset,
  gap,
  behavior
}: UseScrollToTableTopOptions): void;
//#endregion
//#region src/utils/stableKey.d.ts
/**
 * Produce a deterministic string from any JSON-serialisable value so it
 * can be embedded in a query cache key (e.g. TanStack Query) without
 * changing identity on every render.
 *
 * Guarantees:
 * - Object keys are sorted, so `{ a, b }` and `{ b, a }` serialise
 *   identically.
 * - Nested objects are normalised recursively.
 * - Array order is preserved (order is meaningful for lists).
 * - `undefined` values are dropped, mirroring how query strings and
 *   `JSON.stringify` already treat them.
 *
 * @param input - Any value. Functions/symbols are not supported and will
 *   serialise the way `JSON.stringify` handles them.
 * @returns A stable JSON string for the normalised input.
 *
 * @example
 * ```ts
 * stableKey({ b: 1, a: 2 }) === stableKey({ a: 2, b: 1 }); // true
 * ```
 */
declare function stableKey(input: unknown): string;
//#endregion
//#region src/rows/patch.d.ts
/**
 * Row patches — changing the data you already have, without refetching it.
 *
 * A save returns the updated record, a socket pushes a new one, a delete
 * succeeds. Refetching the page to reflect that costs a round trip and, worse,
 * throws away everything the user had going: the scroll position, which rows
 * were open, sometimes the selection.
 *
 * ```ts
 * const [rows, setRows] = useState(initial);
 * const onSaved = (row: Person) =>
 *   setRows((current) => applyRowPatches(current, [updateRow(row.id, row)], byId));
 * ```
 *
 * Two properties make that safe, and both are tested:
 *
 * - **Untouched rows keep their object identity.** React reconciles them as
 *   unchanged, and anything memoized per row — a `computed` column's cache,
 *   a `memo`'d cell — stays valid instead of recomputing for the whole page.
 * - **A patch that changes nothing returns the very same array.** Applying an
 *   update whose values already match, or removing an id that is not there,
 *   hands back the original reference, so a `setState` with it does not
 *   re-render.
 *
 * Selection and expansion survive because both are keyed by row id, and a
 * patch never changes the id of a row it did not touch.
 *
 * This is a pure function over an array. The table never owns your data and
 * this does not make it start: you hold the rows, you apply the patch.
 */
/** Insert a row. Without `at`, it goes on the end. */
interface InsertPatch<TRow> {
  type: "insert";
  row: TRow;
  /** Zero-based position. Clamped into range; negative counts from the end. */
  at?: number;
}
/** Merge changes into the row with this id. Absent id: nothing happens. */
interface UpdatePatch<TRow> {
  type: "update";
  id: string;
  changes: Partial<TRow>;
}
/** Replace the row with this id, or append it when it is not there yet. */
interface UpsertPatch<TRow> {
  type: "upsert";
  row: TRow;
}
/** Drop the row with this id. Absent id: nothing happens. */
interface RemovePatch {
  type: "remove";
  id: string;
}
/** One change to a row set. */
type RowPatch<TRow> = InsertPatch<TRow> | UpdatePatch<TRow> | UpsertPatch<TRow> | RemovePatch;
/** Insert a row, optionally at a position. */
declare function insertRow<TRow>(row: TRow, at?: number): InsertPatch<TRow>;
/** Merge changes into one row. */
declare function updateRow<TRow>(id: string, changes: Partial<TRow>): UpdatePatch<TRow>;
/** Replace a row, or add it if it is new. */
declare function upsertRow<TRow>(row: TRow): UpsertPatch<TRow>;
/** Remove a row by id. */
declare function removeRow(id: string): RemovePatch;
/**
 * One mutation {@link applyRowPatchesWithLog} actually performed.
 *
 * Incremental re-evaluation walks this list instead of scanning the row set
 * to find what changed. Indices are taken at the moment the event ran, so a
 * later event sees the array the earlier one left behind.
 */
type RowPatchEvent<TRow> = {
  type: "insert";
  id: string;
  row: TRow;
  index: number;
} | {
  type: "remove";
  id: string;
  row: TRow;
  index: number;
} | {
  type: "update";
  id: string;
  prev: TRow;
  next: TRow;
  index: number;
};
/**
 * The result of applying patches, plus the events an incremental view needs
 * so it does not have to diff two 20k-row arrays to find one update.
 */
interface RowPatchLog<TRow> {
  /** The row set after the patches — same contract as {@link applyRowPatches}. */
  rows: readonly TRow[];
  /** Empty when nothing changed; the original array is then on `rows`. */
  events: readonly RowPatchEvent<TRow>[];
}
/**
 * The log {@link applyRowPatches} attached to a result array, when the
 * patches actually changed something. A host that already called
 * `applyRowPatches` (the Scale demo, a socket handler) can hand this to
 * the incremental view instead of applying the same patches twice.
 *
 * Spreading the result (`[...applyRowPatches(...)]`) drops the log — the
 * copy is a different array.
 *
 * @typeParam TRow - The row type.
 * @param rows - An array returned by {@link applyRowPatches}.
 * @returns The log, or `undefined` when this array was not produced by a
 *   changing patch (or was copied).
 */
declare function rowPatchLog<TRow>(rows: readonly TRow[]): RowPatchLog<TRow> | undefined;
/**
 * Apply patches to a row set, in order, and return the result.
 *
 * Returns the original array — the same reference — when no patch changed
 * anything. Rows that no patch touched keep their object identity.
 *
 * @typeParam TRow - The row type.
 * @param rows - The current rows.
 * @param patches - The changes to apply, in order.
 * @param getRowId - How a row's id is derived; the table's own `rowKey`.
 */
declare function applyRowPatches<TRow>(rows: readonly TRow[], patches: readonly RowPatch<TRow>[], getRowId: (row: TRow) => string): readonly TRow[];
/**
 * Apply patches and return the events each real mutation produced.
 *
 * {@link applyRowPatches} is this without the log. Incremental re-evaluation
 * sits on the log so a 200-update burst does not walk 20k rows looking for
 * what changed.
 *
 * @typeParam TRow - The row type.
 * @param rows - The current rows.
 * @param patches - The changes to apply, in order.
 * @param getRowId - How a row's id is derived; the table's own `rowKey`.
 */
declare function applyRowPatchesWithLog<TRow>(rows: readonly TRow[], patches: readonly RowPatch<TRow>[], getRowId: (row: TRow) => string): RowPatchLog<TRow>;
//#endregion
//#region src/rows/incremental.d.ts
/** How the table turns a row set into a filtered, sorted, grouped view. */
interface IncrementalViewConfig<TRow> {
  /** How a row's id is derived; the table's own `rowKey`. */
  getRowId: (row: TRow) => string;
  /**
   * Project a row to its searchable text. Defaults to a flatten of the
   * row's own values — the same default `useFrontendData` uses.
   */
  getSearchText?: (row: TRow) => string;
  /** Active search term. Empty / omitted means no search. */
  search?: string;
  /** Client-side extra-filter predicate. */
  filterFn?: (row: TRow, extra: ExtraFilters) => boolean;
  /** The extra-filter bag `filterFn` reads. */
  extra?: ExtraFilters;
  /**
   * Evaluate the AND/OR filter tree against a row. Omit and the tree is
   * stored but not applied — same seam as `useFrontendData`.
   */
  filterTreeFn?: (row: TRow, tree: QueryFilterGroup) => boolean;
  /** The active filter tree, when there is one. */
  filterTree?: QueryFilterGroup;
  /** Columns — sort and group values resolve through these. */
  columns?: readonly ColumnDef<TRow>[];
  /** Override a column's sort value. */
  getSortValue?: (row: TRow, columnKey: string) => SortableValue;
  /** Single-column sort. Ignored when `sortLevels` is non-empty. */
  sortBy?: string;
  /** Single-column sort direction. */
  sortDir?: SortDirection;
  /** Multi-column sort chain. Supersedes `sortBy` / `sortDir`. */
  sortLevels?: readonly SortLevel[];
  /** Group by one key, or several for a nested grouping. */
  groupBy?: string | readonly string[];
  /** Per-group cells — same signature as `summaryRow`. */
  groupAggregates?: GroupAggregatesFn<TRow>;
  /** Order groups within their parent. */
  groupSort?: GroupSort<TRow>;
  /** Keep only the groups this answers true for. */
  groupFilter?: (group: GroupNode<TRow>) => boolean;
  /** Close every group with a footer row. */
  groupFooters?: boolean;
  /** Collapsed group keys. */
  collapsedGroupIds?: ReadonlySet<string>;
  /** Override the blank-group label. */
  blankLabel?: string;
  /** Page size for top-level groups. */
  groupPageSize?: number;
  /** Page size for leaves inside a group. */
  rowPageSize?: number;
  /** How many extra groups / rows are currently revealed. */
  paging?: GroupPaging;
  /** Grand-total mapper over the sorted (filtered) set. */
  summaryRow?: (rows: readonly TRow[]) => Partial<Record<string, ReactNode>>;
  /**
   * Built-in aggregate spec for incremental totals. Used for the grand
   * total when `summaryRow` is omitted, and for group cells when
   * `groupAggregates` is omitted.
   */
  aggregateSpec?: AggregateSpec;
  /** Options for {@link IncrementalViewConfig.aggregateSpec}. */
  aggregateOptions?: AggregateOptions<TRow>;
}
/**
 * A derived snapshot of a row set. The latest snapshot is the only one
 * {@link applyRowPatchesToView} may be called on — applying to a stale
 * snapshot rebuilds from its `rows` instead of continuing incrementally.
 */
interface IncrementalView<TRow> {
  /** Source rows after patches — same contract as {@link applyRowPatches}. */
  readonly rows: readonly TRow[];
  /** After search, extra filters and the filter tree. */
  readonly filtered: readonly TRow[];
  /** After sort, or `filtered` when unsorted. */
  readonly sorted: readonly TRow[];
  /** Grouped flat model, when grouping is configured. */
  readonly groups: readonly GroupedFlatEntry<TRow>[] | undefined;
  /** Grand-total cells over `sorted`. */
  readonly aggregates: Partial<Record<string, ReactNode>> | undefined;
}
/**
 * The snapshot {@link createIncrementalView} attached to a derived row
 * array (`rows` / `filtered` / `sorted`, or a page slice the host
 * attached). Spreading that array drops the link, same as
 * {@link rowPatchLog}.
 */
declare function incrementalViewOf<TRow>(rows: readonly TRow[]): IncrementalView<TRow> | undefined;
/**
 * Point a derived array (a page slice) at the snapshot it came from, so
 * {@link incrementalViewOf} can find aggregates / groups without a
 * second argument.
 */
declare function attachIncrementalView<TRow>(rows: readonly TRow[], view: IncrementalView<TRow>): void;
/** The config the snapshot was last built or reconfigured with. */
declare function incrementalViewConfig<TRow>(view: IncrementalView<TRow>): IncrementalViewConfig<TRow> | undefined;
/**
 * Merge new settings into a snapshot without walking the row set when
 * only grouping / summary extras changed.
 *
 * Filter, sort and search changes rebuild the derived arrays. Grouping
 * and summary extras rebuild only those stages and keep `filtered` /
 * `sorted` identity. A patch that only replaces a callback or a
 * `columns` array with the same keys returns the same view object —
 * hosts rebuild those every render, and a new view identity must not
 * ripple into the page slice.
 *
 * @typeParam TRow - The row type.
 * @param view - The latest snapshot.
 * @param patch - Fields to merge. `undefined` entries are ignored.
 */
declare function configureIncrementalView<TRow>(view: IncrementalView<TRow>, patch: Partial<IncrementalViewConfig<TRow>>): IncrementalView<TRow>;
/**
 * Default searchable-text projector: flatten a row's own values. Kept
 * here so this module does not import the React hook that publishes the
 * same helper on `useFrontendData`.
 */
declare function incrementalSearchText<TRow>(row: TRow): string;
/**
 * Build a snapshot by fully evaluating `rows`. Patches after this go
 * through {@link applyRowPatchesToView} so only touched rows are
 * re-evaluated.
 *
 * @typeParam TRow - The row type.
 * @param rows - The current source rows.
 * @param config - Filter / sort / group / aggregate settings.
 */
declare function createIncrementalView<TRow>(rows: readonly TRow[], config: IncrementalViewConfig<TRow>): IncrementalView<TRow>;
/**
 * Apply patches to a snapshot: {@link applyRowPatches} for the rows, then
 * incremental re-evaluation of every derived stage.
 *
 * @typeParam TRow - The row type.
 * @param view - The latest snapshot.
 * @param patches - The changes to apply, in order.
 */
declare function applyRowPatchesToView<TRow>(view: IncrementalView<TRow>, patches: readonly RowPatch<TRow>[]): IncrementalView<TRow>;
/**
 * Continue a snapshot from a log {@link applyRowPatches} already produced.
 * Use this when the host applied the patches itself and the incremental
 * view must not apply them a second time.
 *
 * @typeParam TRow - The row type.
 * @param view - The snapshot taken against the pre-patch rows.
 * @param log - The log attached to the post-patch array.
 */
declare function applyRowPatchLogToView<TRow>(view: IncrementalView<TRow>, log: RowPatchLog<TRow>): IncrementalView<TRow>;
//#endregion
//#region src/tree/useLazyChildren.d.ts
/** What {@link useLazyChildren} needs. */
interface UseLazyChildrenOptions<TRow> {
  /**
   * Fetch a node's children. Resolve once they are in the data the table
   * reads — the table re-walks the tree from the rows it is given, so it needs
   * nothing back.
   */
  onLoadChildren?: (row: TRow) => void | Promise<void>;
  /** Whether a row's children are already in hand. */
  hasLoadedChildren: (row: TRow) => boolean;
  /** Row identity. */
  getRowId: (row: TRow) => string;
}
/** Lazy-loading state for a tree. */
interface LazyChildrenState<TRow> {
  /** Nodes being fetched right now — what the chevron shows a spinner for. */
  loadingIds: ReadonlySet<string>;
  /**
   * Call before opening a node: fetches its children when they are missing.
   * Returns nothing — expansion is not blocked on the fetch, so the row opens
   * immediately and fills when the rows arrive.
   */
  loadIfNeeded: (row: TRow) => void;
  /** Ids whose last fetch rejected, so a caller can offer a retry. */
  failedIds: ReadonlySet<string>;
}
/**
 * Track which nodes are fetching their children, and fetch on demand.
 *
 * @typeParam TRow - The row type.
 * @param options - See {@link UseLazyChildrenOptions}.
 * @returns The state; inert when no `onLoadChildren` is given.
 */
declare function useLazyChildren<TRow>(options: UseLazyChildrenOptions<TRow>): LazyChildrenState<TRow>;
//#endregion
//#region src/editing/MultiSelectEditorChrome.d.ts
/** One option's checkbox, rendered by the adapter with its kit's control. */
interface MultiSelectEditorCheckboxProps {
  /** The option's visible text. */
  readonly label: ReactNode;
  /** The option's value — unique within the editor. */
  readonly value: string;
  /** Whether the draft currently holds this value. */
  readonly checked: boolean;
  /** Add or remove this value from the draft. */
  readonly onToggle: () => void;
  /**
   * Present on the FIRST option only. Attach it to the kit's control so the
   * editor takes focus when the cell opens, exactly as a single-control editor
   * does through {@link EditableCellEditorCtrl.focusRef}.
   */
  readonly focusRef?: (node: {
    focus: () => void;
  } | null) => void;
  /**
   * The editor's key handling — Enter commits, Escape cancels. It belongs on
   * the controls themselves rather than the group: a group is not an
   * interactive element, and keys arrive at whichever option has focus.
   */
  readonly onKeyDown: (event: KeyboardEvent) => void;
}
/** Adapter-supplied controls for {@link MultiSelectEditorChrome}. */
interface MultiSelectEditorSlots {
  readonly Checkbox: (props: MultiSelectEditorCheckboxProps) => ReactNode;
}
/** Props for {@link MultiSelectEditorChrome}. */
interface MultiSelectEditorChromeProps {
  /** The active cell's editor controller. */
  readonly ctrl: EditableCellEditorCtrl;
  /** Accessible name for the group — the table's edit label. */
  readonly label: string;
  /** The adapter's key handling, already wired to `ctrl.onEditorKeyDown`. */
  readonly onKeyDown: (event: KeyboardEvent) => void;
  readonly slots: MultiSelectEditorSlots;
}
/**
 * A group of kit checkboxes standing in for `<select multiple>`.
 *
 * @param props - See {@link MultiSelectEditorChromeProps}.
 * @returns The editor, named and focusable as one control.
 */
declare function MultiSelectEditorChrome({
  ctrl,
  label,
  onKeyDown,
  slots
}: Readonly<MultiSelectEditorChromeProps>): ReactNode;
//#endregion
//#region src/grouping/groupRowLayout.d.ts
/** One cell of a group header row, after the leading label cell. */
interface GroupRowCell<TRow> {
  /** The column this cell sits under. */
  column: ColumnDef<TRow>;
  /** That column's aggregate, or `undefined` for an empty cell. */
  node: ReactNode;
}
/** How to build a group header row. */
interface GroupRowLayout<TRow> {
  /**
   * Columns the leading label cell covers. Its `colSpan` is this length plus
   * however many edge cells (expand chevron, selection checkbox) precede it.
   */
  labelColumns: readonly ColumnDef<TRow>[];
  /**
   * Aggregates belonging to a column inside the label cell — only possible when
   * the very first column carries one, since the label has to live somewhere.
   * Rendered after the count.
   */
  labelAggregates: readonly GroupRowCell<TRow>[];
  /** One cell per remaining column, in render order. */
  cells: readonly GroupRowCell<TRow>[];
}
/**
 * Plan a group header row.
 *
 * With no aggregates the row stays a single spanning cell — nothing to align, and
 * a full-width label is what a plain group header should look like.
 *
 * @typeParam TRow - The row type.
 * @param columns - The columns as rendered, in order.
 * @param aggregateCells - Per-column aggregate nodes, keyed by column key.
 * @returns The row's shape.
 */
declare function groupRowLayout<TRow>(columns: readonly ColumnDef<TRow>[], aggregateCells: Readonly<Partial<Record<string, ReactNode>>> | undefined): GroupRowLayout<TRow>;
/**
 * Just the columns that carry an aggregate, in column order.
 *
 * A mobile card is a list of label/value pairs rather than a row of columns, so
 * alignment means nothing there and the empty cells are noise. A card shows only
 * the numbers that exist, each captioned by its column.
 *
 * @typeParam TRow - The row type.
 * @param columns - The columns as rendered, in order.
 * @param aggregateCells - Per-column aggregate nodes, keyed by column key.
 * @returns One entry per column that has an aggregate.
 */
declare function groupAggregateEntries<TRow>(columns: readonly ColumnDef<TRow>[], aggregateCells: Readonly<Partial<Record<string, ReactNode>>> | undefined): GroupRowCell<TRow>[];
/**
 * How many leaves a group header should report.
 *
 * The server's count when the grouping was computed there — a page of a group
 * of 4,000 still says 4,000 — and the rows in hand otherwise.
 *
 * @param entry - The group entry.
 * @returns The count to display.
 */
declare function groupLeafCount(entry: {
  leafIds: readonly string[];
  serverCount?: number;
}): number;
//#endregion
//#region src/grouping/groupSelection.d.ts
/**
 * Tri-state for a group checkbox over its leaf row ids — same enum as the
 * table header selection state. Leaf ids only; never synthetic group keys.
 */
declare function groupSelectionState(leafIds: readonly string[], selectedIds: ReadonlySet<string>): HeaderSelectionState;
//#endregion
//#region src/grouping/useGroupPaging.d.ts
/** Paging state and the one action that changes it. */
interface GroupPagingState {
  /** What the model reads. */
  paging: GroupPaging;
  /**
   * Reveal one more page. `groupKey` names the group whose leaves to extend;
   * omit it for the top-level groups.
   */
  showMore: (pageSize: number, groupKey?: string) => void;
  /** Back to the first page of everything — what new data calls for. */
  reset: () => void;
}
/**
 * Track how much of a paged group model is showing.
 *
 * @returns The state; inert until something calls `showMore`.
 */
declare function useGroupPaging(): GroupPagingState;
//#endregion
//#region src/url/useGroupCollapseUrlState.d.ts
/** What {@link useGroupCollapseUrlState} needs. */
interface UseGroupCollapseUrlStateOptions {
  /** URL backend; defaults to the History API. */
  urlAdapter?: UrlStateAdapter;
  /** Sync to the URL at all. Defaults to `true`. */
  urlSync?: boolean;
  /** Namespace, when several tables share a page. */
  urlKey?: string;
  /** Groups collapsed before the URL says otherwise. */
  defaultCollapsedGroupIds?: readonly string[];
}
/** The controlled pair `<DataTable>` takes. */
interface UseGroupCollapseUrlStateResult {
  /** The collapsed group keys. */
  collapsedGroupIds: string[];
  /** Hand this to `onCollapsedGroupIdsChange`. */
  onCollapsedGroupIdsChange: (ids: string[]) => void;
}
/**
 * Keep collapsed groups in the URL.
 *
 * @param options - See {@link UseGroupCollapseUrlStateOptions}.
 * @returns The controlled pair to spread onto the table.
 */
declare function useGroupCollapseUrlState(options?: UseGroupCollapseUrlStateOptions): UseGroupCollapseUrlStateResult;
//#endregion
//#region src/url/useRowPinningUrlState.d.ts
/** What {@link useRowPinningUrlState} needs. */
interface UseRowPinningUrlStateOptions {
  /** URL backend; defaults to the History API. */
  urlAdapter?: UrlStateAdapter;
  /** Sync to the URL at all. Defaults to `true`. */
  urlSync?: boolean;
  /** Namespace, when several tables share a page. */
  urlKey?: string;
}
/** The controlled pair `<DataTable>` takes. */
interface UseRowPinningUrlStateResult {
  /** The pin lists. */
  pinnedRowIds: RowPinState;
  /** Hand this to `onPinnedRowIdsChange`. */
  onPinnedRowIdsChange: (next: RowPinState) => void;
}
/**
 * Keep pinned rows in the URL.
 *
 * @param options - See {@link UseRowPinningUrlStateOptions}.
 * @returns The controlled pair to spread onto the table.
 */
declare function useRowPinningUrlState(options?: UseRowPinningUrlStateOptions): UseRowPinningUrlStateResult;
//#endregion
//#region src/export/csv.d.ts
/** Options for {@link rowsToCsv}. */
interface RowsToCsvOptions<TRow> {
  /**
   * Resolve a cell's CSV value. Defaults to the column's `accessor` when it
   * yields a primitive, falling back to `sortValue`, else an empty string —
   * so JSX cells export their underlying value instead of `[object Object]`.
   */
  getValue?: (row: TRow, column: ColumnDef<TRow>) => unknown;
  /** Field delimiter. Defaults to `","`. */
  delimiter?: string;
  /**
   * Neutralise spreadsheet formula injection: string cells beginning with
   * `=`, `+`, `-`, `@`, tab or carriage return are prefixed with `'` so
   * Excel and Google Sheets show them as text instead of executing them.
   * Number and boolean cells are never touched. Disable ONLY when the
   * output is consumed by machines, never opened in a spreadsheet.
   * @defaultValue true
   */
  escapeFormulas?: boolean;
}
/**
 * Serialize rows to CSV using the table's own column definitions: the header
 * row uses each column's string `header` (else its key), and cells resolve
 * via `accessor` → `sortValue`. Pure and headless — pair with
 * {@link downloadCsv} or send the string anywhere.
 *
 * @typeParam TRow - The row type.
 * @param rows - The rows to export (e.g. `source.rows`, or the full set).
 * @param columns - The columns to export, in order.
 * @param options - See {@link RowsToCsvOptions}.
 * @returns The CSV text (no BOM; {@link downloadCsv} adds one for Excel).
 */
declare function rowsToCsv<TRow>(rows: readonly TRow[], columns: readonly ColumnDef<TRow>[], options?: RowsToCsvOptions<TRow>): string;
/**
 * The same CSV, from values that are already resolved.
 *
 * This is the one place that writes CSV. The table-level export resolves its
 * cells once and hands the result to a writer, so routing `rowsToCsv` through
 * here is what keeps the two from ever disagreeing about quoting, line endings
 * or formula escaping.
 *
 * @param table - Headers and one array of values per row.
 * @param options - Delimiter and formula escaping.
 * @returns The CSV text (no BOM).
 */
declare function matrixToCsv(table: {
  headers: readonly string[];
  rows: readonly (readonly unknown[])[];
}, options?: {
  delimiter?: string;
  escapeFormulas?: boolean;
}): string;
/**
 * Trigger a browser download of CSV text (UTF-8 with BOM, so Excel opens
 * unicode correctly). No-op outside the browser.
 *
 * @param filename - Download name, e.g. `"people.csv"`.
 * @param csv - The CSV text from {@link rowsToCsv}.
 */
declare function downloadCsv(filename: string, csv: string): void;
//#endregion
//#region src/export/exportView.d.ts
/**
 * Flatten grouping entries into export view rows.
 *
 * Headers and footers keep their outline level. Leaves sit one level
 * deeper than the group they belong to, which is what Excel's outline
 * expects. "Load more" and extra rows are render chrome and stay out.
 *
 * @typeParam TRow - The row type.
 * @param entries - The grouping model's flat list.
 * @param groupTotal - Optional caption for a footer (`"Core total"`).
 * @param includeHiddenLeaves - When true, a collapsed or paged group
 *   contributes every leaf it holds, not only the ones on screen.
 */
declare function viewFromGroupedEntries<TRow>(entries: readonly GroupedFlatEntry<TRow>[], groupTotal?: (label: string) => string, includeHiddenLeaves?: boolean): ExportViewEntry<TRow>[];
/**
 * A tree is already a list of data rows with a depth. The outline is that
 * depth; there are no extra header rows to invent.
 *
 * @typeParam TRow - The row type.
 * @param entries - The flattened tree, in render order.
 */
declare function viewFromTreeEntries<TRow>(entries: readonly TreeEntry<TRow>[]): ExportViewEntry<TRow>[];
/**
 * Keep the structure that still has a reason to exist after a scope
 * dropped some leaves: a group header stays if any of its remaining
 * descendants stayed; a footer stays with its header.
 *
 * @typeParam TRow - The row type.
 * @param view - The full grouped or tree view.
 * @param scopedIds - Row ids the scope resolved to.
 * @param getRowId - How a row's id is derived.
 */
declare function filterExportView<TRow>(view: readonly ExportViewEntry<TRow>[], scopedIds: ReadonlySet<string>, getRowId: (row: TRow) => string): ExportViewEntry<TRow>[];
/**
 * Pick the view the current chrome is showing. A tree outranks grouping —
 * the same rule the table uses when both are armed.
 *
 * @typeParam TRow - The row type.
 */
declare function exportViewFromChrome<TRow>(options: {
  grouping?: {
    entries: readonly GroupedFlatEntry<TRow>[];
  };
  tree?: {
    entries: readonly TreeEntry<TRow>[];
    allEntries?: readonly TreeEntry<TRow>[];
  };
  groupTotal?: (label: string) => string; /** Folded or paged-away leaves, for `scope: "all"` / `"selected"`. */
  includeHiddenLeaves?: boolean;
}): ExportViewEntry<TRow>[] | undefined;
/** `summaryRow` as file values — JSX cells drop out. */
declare function summaryExportValues(cells: Readonly<Partial<Record<string, unknown>>> | undefined): Partial<Record<string, unknown>> | undefined;
//#endregion
export { updateRow as $, applyRowPin as $a, useColumnDragState as $c, UseDataTableResult as $i, writeClipboardText as $n, FindInTableState as $o, computed as $r, CellEditKeyAction as $s, FilterTriggerToggle as $t, useLazyChildren as A, MobileCardModel as Aa, EditEventHandler as Ac, TableQuery as Ai, useSelection as Al, tableQueryBaseKey as An, makeExportCsvHandler as Ao, addFilterTreeGroup as Ar, FilterHeaderSelectProps as As, countFilterExtra as At, incrementalViewOf as B, pinnedRowCellStyle as Ba, resolveColumnWidth as Bc, SidePanelCloseProps as Bi, resolveDisabledReason as Bl, PasteRangeOptions as Bn, treeCardStyle as Bo, isActiveFilterTree as Br, EditableCellGate as Bs, defaultSearchText as Bt, groupRowLayout as C, rowReorderSignature as Ca, UseDirtyCellsOptions as Cc, fillSlot as Ci, useCommandPalette as Cl, useEditHistory as Cn, ExportRequest as Co, HeaderFilterSessionProps as Cr, FilterHeaderControlChromeProps as Cs, useExtraChips as Ct, MultiSelectEditorSlots as D, RowActionsRenderer as Da, UseBatchEditingOptions as Dc, UseTableDataResult as Di, HeaderSelectionState as Dl, UseDensityUrlStateResult as Dn, downloadTableCsv as Do, usePointerDismiss as Dr, FilterHeaderRangeProps as Ds, CountOperator as Dt, MultiSelectEditorChromeProps as E, RowActionsRenderContext as Ea, BatchRowEdit as Ec, UseTableDataOptions as Ei, useShortcuts as El, UseDensityUrlStateOptions as En, buildTableCsv as Eo, useHeaderFilterOverlay as Er, FilterHeaderOption as Es, CountFilterState as Et, attachIncrementalView as F, formatGroupBy as Fa, PAGE_SIZE_OPTIONS as Fc, useTableUrlState as Fi, useBulkActionRunner as Fl, BaseDataTableProps as Fn, TreeEntry as Fo, walkFilterTreeConditions as Fr, ExportStatus as Fs, PageSelector as Ft, RowPatchLog as G, EMPTY_ROW_PIN_STATE as Ga, ColumnDragRowAttrs as Gc, SidePanelSlots as Gi, ContextMenuActions as Gl, FillDirection as Gn, selectionStats as Go, showSimpleFilterFields as Gr, editorValidationProps as Gs, RouterUrlAdapterOptions as Gt, RemovePatch as H, pinnedRowSticky as Ha, ColumnResizeHandleProps as Hc, SidePanelFrameProps as Hi, Command as Hl, cellPasteHandler as Hn, treeIndentStyle as Ho, serializeFilterTree as Hr, EditableCellSlots as Hs, UseColumnLayoutUrlStateOptions as Ht, configureIncrementalView as I, parseGroupBy as Ia, SEARCH_DEBOUNCE_MS as Ic, FullscreenState as Ii, ContextMenuPoint as Il, SidePanelOptions as In, TreeShape as Io, conditionToExtra as Ir, useExportHandler as Is, UseQuerySourceOptions as It, applyRowPatches as J, RowPinLabels as Ja, ColumnReorderKeyProps as Jc, RowElementProps as Ji, fillRangeEdits as Jn, UseGridFocusOptions as Jo, defaultFilterRegistry as Jr, EditableCellEditing as Js, normalizeLocaleTag as Jt, UpdatePatch as K, PIN_BOTTOM_ACTION_KEY as Ka, ColumnDragState as Kc, SidePanelTabProps as Ki, ContextMenuItem as Kl, FillRangeOptions as Kn, GRID_CELL_ATTR as Ko, toolbarShowsFilters as Kr, multiDraftFromSelect as Ks, routerUrlAdapter as Kt, createIncrementalView as L, PINNED_BOTTOM_PART as La, pageSizeOptions as Lc, useFullscreen as Li, ConfirmHandler as Ll, ToolbarSlots as Ln, bodyRowEntries as Lo, evaluateFilterTree as Lr, EditableCellActivateProps as Ls, useQuerySource as Lt, IncrementalViewConfig as M, GroupCollapseState as Ma, EditUnit as Mc, useServerData as Mi, BulkActionRunner as Ml, HighlightState as Mn, resolveExportCsv as Mo, removeFilterTreeNode as Mr, filterDefForColumn as Ms, isCountFilterComplete as Mt, applyRowPatchLogToView as N, useGroupCollapse as Na, DEFAULT_CARD_SIZE_PX as Nc, UseTableUrlStateOptions as Ni, UseBulkActionRunnerOptions as Nl, HighlightedCell as Nn, BodyRowEntry as No, replaceFilterTreeNode as Nr, headerFilterStickTop as Ns, sanitizeCountFilterParams as Nt, LazyChildrenState as O, visibleRowActions as Oa, useBatchEditing as Oc, isDeclarativeFilters as Oi, SelectionState as Ol, useDensityUrlState as On, exportableColumns as Oo, FilterTreeNode as Or, FilterHeaderRowProps as Os, clearCountFilterExtra as Ot, applyRowPatchesToView as P, GroupByInput as Pa, DEFAULT_LIMIT as Pc, UseTableUrlStateResult as Pi, bulkActionErrorMessage as Pl, useHighlight as Pn, BuildTreeEntriesOptions as Po, setFilterTreeCombinator as Pr, ExportHandlerState as Ps, InfiniteQueryLike as Pt, rowPatchLog as Q, UNPIN_ROW_ACTION_KEY as Qa, columnRowDragProps as Qc, UseDataTableOptions as Qi, readClipboardText as Qn, batchEditHandler as Qo, ComputedColumnSpec as Qr, rowIsDirty as Qs, ChromeBodyData as Qt, incrementalSearchText as R, PINNED_TOP_PART as Ra, parsePxWidth as Rc, SidePanelChrome as Ri, ConfirmRequest as Rl, CellFillHandlerOptions as Rn, buildTreeEntries as Ro, FILTER_TREE_PARAM as Rr, EditableCellButtonProps as Rs, UseFrontendDataOptions as Rt, groupLeafCount as S, rowReorderDropStyle as Sa, DirtyCellState as Sc, TableErrorState as Si, TableCommandPalette as Sl, readCellValue as Sn, ExportQuery as So, splitRelativeToken as Sr, FilterHeaderControlChrome as Ss, UseExtraChipsOptions as St, MultiSelectEditorChrome as T, RowActionsLayout as Ta, BatchEditingState as Tc, DataModeProps as Ti, Shortcut as Tl, Density as Tn, FetchAllExport as To, headerFilterFieldIsComplete as Tr, FilterHeaderMultiProps as Ts, COUNT_OPERATOR_SYMBOL as Tt, RowPatch as U, pinnedRowStickyStyle as Ua, columnResizeHandleProps as Uc, SidePanelLayout as Ui, filterCommands as Ul, parseClipboardTable as Un, SelectionStats as Uo, FilterChromeMode as Ur, commitBooleanDraft as Us, UseColumnLayoutUrlStateResult as Ut, InsertPatch as V, pinnedRowPart as Va, tableMinWidth as Vc, SidePanelEntry as Vi, runRowAction as Vl, cellFillHandler as Vn, treeColumnKey as Vo, parseFilterTree as Vr, EditableCellGateProps as Vs, useFrontendData as Vt, RowPatchEvent as W, useOffsetHeight as Wa, COLUMN_DND_MIME as Wc, SidePanelLayoutProps as Wi, tableCommands as Wl, pasteRangeEdits as Wn, SelectionStatsOptions as Wo, resolveFilterMode as Wr, editorBusyProps as Ws, useColumnLayoutUrlState as Wt, insertRow as X, RowPinState as Xa, columnDropProps as Xc, SortButtonElementProps as Xi, ClipboardRangeOptions as Xn, useGridFocus as Xo, localizedColumnPath as Xr, focusEditorOnMount as Xs, humanizeKey as Xt, applyRowPatchesWithLog as Y, RowPinSide as Ya, ColumnRowDragProps as Yc, SearchInputElementProps as Yi, fillTargetRange as Yn, gridCellAttr as Yo, resolveFilterRegistry as Yr, EditableCellMode as Ys, resolveLocaleTag as Yt, removeRow as Z, RowPinningState as Za, columnReorderKeyProps as Zc, TableElementProps as Zi, clipboardRangeText as Zn, CellEdit as Zo, resolveColumns as Zr, rowEditingSignature as Zs, BulkBarChromeProps as Zt, useGroupPaging as _, RowReorderHandler as _a, EditConflictPolicy as _c, NestedTableFor as _i, unpinAllColumns as _l, EditHistoryEntry as _n, EXPORT_FETCH_ALL_MAX_ROWS as _o, isRelativeDateToken as _r, moveGridFocus as _s, resolveColumnFooter as _t, viewFromTreeEntries as a, PaginationInfo as aa, CellSaveState as ac, SavedViewMigration as ai, ColumnMenuRow as al, undoRedoToolbar as an, UseTableVirtualizationOptions as ao, UseFilterTreeChipsOptions as ar, cellRangeBounds as as, useMediaQuery as at, GroupRowLayout as b, applyRowReorder as ba, liveRowChanged as bc, nestedTableDetail as bi, useTableContextMenu as bl, UseEditHistoryOptions as bn, ExportCsvOptions as bo, relativeTokenLabel as br, FilterHeaderChromeProps as bs, measureColumnWidth as bt, matrixToCsv as c, computePagination as ca, UseCellSaveStateOptions as cc, UseSavedViewsOptions as ci, columnMenuActions as cl, useFilterTriggerToggle as cn, rowSourceIndex as co, ResolvedFilterOptions as cr, extendCellRange as cs, useInfiniteScroll as ct, UseRowPinningUrlStateResult as d, TreeExpansionState as da, RowEditingState as dc, LayoutStorage as di, filterColumnMenuRows as dl, DELETE_ROW_ACTION_KEY as dn, windowGroupedEntries as do, RELATIVE_PRESETS as dr, singleCellRange as ds, useHorizontalOverflow as dt, useDataTable as ea, CellEditKeyOutcome as ec, columnText as ei, ACTIONS_COLUMN_KEY as el, TableBodyRegion as en, partitionPinnedRows as eo, FindMatchesOptions as er, UseFindInTableOptions as es, upsertRow as et, useRowPinningUrlState as f, useTreeExpansion as fa, UseRowEditingOptions as fc, UseColumnLayoutStorageStateOptions as fi, hideAllColumns as fl, DUPLICATE_ROW_ACTION_KEY as fn, ResizableVirtualizer as fo, RELATIVE_PRESET_LABEL_KEYS as fr, GridBounds as fs, TableLayout as ft, GroupPagingState as g, ROW_DND_MIME as ga, EditConflictHandler as gc, NestedTableDefaults as gi, showAllColumns as gl, useRowMutations as gn, FeatureNoticeKind as go, countedRelativeToken as gr, gridFocusMoveForKey as gs, columnsHaveFooter as gt, useGroupCollapseUrlState as h, REORDER_COLUMN_WIDTH as ha, EditConflictChoice as hc, NestedTable as hi, resetColumnLayout as hl, UseRowMutationsOptions as hn, FeatureNotice as ho, RelativePreset as hr, GridKeyPress as hs, columnHeaderLabel as ht, viewFromGroupedEntries as i, mergeProps as ia, useCellEditing as ic, SavedView as ii, ColumnMenuLabels as il, printToolbar as in, TableVirtualization as io, stepMatch as ir, CellRangeBounds as is, usePrefersReducedMotion as it, IncrementalView as j, MobileCardRenderer as ja, EditLifecycle as jc, UseServerDataOptions as ji, BulkActionOutcome as jl, tableQueryKey as jn, resolveExportColumns as jo, emptyFilterTree as jr, FilterHeaderSlots as js, countFilterStateFromExtra as jt, UseLazyChildrenOptions as k, MobileCardField as ka, EditEvent as kc, useTableData as ki, UseSelectionOptions as kl, TableQueryKeyOptions as kn, fetchAllExportRows as ko, addFilterTreeCondition as kr, FilterHeaderSearchProps as ks, countFilterChipLabel as kt, rowsToCsv as l, paginationItems as la, useCellSaveState as lc, UseSavedViewsResult as li, columnMenuLabel as ll, useTableChrome as ln, useKeyedVirtualization as lo, useFilterOptions as lr, isInCellRange as ls, useDebounce as lt, UseGroupCollapseUrlStateResult as m, useRowExpansion as ma, EditConflict as mc, useColumnLayoutStorageState as mi, pinActionLabel as ml, RowMutationsState as mn, useRowPairMeasurer as mo, RelativeDateToken as mr, GridFocusMove as ms, columnHeaderController as mt, filterExportView as n, resolveLabels as na, CellEditingState as nc, useSearchInput as ni, ColumnMenuActionContext as nl, ToolbarChromeProps as nn, useRowPinning as no, matchKey as nr, useFindInTable as ns, UseScrollToTableTopOptions as nt, RowsToCsvOptions as o, PaginationItem as oa, CellSaveStatus as oc, SavedViewVisibility as oi, PinnedSide as ol, useChromeBodyData as on, VirtualTableRow as oo, filterTreeChipLabel as or, cellRangeIndices as os, useIsMobile as ot, UseGroupCollapseUrlStateOptions as p, RowExpansionState as pa, useRowEditing as pc, UseColumnLayoutStorageStateResult as pi, nextPinSide as pl, RowMutationHandlers as pn, RowPairMeasurer as po, RelativeDateRange as pr, GridCell as ps, visibleColumns as pt, UpsertPatch as q, PIN_TOP_ACTION_KEY as qa, ColumnDropProps as qc, CellElementProps as qi, ContextMenuTarget as ql, fillDirection as qn, GridFocusState as qo, builtInFilterSpecs as qr, EditableCellController as qs, getPath as qt, summaryExportValues as r, Props as ra, UseCellEditingOptions as rc, SAVED_VIEW_VERSION as ri, ColumnMenuChromeProps as rl, ViewControlsToolbar as rn, KeyedVirtualization as ro, matchKeySet as rr, CellRange as rs, useScrollToTableTop as rt, downloadCsv as s, PaginationSlot as sa, FailedCellSave as sc, SavedViewsStore as si, REORDER_COLUMN_KEY as sl, useChromeScrollReset as sn, resolveVirtualRows as so, useFilterTreeChips as sr, cellRangeSize as ss, UseInfiniteScrollOptions as st, exportViewFromChrome as t, defaultLabels as ta, CellEditNavigation as tc, SearchInputState as ti, ColumnMenuAction as tl, TableChrome as tn, rowPinSignature as to, findMatches as tr, useFindFocus as ts, stableKey as tt, UseRowPinningUrlStateOptions as u, paginationSlots as ua, RowEditDrafts as uc, useSavedViews as ui, columnMenuRows as ul, viewControlsToolbar as un, useTableVirtualization as uo, RELATIVE_NAMED as ur, isSingleCell as us, useColorScheme as ut, groupSelectionState as v, RowReorderLabels as va, EditConflictState as vc, NestedTableParent as vi, ContextMenuOptions as vl, EditHistoryState as vn, ExportColumnScope as vo, joinRelativeToken as vr, sameGridCell as vs, resolveColumnHeader as vt, MultiSelectEditorCheckboxProps as w, useRowReorder as wa, useDirtyCells as wc, tableErrorState as wi, DEFAULT_SHORTCUTS as wl, useTableEditHistory as wn, ExportRowScope as wo, bindHeaderFilterDismiss as wr, FilterHeaderControlProps as ws, COUNT_OPERATORS as wt, groupAggregateEntries as x, datasetIndex as xa, useEditConflict as xc, Slot as xi, CommandPaletteOptions as xl, asGesture as xn, ExportInfo as xo, resolveRelativeRange as xr, FilterHeaderClassNames as xs, nextSort as xt, GroupRowCell as y, RowReorderState as ya, ReconcileLiveEdit as yc, nestedTableDefaults as yi, TableContextMenu as yl, TableEditHistoryProps as yn, ExportContext as yo, parseRelativeToken as yr, FilterHeaderChrome as ys, autoSizeColumns as yt, incrementalViewConfig as z, orderedCardEntries as za, pinnedColumnWidth as zc, SidePanelChromeProps as zi, defaultConfirm as zl, CellPasteHandlerOptions as zn, filterTreeRows as zo, FILTER_TREE_VERSION as zr, EditableCellEditorCtrl as zs, defaultFrontendRowId as zt };
//# sourceMappingURL=index-Ab91GGk9.d.ts.map