@kanunilabs/datagrid-react 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,1761 @@
+import * as react from 'react';
+import { ReactNode, RefObject } from 'react';
+import { GridRowData, DataGridController, StateStoringConfig, RowKey, RowNode, GridColumnDef, DataGridCoreConfig, InferColumnsOptions, DescribeFilterOptions, ColumnRuntime, ColumnLayout, SortDescriptor, ColumnModel, SummaryDef, FilterNode, GridDataType, SummaryType, GridDictionary, ColumnState, BusyPhase, DataRowNode, VirtualWindow, ChartSpec, ChartModel } from '@kanunilabs/datagrid-core';
+export { BusyChangedEvent, BusyPhase, ClientRowModel, ColumnLayout, ColumnLookup, ColumnModel, ColumnPin, ColumnRuntime, ColumnState, ColumnStateChangedEvent, ContentReadyEvent, DEFAULT_ROW_HEIGHT, DataGridController, DataGridCoreConfig, DataRowNode, DataSource, FilterChangedEvent, FilterCondition, FilterGroupNode, FilterNode, FilterOperator, FocusedRowChangedEvent, GridColumnDef, GridDataType, GridEventMap, GridRowData, GridStateStore, GridViewState, GroupRowNode, GroupingConfig, HeaderBandCell, InferColumnsOptions, LoadOptions, LoadResult, LookupItem, NewRowPosition, RowDropPosition, RowKey, RowNode, ScrollingConfig, SelectionDescriptor, SortChangedEvent, SortDescriptor, SortDirection, StateStoringConfig, SummaryDef, SummaryType, ViewportChangedEvent, VirtualWindow, VirtualWindowEngine, andFilters, attachStateStoring, bandDepth, bandPath, computeColumnLayout, computeHeaderBands, createRestDataSource, describeFilter, downloadBlob, humanizeField, importCsv, inferColumns, isDataRow, isDataSource, isFilterGroup, isGroupRow, lookupLabel, moveRowInArray, parseCsv, sniffDelimiter, summaryKey } from '@kanunilabs/datagrid-core';
+
+/** Formats an export menu can offer. */
+type ExportKind = 'csv' | 'excel' | 'excel-selected' | 'pdf';
+interface ExportOutcome {
+    /** False when the user cancelled, or when the writer refused. */
+    completed: boolean;
+    /** Set only for a genuine failure — a cancel reports `completed: false`. */
+    error?: string;
+}
+/**
+ * Run one export and download it.
+ *
+ * Never throws: both callers render the failure rather than letting it reach an
+ * error boundary, because the common cause is a missing optional peer
+ * (`exceljs`, `jspdf`) — a message the user can act on, not a crash.
+ */
+declare function runGridExport<TRow = GridRowData>(controller: DataGridController<TRow>, kind: ExportKind): Promise<ExportOutcome>;
+
+declare function useStateStoring<TRow = GridRowData>(controller: DataGridController<TRow>, config: StateStoringConfig | undefined): void;
+
+interface PrintLayoutOptions {
+    /**
+     * Stay in print layout permanently instead of only while printing. For
+     * rendering a grid INTO a report page, where there is no print dialog to
+     * react to and the whole result is meant to be in the document.
+     */
+    always?: boolean;
+    /**
+     * Above this many rows the grid does NOT switch (default 5.000).
+     *
+     * Print layout puts every row in the DOM. At report sizes that is a beat;
+     * at a hundred thousand it is a frozen tab, and a browser that stops
+     * responding during printing is worse than a short printout. Past the cap the
+     * grid prints what it always did — the visible rows — and says so under
+     * `debugMode`, because the right tool at that size is `exportPdf`, which
+     * streams instead.
+     */
+    maxRows?: number;
+}
+/** Default row cap. Report-sized results print; result sets do not. */
+declare const PRINT_MAX_ROWS = 5000;
+interface PrintLayoutState {
+    /** Render every row and let the box grow. */
+    active: boolean;
+    /** Enter print layout by hand — for an app driving its own print button. */
+    begin: () => void;
+    /** Leave it again. */
+    end: () => void;
+}
+/**
+ * Suspend virtualization while the browser is printing.
+ *
+ * `flushSync` is not decoration here. `beforeprint` is the last moment the page
+ * can be changed, and the browser snapshots it the instant the handler returns
+ * — an ordinary `setState` would land after that and print the old, clipped
+ * view. This is the case the API exists for.
+ */
+declare function usePrintLayout<TRow = GridRowData>(controller: DataGridController<TRow>, options: boolean | PrintLayoutOptions | undefined): PrintLayoutState;
+
+/** MIME type carrying the payload. Custom so nothing else claims it. */
+declare const ROW_DRAG_MIME = "application/x-kanuni-row";
+/** What travels in `dataTransfer` when a row leaves its grid. */
+interface RowDragPayload {
+    /** Grid the row started in — a same-grid drop is a REORDER, not a move. */
+    gridId: string;
+    /** Only grids sharing a group exchange rows. */
+    group: string | null;
+    rowKey: RowKey;
+    /** The row itself, so the receiving grid can insert it without a round trip. */
+    row: unknown;
+}
+interface RowReorderEvent<TRow = GridRowData> {
+    dragKey: RowKey;
+    /** Row it was dropped onto, or null for the empty space past the last row. */
+    targetKey: RowKey | null;
+    position: 'before' | 'after';
+    row: TRow | undefined;
+}
+interface RowDropEvent<TRow = GridRowData> {
+    /** Row that crossed over, as the source grid had it. */
+    row: TRow;
+    rowKey: RowKey;
+    /** Grid it came from / went to. */
+    otherGridId: string;
+    targetKey: RowKey | null;
+    position: 'before' | 'after';
+}
+interface RowDragConfig<TRow = GridRowData> {
+    enabled?: boolean;
+    /**
+     * Grids sharing a group can exchange rows. Without one a grid only reorders
+     * its own rows — dropping into an unrelated grid on the same page is almost
+     * never what the user meant.
+     */
+    group?: string;
+    /** Reordering within this grid. Default true. */
+    allowReordering?: boolean;
+    /** Accept rows from another grid in the group. Default true when `group` is set. */
+    allowDropInsert?: boolean;
+    /**
+     * A row was moved within this grid. Without a handler the grid reorders its
+     * own source array; with one, YOU own the order (persist it, update your
+     * sort field) and the grid does nothing on its own.
+     */
+    onReorder?: (event: RowReorderEvent<TRow>) => void;
+    /** A row arrived from another grid. */
+    onAdd?: (event: RowDropEvent<TRow>) => void;
+    /** A row of THIS grid was accepted by another one. */
+    onRemove?: (event: RowDropEvent<TRow>) => void;
+}
+/** What `GridRow` needs to render and drive the gesture. */
+interface RowDragHandlers {
+    /** True while the pointer is on a grip — the row is armed for dragging. */
+    draggable: boolean;
+    setDraggable: (value: boolean) => void;
+    onDragStart: (node: RowNode<unknown>, event: React.DragEvent) => void;
+    onDragEnd: () => void;
+    onDragOver: (node: RowNode<unknown>, event: React.DragEvent) => void;
+    onDrop: (node: RowNode<unknown>, event: React.DragEvent) => void;
+}
+interface UseRowDragResult {
+    /** Undefined when dragging is off, so `GridRow` renders no grip at all. */
+    handlers: RowDragHandlers | undefined;
+    /** Row currently under the pointer, and which edge the line is drawn on. */
+    dropAt: {
+        key: RowKey;
+        side: 'before' | 'after';
+    } | null;
+    /** Drop target for the empty space BELOW the rows — "move to the end". */
+    bodyHandlers: {
+        onDragOver: (event: React.DragEvent) => void;
+        onDrop: (event: React.DragEvent) => void;
+        onDragLeave: (event: React.DragEvent) => void;
+    } | undefined;
+}
+declare function useRowDrag<TRow = GridRowData>(controller: DataGridController<TRow>, config: RowDragConfig<TRow> | undefined): UseRowDragResult;
+
+interface CellRenderContext<TRow = GridRowData> {
+    value: unknown;
+    row: TRow;
+    node: RowNode<TRow>;
+    column: GridColumnDef<TRow>;
+}
+interface HeaderRenderContext<TRow = GridRowData> {
+    column: GridColumnDef<TRow>;
+}
+/**
+ * What a custom editor is handed. `commit`/`cancel` are the SAME handles the
+ * built-in editor uses, so a replacement participates in Tab-walking, batch
+ * changes and undo rather than living beside them.
+ */
+interface EditorRenderContext<TRow = GridRowData> {
+    /** Current (uncommitted) editor value. */
+    value: unknown;
+    /** The row with pending edits applied — what a cascading list should read. */
+    row: TRow;
+    columnId: string;
+    /** Validation message for `value`, or null. */
+    error: string | null;
+    setValue: (value: unknown) => void;
+    commit: () => void;
+    cancel: () => void;
+}
+interface ReactGridColumnDef<TRow = GridRowData> extends GridColumnDef<TRow> {
+    /** Expensive escape hatch — renders arbitrary React per cell. */
+    renderCell?: (ctx: CellRenderContext<TRow>) => ReactNode;
+    renderHeader?: (ctx: HeaderRenderContext<TRow>) => ReactNode;
+    /**
+     * Replace the built-in editor for this column (Enterprise). Use for controls
+     * the grid does not ship — a colour picker, a masked input, an autocomplete
+     * against your own API.
+     */
+    renderEditor?: (ctx: EditorRenderContext<TRow>) => ReactNode;
+    /**
+     * Extra class(es) on every cell of this column — a monospace SKU column, a
+     * status tint. A function form allows per-VALUE classes without paying for a
+     * full `renderCell`, which would replace the cell's content and lose the
+     * built-in truncation and alignment.
+     */
+    cellClassName?: string | ((ctx: CellRenderContext<TRow>) => string | undefined);
+    /**
+     * Let this column's text WRAP, and let the row grow to fit it.
+     *
+     * The row is measured after it renders and the measurement is fed back to the
+     * window engine, so the scrollbar and every row offset account for the real
+     * height. Two consequences worth knowing before turning it on:
+     *
+     *   • only RENDERED rows can be measured. Rows below the viewport are assumed
+     *     to be the standard height until they scroll into it, so the scrollbar
+     *     firms up as the user travels. Every virtualized grid that measures has
+     *     this property; the alternative is laying out every row up front, which
+     *     at a million rows is not an alternative.
+     *   • measurements are dropped when a column is resized, because the width is
+     *     what decided where the text wrapped.
+     *
+     * When the height is known WITHOUT measuring, `getRowHeight` on the config is
+     * both cheaper and exact.
+     */
+    autoHeight?: boolean;
+    /**
+     * Tooltip text for this column's cells (P2.1).
+     *
+     * Without it, a cell whose text does not fit still gets one — the grid falls
+     * back to showing the clipped text in full. Set this when the tooltip should
+     * say something the cell does NOT: a code's description, an abbreviation
+     * spelled out, why a value is flagged.
+     *
+     * The function form runs only for the cell under the pointer, so it may be as
+     * expensive as it needs to be. Return null (or an empty string) to suppress
+     * the tooltip for that cell — including the truncation fallback.
+     */
+    tooltip?: string | ((ctx: CellRenderContext<TRow>) => string | null | undefined);
+    /**
+     * Read the tooltip from another FIELD of the row — the common case where the
+     * long form already travels with the data (`status` / `statusDetail`).
+     *
+     * `tooltip` wins if both are given.
+     */
+    tooltipField?: string;
+    /** Tooltip for this column's HEADER cell. */
+    headerTooltip?: string;
+}
+/** Which cell a note belongs to, and the row behind it. */
+interface NoteCellContext<TRow = GridRowData> {
+    rowKey: RowKey;
+    columnId: string;
+    row: TRow;
+}
+/**
+ * Which of the grid's own entries the cell context menu offers.
+ *
+ * Every flag defaults to ON, so `cellMenu` is a way to REMOVE things rather
+ * than a list to opt into — a grid that ships without saying anything gets the
+ * clipboard and export entries a user expects from a spreadsheet.
+ *
+ * Entries the grid cannot honour are not rendered rather than rendered
+ * disabled: an Export submenu on a grid whose optional export peers are absent
+ * would be a menu of dead ends. The exception is a permission the user could
+ * satisfy by acting — "Paste" stays visible while a cell is read-only, because
+ * the way out is to focus a different cell.
+ */
+interface CellMenuOptions {
+    /** Copy the selected cells, or the selected rows when there is no range. */
+    copy?: boolean;
+    /** Copy with a column-header line above the values. */
+    copyWithHeaders?: boolean;
+    /**
+     * Copy with the BAND caption rows above the header line. Hidden on a grid
+     * with no bands, where it would produce exactly `copyWithHeaders`.
+     */
+    copyWithGroupHeaders?: boolean;
+    /**
+     * Export submenu. `true` offers every format the grid can write; an array
+     * picks which, in the order given.
+     *
+     * Excel and PDF ride on OPTIONAL peers (`exceljs`, `jspdf`), so the default
+     * is CSV only — the one format that needs nothing installed. An app that
+     * installed the peers opts into them by naming them.
+     */
+    export?: boolean | ExportKind[];
+}
+/**
+ * Cell notes — prose a USER attached to a cell, Excel-style (gap analysis P3.3).
+ *
+ * Not a tooltip and not a value. A tooltip describes what the cell already
+ * says; a note is something a person added that is not in the data, so it
+ * carries a visible marker — you can see which cells have one without hovering
+ * every cell to find out.
+ *
+ * Storage is the application's. The grid renders notes, reveals them and (with
+ * `onChange`) collects edits; it does not decide where they live, because a
+ * note that survives a reload has to go somewhere only the app knows about.
+ */
+interface GridNotesConfig<TRow = GridRowData> {
+    /**
+     * This cell's note, or null.
+     *
+     * Called for every RENDERED cell, so make it a lookup — a Map keyed by
+     * `${rowKey}:${columnId}` is the shape that fits. Anything that scans per
+     * call turns a viewport into quadratic work.
+     */
+    get: (ctx: NoteCellContext<TRow>) => string | null | undefined;
+    /**
+     * The user changed a note; `text` is null when they cleared it.
+     *
+     * Its PRESENCE is what makes notes editable: without it the grid shows notes
+     * and offers no way to write one, which is the right behaviour for a grid
+     * displaying notes that came from somewhere else.
+     */
+    onChange?: (ctx: NoteCellContext<TRow> & {
+        text: string | null;
+    }) => void;
+    /**
+     * Append add/edit/delete items to the row context menu. Default true when
+     * `onChange` is given.
+     *
+     * Turn it off to place the items yourself — the grid's own menu entries are a
+     * convenience, not the only way in.
+     */
+    menu?: boolean;
+}
+/** Grid-wide tooltip behaviour (P2.1). */
+interface GridTooltipConfig {
+    /** Off entirely, truncation fallback included. Default true. */
+    enabled?: boolean;
+    /**
+     * Milliseconds of hover before it appears. Default 400 — long enough that
+     * sweeping the pointer across a grid does not strobe, short enough to feel
+     * like an answer rather than a wait.
+     */
+    delay?: number;
+    /**
+     * Show the full text when a cell's content is clipped. Default true; this is
+     * the behaviour the column API exists to override, not the other way round.
+     */
+    showOnTruncation?: boolean;
+}
+type ReactColumnRuntime<TRow = GridRowData> = Omit<ColumnRuntime<TRow>, 'def'> & {
+    def: ReactGridColumnDef<TRow>;
+};
+/** Vertical rhythm preset. `rowHeight` overrides whatever this resolves to. */
+type GridDensity = 'compact' | 'normal' | 'comfortable';
+/** Row height each density resolves to — the value the virtualizer runs on. */
+declare const DENSITY_ROW_HEIGHT: Record<GridDensity, number>;
+/**
+ * A packaged look. Purely visual: no theme changes what the grid does, which
+ * columns it shows, or how any of it behaves.
+ *
+ * The palettes, metrics and line work live in DataGridThemes.css and are ours
+ * — nothing is imported or copied from a third-party grid's stylesheet. The
+ * names are the shared vocabulary for a grid's chrome and density, in the same
+ * way a typeface is described as "grotesque".
+ */
+type GridTheme = 
+/** Minimal chrome: no column rules, hairline rows, roomy radii. */
+'quartz'
+/** Dense and fully ruled — small type, tight padding, square corners. */
+ | 'balham'
+/** Tall rhythm, rows-only rules, medium-weight tracked header, real elevation. */
+ | 'material'
+/** Airy but fully framed, with a doubled rule anchoring the header band. */
+ | 'alpine'
+/** KanuniLabs house theme: ink header, brand gold accent, warm near-white body. */
+ | 'kanuni'
+/** The house theme in dark. Applies without `dark`. */
+ | 'kanuni-midnight';
+/** Every packaged theme, in the order the docs and the playground list them. */
+declare const GRID_THEMES: readonly GridTheme[];
+/**
+ * Row height per theme and density.
+ *
+ * This table exists in JS and not in CSS for the same reason `DENSITY_ROW_HEIGHT`
+ * does: the row height is a CORE value — the virtualizer computes every row
+ * offset and the scroll extent from it — so it has to reach the engine as a
+ * number. Everything else a theme changes about the rhythm (header height, cell
+ * padding, type scale, control sizes) is CSS's, and lives only there, so the
+ * two can never hold different opinions about the same measurement.
+ *
+ * Keep in sync with the `--dg-header-height` values in DataGridThemes.css.
+ */
+declare const THEME_ROW_HEIGHT: Record<GridTheme, Record<GridDensity, number>>;
+/**
+ * A colour scheme, independent of the theme.
+ *
+ * The theme decides the STRUCTURE — where the rules are drawn, how tall a row
+ * is, how round a control is, how much a popup lifts. A palette decides only
+ * the colours. They compose: `theme="balham" palette="nord"` is Balham's dense
+ * ruled grid in Nord's arctic blues; `theme="material" palette="nord"` is
+ * Material's tall airy one in the same blues.
+ *
+ * Each ships a light and a dark set, so `dark` keeps working across all of
+ * them. Every one clears WCAG AA on the surfaces that carry text — measured,
+ * and pinned by a test.
+ *
+ * The names are the colour schemes people already know from their editors. The
+ * hues are theirs; the mapping onto the grid's tokens, and the contrast work
+ * that mapping needs, are ours. No third-party stylesheet is involved.
+ */
+type GridPalette = 
+/** Arctic, desaturated blue-grey. The calmest of the six. */
+'nord'
+/** Near-black violet with high-chroma purple and pink. */
+ | 'dracula'
+/** The fixed-lightness classic, designed as a matched light/dark pair. */
+ | 'solarized'
+/** Warm retro, high contrast — the only genuinely warm light mode here. */
+ | 'gruvbox'
+/** Pastel, with very close surface tones. Easy for a long reading session. */
+ | 'catppuccin'
+/** Deep navy with violet and cyan; the most saturated dark. */
+ | 'tokyo-night';
+/** Every packaged palette, in the order the docs and the playground list them. */
+declare const GRID_PALETTES: readonly GridPalette[];
+/**
+ * The modifier classes a theme contributes, as one string.
+ *
+ * Composed ONCE per grid and handed to the popup surfaces that render outside
+ * the grid's DOM (portals, dialogs, the row editor). Those cannot inherit the
+ * class through the cascade, and the tokens are declared on the theme class —
+ * so without this they render in the packaged palette while the grid behind
+ * them is in another one. It is the same reason `dark` is forwarded explicitly.
+ *
+ * A plain string, deliberately: nothing here is per-row or per-cell work.
+ */
+declare function themeClassName(theme?: GridTheme, density?: GridDensity, palette?: GridPalette): string;
+interface GridMenuItem<TContext = unknown> {
+    /** Stable key; falls back to the index when omitted. */
+    id?: string;
+    label?: string;
+    icon?: ReactNode;
+    /** Right-aligned hint, e.g. "Ctrl+C". Purely visual — no binding is created. */
+    shortcut?: string;
+    disabled?: boolean;
+    /** Renders a divider instead of an item. */
+    separator?: boolean;
+    /** One level of nesting. */
+    items?: GridMenuItem<TContext>[];
+    onSelect?: (context: TContext) => void;
+}
+/** What a row template is handed. */
+interface RowTemplateContext<TRow = GridRowData> {
+    row: TRow;
+    node: RowNode<TRow>;
+    /** Position in the current view. */
+    rowIndex: number;
+    selected: boolean;
+    /** True when this is the focused row (`focusedRow` is on). */
+    focused: boolean;
+}
+/** What a header menu is opened against. */
+interface HeaderMenuContext {
+    columnId: string;
+    /** Header text as rendered, for labels and announcements. */
+    headerName: string;
+}
+/** What a row menu is opened against. */
+interface RowMenuContext<TRow = GridRowData> {
+    row: TRow;
+    node: RowNode<TRow>;
+    /** Index in the current view. */
+    rowIndex: number;
+    /** Column under the pointer, when the menu was opened from a cell. */
+    columnId: string | null;
+    /** Selected row keys at the moment the menu opened. */
+    selectedKeys: RowKey[];
+}
+interface DataGridProps<TRow = GridRowData> extends Omit<DataGridCoreConfig<TRow>, 'columns'> {
+    /**
+     * Optional: with an ARRAY data source and no columns, one column per field
+     * is derived from the data (see `autoColumns`). A remote `DataSource` must
+     * declare them — there is nothing to sample before the first fetch.
+     */
+    columns?: ReactGridColumnDef<TRow>[];
+    /**
+     * Tunes the columns derived from the data when `columns` is omitted:
+     * `sampleSize`, `include`, `exclude`, `humanizeHeaders`, `defaults`.
+     * `false` turns the derivation off and leaves the grid with no columns.
+     */
+    autoColumns?: boolean | InferColumnsOptions;
+    /**
+     * Drag rows to reorder them, and — with a shared `group` — between two
+     * grids. A grip appears at the start of each row on hover.
+     *
+     * Reordering the grid's own array only works on an UNSORTED view: with a
+     * sort active the sort decides the order and the drop would be invisible.
+     * Handle `onReorder` yourself (updating an order field, or the server) to
+     * support a sorted grid.
+     */
+    rowDrag?: RowDragConfig<TRow>;
+    className?: string;
+    style?: React.CSSProperties;
+    /** Applies the packaged dark palette. */
+    dark?: boolean;
+    /**
+     * A packaged look — `'quartz'`, `'balham'`, `'material'`, `'alpine'`,
+     * `'kanuni'` or `'kanuni-midnight'`. Omit for the default palette, which is
+     * unchanged and always will be.
+     *
+     * Switchable at runtime: it resolves to one class on the grid root, so
+     * changing it repaints without rebuilding anything. Combines with `dark`
+     * (each theme ships both palettes) and with `density`. `'kanuni-midnight'`
+     * is already dark and ignores the flag.
+     *
+     * Every colour, metric and border the stylesheet draws with is a `--dg-*`
+     * custom property, so a theme is a token override and nothing more — override
+     * the same properties yourself under your own class to go further.
+     */
+    theme?: GridTheme;
+    /**
+     * A colour scheme, on top of whatever `theme` decides about structure —
+     * `'nord'`, `'dracula'`, `'solarized'`, `'gruvbox'`, `'catppuccin'` or
+     * `'tokyo-night'`.
+     *
+     * Independent of `theme`, so the two multiply: Balham's dense ruled grid in
+     * Nord's blues, or Material's tall one in the same blues. Works with `dark`
+     * (each palette ships both), and without a `theme` it recolours the packaged
+     * default. Omit it and the theme's own colours apply.
+     */
+    palette?: GridPalette;
+    /** Alternating row background. */
+    striped?: boolean;
+    /** Shown when the pipeline yields no rows. */
+    emptyText?: string;
+    /** Header click sorting (multi-sort follows `sorting.multi` + Shift). */
+    sortable?: boolean;
+    /** Text-input row under the header, one box per column. */
+    filterRow?: boolean;
+    /**
+     * Milliseconds to wait after the last keystroke before applying a filter-row
+     * value. `0` applies on every keystroke.
+     *
+     * Defaults to **0 for client data** (filtering is local and instant — adding a
+     * delay to something already immediate would be a regression in feel) and
+     * **200 for a remote `DataSource`**, where each keystroke is a network round
+     * trip: typing "Marmara" used to open seven queries, six of them already
+     * superseded by the time they answered.
+     *
+     * Set it explicitly on a very large CLIENT grid, where one pass is expensive
+     * enough that coalescing keystrokes is worth a short delay.
+     *
+     * Enter, or moving focus out of the box, always applies immediately.
+     */
+    filterDebounce?: number;
+    /**
+     * A bar under the footer stating the active filter in words, with a checkbox
+     * that suspends it and an `×` that removes it — the DevExpress cxGrid filter
+     * panel.
+     *
+     * `true` shows it only while something is filtered; `'always'` keeps it in
+     * place. It describes the FULL filter — the builder's conditions and every
+     * column funnel and filter-row entry, combined — which is what makes it the
+     * one place to read back why the grid is showing 12 of 100.000 rows.
+     */
+    filterPanel?: boolean | 'always';
+    /** Wording for the filter panel's sentence — `and` / `or` / `is` / `blank`… */
+    filterPanelLabels?: DescribeFilterOptions;
+    /**
+     * Opens the app's filter builder from the panel's chevron. Without it the
+     * chevron is not rendered, because a control that opens nothing is worse than
+     * no control. `EnterpriseDataGrid` wires this to its own builder.
+     */
+    onOpenFilterBuilder?: () => void;
+    /** Funnel button per header opening the distinct-value checklist popup. */
+    headerFilter?: boolean;
+    /**
+     * When the funnel is visible. `'hover'` (default) keeps the header clean and
+     * reveals it on hover or keyboard focus; `'always'` pins it. A column that is
+     * actually filtered always shows its funnel, in either mode.
+     */
+    filterIconMode?: 'hover' | 'always';
+    /** Drag a header onto another header to change the column order. Default on. */
+    columnReorder?: boolean;
+    /** Width drag handle on each header's trailing edge; double-click best-fits. Default on. */
+    columnResize?: boolean;
+    /**
+     * Overlay shown while the grid is busy, with a percentage where one exists.
+     * Default on. A number sets how many milliseconds of work must pass before it
+     * appears (default 300) — short operations finish without ever showing it.
+     */
+    loadingOverlay?: boolean | number;
+    /** Fired on Enter / double-click over the focused row. */
+    onRowActivate?: (node: RowNode<TRow>) => void;
+    /** Announcements for screen readers (sort/filter/selection). Defaults on. */
+    announcements?: boolean;
+    /** Drop area above the grid for grouping by a column. */
+    groupPanel?: boolean;
+    /**
+     * Vertical rhythm preset. Resolves to a row height, header height, font size
+     * and cell padding. An explicit `rowHeight` still wins — density is a
+     * shorthand, not an override.
+     */
+    density?: GridDensity;
+    /**
+     * Right-click (and Shift+F10 / ContextMenu key) menu for data rows. A
+     * function receives the row that was clicked, so the items can depend on it.
+     * Returning an empty list suppresses the menu for that row.
+     */
+    rowMenu?: GridMenuItem<RowMenuContext<TRow>>[] | ((context: RowMenuContext<TRow>) => GridMenuItem<RowMenuContext<TRow>>[]);
+    /**
+     * The grid's OWN cell-menu entries — clipboard and export — appended below
+     * whatever `rowMenu` supplies. See {@link CellMenuOptions}.
+     *
+     * On by default: a right-click that offers no way to copy the cell is the
+     * gap this closes, and an app that wants the menu bare passes `false`.
+     * `rowMenu` is untouched either way — an app's items keep the order it wrote
+     * them in, and the built-ins read as an addition after a separator.
+     */
+    cellMenu?: boolean | CellMenuOptions;
+    /**
+     * Right-click menu on COLUMN HEADERS: sort, group, footers, hide, field
+     * chooser, best fit. `true` (default) uses the built-in list; a function
+     * receives it and returns the list to show, so an app can drop items or
+     * append its own. `false` turns it off and lets the browser menu through.
+     */
+    headerMenu?: boolean | ((context: HeaderMenuContext, defaults: GridMenuItem<HeaderMenuContext>[]) => GridMenuItem<HeaderMenuContext>[]);
+    /**
+     * Highlight the row holding focus. Distinct from selection: focus is where
+     * the keyboard is, selection is what an action applies to — a grid that
+     * conflates them cannot express "look at this row without selecting it".
+     */
+    focusedRow?: boolean;
+    /** Focus this row on mount / when the prop changes (controlled focus). */
+    focusedRowKey?: RowKey | null;
+    /** Fired when the focused ROW changes — not on every cell move within it. */
+    onFocusedRowChanged?: (event: {
+        rowKey: RowKey | null;
+        row?: TRow;
+    }) => void;
+    /**
+     * @deprecated Retired 2026-08-15 and now a no-op; the prop is kept so
+     * existing call sites do not break, and will be dropped in a later major.
+     *
+     * It rendered a strip under the grid whose only remaining content was the row
+     * count. That strip once carried the per-column totals too, but punch item
+     * #18 moved those into the column-aligned footer ROW, where each number sits
+     * under the column it belongs to — leaving a whole bar to say one number.
+     * With the Enterprise status bar switched on, that number was then printed
+     * twice, one line above itself.
+     *
+     * Where the count lives now: the **status bar** (`statusBar`, Enterprise —
+     * it reports total, filtered and selected), or the **pager**, which shows the
+     * total whenever pagination is on.
+     */
+    showRowCount?: boolean;
+    /**
+     * Column-aligned totals row at the bottom of the grid. Defaults to on when
+     * `summaries` is non-empty. Turning it on with no summaries shows an empty
+     * row, which is how the user reaches the per-column aggregation menu.
+     */
+    footer?: boolean;
+    /**
+     * Right-click (and click) on a footer cell opens the aggregation picker —
+     * Count / Sum / Average / Min / Max, filtered to what the column's data type
+     * supports. `false` makes the footer read-only.
+     */
+    footerMenu?: boolean;
+    /** Toolbar with search, column chooser and export. */
+    toolbar?: boolean;
+    /**
+     * The toolbar's Columns button — the popup listing HIDDEN columns. Default
+     * true. The Enterprise wrapper turns it off when the side bar's Columns
+     * panel is showing: two surfaces answering "where did my column go" is one
+     * more than anyone needs, and the panel is the fuller of the two.
+     */
+    toolbarColumnChooser?: boolean;
+    /** Add an Excel entry to the toolbar's export menu (needs the optional `exceljs` peer). */
+    toolbarExcel?: boolean;
+    /**
+     * Add a PDF entry to the toolbar's export menu (needs the optional `jspdf`
+     * and `jspdf-autotable` peers).
+     *
+     * Off by default for the same reason as Excel: an entry that is always there
+     * would fail on a grid that never installed the libraries, and a menu item
+     * that throws is worse than one that is absent.
+     */
+    toolbarPdf?: boolean;
+    /** Extra toolbar controls, before / after the built-in ones. */
+    toolbarItemsBefore?: ReactNode;
+    toolbarItemsAfter?: ReactNode;
+    /**
+     * Replace each DATA row's content. Group headers and detail panels keep
+     * their own rendering — a template that had to handle those too would be a
+     * template of the whole grid.
+     *
+     * The row ELEMENT stays: it carries the height, the aria indices and the
+     * click handlers the virtualizer and selection depend on. What the template
+     * replaces are the cells — so in-cell editing, range selection and the fill
+     * handle have nothing to attach to while it is on. For per-cell
+     * customization that keeps the column layout, use a column's `renderCell`.
+     */
+    renderRow?: (ctx: RowTemplateContext<TRow>) => ReactNode;
+    /**
+     * Remember the user's columns, sort, filters and grouping between visits.
+     * Off by default: persisting a layout the app never asked to persist is a
+     * surprise, and the storage key is shared ground the app may own.
+     */
+    stateStoring?: StateStoringConfig;
+    /**
+     * Cell and header tooltips (P2.1). On by default — with no configuration at
+     * all, a cell whose text is clipped shows it in full on hover, which is the
+     * complaint this exists to answer. Pass `{ enabled: false }` to opt out, or
+     * see a column's `tooltip` / `tooltipField` to say something else.
+     */
+    tooltip?: GridTooltipConfig;
+    /**
+     * Rows fixed above the scrolling body (P2.3) — a target line, last year's
+     * figures, a row the user pinned for comparison.
+     *
+     * They are NOT data: never sorted, filtered, paged, selected or counted, and
+     * not included in an export. Everything visual is shared with a real row
+     * (columns, widths, pinned offsets, `renderCell`), so the two stay aligned.
+     * For totals over the grid's own rows, use `summaries` — that is what the
+     * footer row is.
+     */
+    pinnedTopRows?: readonly TRow[];
+    /** Rows fixed below the scrolling body. See `pinnedTopRows`. */
+    pinnedBottomRows?: readonly TRow[];
+    /**
+     * Which edge the grand total row sticks to (P2.8). Default `'bottom'`.
+     *
+     * Same row either way — the column-aligned totals over the filtered result,
+     * with the same aggregation menu. `'top'` is for a grid read top-down, where
+     * the totals are the headline; the rows below are then the evidence for it.
+     */
+    footerPosition?: 'top' | 'bottom';
+    /**
+     * What to do with the column widths once the grid knows how much room it has
+     * (gap analysis P2.5). Default `'none'` — the configured widths are used as
+     * written, which is what every existing grid already does.
+     *
+     * - `'fitGrid'` spreads the columns across the width so they fill it exactly,
+     *   proportionally to their configured widths, re-applied when the grid is
+     *   resized. For a grid that should never show empty canvas or a horizontal
+     *   scrollbar.
+     * - `'fitCells'` measures the rendered content and sizes each column to it —
+     *   the "best fit" the header menu offers, applied once to every column after
+     *   the first rows paint. It can overflow the grid; that is the point.
+     *
+     * A user resize is not undone by either: `'fitGrid'` re-runs on a GRID resize
+     * and takes the current widths as its proportions, so a column the user made
+     * wider stays proportionally wider.
+     */
+    autoSizeStrategy?: 'none' | 'fitGrid' | 'fitCells';
+    /**
+     * Mark the search term inside cell text (gap analysis P2.4). Default true.
+     *
+     * The search already decides which rows survive; without the marks the user
+     * is left scanning fifteen columns for the reason a row is on screen. Only
+     * the grid's own rendering is marked up — a column with a `renderCell` owns
+     * its output and is left alone.
+     */
+    highlightSearch?: boolean;
+    /**
+     * A leading column numbering the rows (gap analysis P3.5). Default false.
+     *
+     * The number is the row's position in WHAT IS SHOWN — it renumbers after a
+     * sort or a filter rather than carrying a record's identity around. A stable
+     * per-record number is a column of your data; this is a reading aid, the one
+     * users mean when they say "the third row".
+     *
+     * With pagination on it continues across pages: page 2 of 50 starts at 51,
+     * because a second page starting at 1 again says nothing about position.
+     * Group headers and detail panels get an empty cell — a number on a group
+     * header would claim it is a record.
+     */
+    rowNumbers?: boolean;
+    /**
+     * Print the whole grid instead of the screenful that happened to be visible
+     * (gap analysis P3.4). Off by default.
+     *
+     * Virtualization is what makes a printed grid useless: the browser gets the
+     * twenty rows inside a clipped, fixed-height box and paginates those. With
+     * this on, `beforeprint` switches the grid to a mode that renders every row
+     * and lets the box grow, and `afterprint` puts it back — the user's scroll
+     * position and selection survive, because only the rendering changed.
+     *
+     * `{ always: true }` stays in that mode permanently, for rendering a grid
+     * into a report page where there is no print dialog to react to.
+     *
+     * `{ maxRows }` (default 5.000) is where it refuses. Print layout puts every
+     * row in the DOM; at a hundred thousand that is a frozen tab, which is worse
+     * than a short printout. Past the cap the grid prints what it always did and
+     * says so under `debugMode` — `exportPdf()` is the tool at that size, and it
+     * streams.
+     */
+    printLayout?: boolean | PrintLayoutOptions;
+    /**
+     * Keep this grid's COLUMN LAYOUT and horizontal scroll in step with every
+     * other grid given the same name (gap analysis P3.2).
+     *
+     * For two grids that have to read as one table — a scrolling body with a
+     * fixed totals strip under it, or a master and a detail over the same
+     * columns. Resize, move, hide or pin a column in one and the others follow;
+     * scroll one sideways and the others keep pace.
+     *
+     * Sort, filter, selection and VERTICAL scroll deliberately do not travel.
+     * Aligned grids share a shape, not a result — a summary strip that re-sorted
+     * itself because the grid above it did would be answering a different
+     * question. Columns the peer does not have are ignored, so a three-column
+     * strip can align under a twelve-column grid.
+     */
+    alignedGrids?: string;
+    /**
+     * Cell notes (gap analysis P3.3) — user-written prose attached to a cell,
+     * marked with a corner triangle and revealed on hover. See
+     * {@link GridNotesConfig}.
+     */
+    notes?: GridNotesConfig<TRow>;
+    onRowClick?: (node: RowNode<TRow>) => void;
+    /**
+     * Imperative access to the controller (§5.3) — search, filters, layout,
+     * export. Called once per controller instance; keep the callback stable
+     * (useCallback) or it will fire on every render.
+     */
+    onReady?: (controller: DataGridController<TRow>) => void;
+    /** Replace a cell's content (e.g. with an editor). Return undefined for default. */
+    renderCellContent?: (ctx: CellSlotContext<TRow>) => ReactNode | undefined;
+    /** Extra class names per cell (dirty marker, range highlight, invalid). */
+    getCellClassName?: (ctx: CellSlotContext<TRow>) => string | undefined;
+    /** Absolutely-positioned layer over the viewport (fill handle, watermark). */
+    renderOverlay?: () => ReactNode;
+    /** Pointer down on a cell, with the view coordinates the range engine needs. */
+    onCellPointerDown?: (ctx: CellSlotContext<TRow>, event: React.MouseEvent) => void;
+    onCellPointerEnter?: (ctx: CellSlotContext<TRow>, event: React.MouseEvent) => void;
+    onCellDoubleClick?: (ctx: CellSlotContext<TRow>) => void;
+    /**
+     * Unlocks the Enterprise edition. **Set by `EnterpriseDataGrid`** — an app
+     * rendering `DataGrid` directly leaves it off.
+     *
+     * The engine keeps every capability either way: the pipeline (filter → sort →
+     * group → aggregate) is one piece, and an edition boundary cutting through it
+     * would be a fork rather than a gate. What this flag decides is what the
+     * COMPONENT agrees to switch on. See `gateEdition` for the removals and
+     * `DataGridController.setEnterpriseEdition` for the imperative half.
+     *
+     * Off, the following are declined (each says why under `debugMode`):
+     * multi-level grouping (capped at one level), `grouping.groupSummaries`,
+     * `masterDetail`, `tree`, `summaries` (footer column totals), column
+     * `spanRows`, `notes`, Excel and PDF export. A server-side `DataSource`
+     * THROWS rather than being stripped — an empty grid sends the developer
+     * hunting in their backend.
+     *
+     * Community keeps: virtual scrolling at a million rows, worker offload,
+     * sorting, the column family, filtering, selection, pagination, single-level
+     * grouping, CSV export, themes, 12 locales and the whole event/imperative
+     * API. Boundary set with the user on 2026-08-14 against AG Grid's own line.
+     */
+    enterpriseEdition?: boolean;
+    /**
+     * Body of a row's detail panel. Required for the expander column to appear —
+     * together with `masterDetail` on the config.
+     */
+    renderDetail?: (row: TRow) => ReactNode;
+    /**
+     * Body of the in-grid edit form (`mode: 'form'`), rendered in the row flow
+     * under the record it edits. Set by `EnterpriseDataGrid`; the form's position
+     * and height come from `controller.setEditFormRow`.
+     */
+    renderEditForm?: (rowKey: RowKey, row: TRow | undefined) => ReactNode;
+}
+interface CellSlotContext<TRow = GridRowData> {
+    node: RowNode<TRow>;
+    columnId: string;
+    /** Row position in the current view. */
+    rowIndex: number;
+    /** Column position in visual order (pinned-left → center → right). */
+    columnIndex: number;
+    value: unknown;
+}
+
+declare function DataGrid<TRow = GridRowData>(props: DataGridProps<TRow>): react.JSX.Element;
+
+interface GridHeaderProps<TRow = GridRowData> {
+    layout: ColumnLayout<TRow>;
+    /**
+     * Height of the band rows above, in px. The header sticks BELOW them rather
+     * than at 0 — otherwise scrolling down slides the header up over the bands
+     * it belongs to.
+     */
+    bandOffset?: number;
+    centerColumns: ReactColumnRuntime<TRow>[];
+    /** Inset per STICKY center column, by id. See RenderGeometry.stickyInsets. */
+    stickyInsets?: ReadonlyMap<string, number>;
+    leadingSpacer: number;
+    trailingSpacer: number;
+    sort: SortDescriptor[];
+    sortable: boolean;
+    onSort: (columnId: string, additive: boolean) => void;
+    /** Renders the funnel button that opens the distinct-value popup. */
+    headerFilter?: boolean;
+    /** Leading select-all checkbox column. */
+    checkboxColumn?: boolean;
+    /** Leading expander column for master-detail (Enterprise). */
+    detailColumn?: boolean;
+    /** Leading row-number column (gap analysis P3.5). */
+    rowNumberColumn?: boolean;
+    /** What the row-number column's header shows. Defaults to `#`. */
+    rowNumberHeader?: React.ReactNode;
+    /** 'all' | 'some' | 'none' — drives the tri-state select-all box. */
+    selectAllState?: 'all' | 'some' | 'none';
+    onToggleSelectAll?: () => void;
+    /** Make headers draggable onto the group panel. */
+    draggable?: boolean;
+    /** Column ids that currently have a filter (funnel shown as active). */
+    filteredColumns?: string[];
+    onOpenFilter?: (columnId: string, anchor: HTMLElement) => void;
+    /**
+     * When the funnel is visible. `'hover'` (default) keeps the header clean and
+     * reveals it on hover/keyboard focus; `'always'` pins it. A column that IS
+     * filtered shows its funnel in both modes — hiding the only indicator that a
+     * filter is active would make rows disappear for no visible reason.
+     */
+    filterIconMode?: 'hover' | 'always';
+    /** Drag a header onto another to change the column order. */
+    reorderable?: boolean;
+    /** `beforeId === undefined` means "move to the end". */
+    onReorder?: (columnId: string, beforeId: string | undefined) => void;
+    /** Drag handle on the trailing edge of each header. */
+    resizable?: boolean;
+    /** `finished` is false while dragging, true once on release. Absent = one-shot. */
+    onResize?: (columnId: string, width: number, finished?: boolean) => void;
+    /** Double-click on the resize handle, and the context-menu "best fit" item. */
+    onAutoFit?: (columnId: string) => void;
+    /** Right-click on a header cell (Enterprise header menu). */
+    onHeaderContextMenu?: (columnId: string, event: React.MouseEvent) => void;
+}
+declare function GridHeaderImpl<TRow = GridRowData>({ bandOffset, stickyInsets, layout, centerColumns, leadingSpacer, trailingSpacer, sort, sortable, onSort, headerFilter, filteredColumns, onOpenFilter, filterIconMode, checkboxColumn, detailColumn, rowNumberColumn, rowNumberHeader, selectAllState, onToggleSelectAll, draggable, reorderable, onReorder, resizable, onResize, onAutoFit, onHeaderContextMenu, }: GridHeaderProps<TRow>): react.JSX.Element;
+declare const GridHeader: typeof GridHeaderImpl;
+
+/**
+ * Height of one band row. Shorter than a column header on purpose: a band is a
+ * grouping caption, and giving it the same weight as the headers underneath
+ * makes the real headers harder to scan.
+ */
+declare const BAND_ROW_HEIGHT = 26;
+interface GridHeaderBandsProps<TRow = GridRowData> {
+    layout: ColumnLayout<TRow>;
+    /** The virtualized slice of the centre block, as the header renders it. */
+    centerColumns: ReactColumnRuntime<TRow>[];
+    leadingSpacer: number;
+    trailingSpacer: number;
+    /** Number of band rows. Nothing renders at 0. */
+    depth: number;
+    checkboxColumn?: boolean;
+    detailColumn?: boolean;
+    /** Leading row-number column (gap analysis P3.5). */
+    rowNumberColumn?: boolean;
+    /** Height of one band row, in px. Defaults to `BAND_ROW_HEIGHT`. */
+    rowHeight?: number;
+    /**
+     * Folding (gap analysis P2.6). Absent leaves bands display-only, exactly as
+     * they were — a grid whose columns declare no `bandShow` never sees a toggle.
+     */
+    bandFold?: {
+        /** Band path of a column, outermost first. */
+        pathOf: (columnId: string) => string[];
+        collapsible: (path: readonly string[]) => boolean;
+        collapsed: (path: readonly string[]) => boolean;
+        onToggle: (path: string[]) => void;
+        labels: {
+            expand: string;
+            collapse: string;
+        };
+    };
+}
+declare function GridHeaderBandsImpl<TRow = GridRowData>({ layout, centerColumns, leadingSpacer, trailingSpacer, depth, checkboxColumn, detailColumn, rowNumberColumn, rowHeight, bandFold, }: GridHeaderBandsProps<TRow>): react.JSX.Element | null;
+declare const GridHeaderBands: typeof GridHeaderBandsImpl;
+
+interface GridRowProps<TRow = GridRowData> {
+    /** Used to build stable cell ids for aria-activedescendant. */
+    gridId: string;
+    node: RowNode<TRow>;
+    /** Row's ordinal in the view (drives striping). */
+    index: number;
+    layout: ColumnLayout<TRow>;
+    columnModel: ColumnModel<TRow>;
+    /** Center columns inside the horizontal window. */
+    centerColumns: ReactColumnRuntime<TRow>[];
+    /**
+     * True index in `layout.center` for each rendered center column.
+     *
+     * A column's position in `centerColumns` is NOT its position in the grid —
+     * the block is a window slice with scrolled-past sticky columns spliced onto
+     * the front. Deriving the index from the loop counter made every center
+     * column report a smaller `aria-colindex` the further right the grid was
+     * scrolled, and put the range anchor and fill handle on the wrong column.
+     */
+    centerIndices?: readonly number[];
+    /** Inset per STICKY center column, by id. See RenderGeometry.stickyInsets. */
+    stickyInsets?: ReadonlyMap<string, number>;
+    /** Width of the center columns skipped to the left of the window. */
+    leadingSpacer: number;
+    /** Width of the center columns skipped to the right of the window. */
+    trailingSpacer: number;
+    striped: boolean;
+    selected: boolean;
+    /** Column id holding keyboard focus in this row, or null. */
+    focusedColumnId: string | null;
+    /** Highlight this row as the focused one (`focusedRow` is on). */
+    rowFocused?: boolean;
+    /**
+     * Replace the row's CONTENT with arbitrary markup. The row element itself
+     * stays — it carries the height, the aria indices and the click handlers the
+     * virtualizer and selection depend on, so a template that owned the whole
+     * element would have to reproduce all of it correctly to work at all.
+     */
+    renderRow?: (ctx: RowTemplateContext<TRow>) => React.ReactNode;
+    /**
+     * Row drag & drop (gap G7). A sticky GRIP is rendered at the row's inline
+     * start rather than a lead column: a third lead column would have to be
+     * threaded through `leadColumnWidth`, every sticky offset and every
+     * aria-colindex in six components, and this file already warns that those
+     * drifting apart is what desynchronizes header and body.
+     */
+    rowDrag?: RowDragHandlers;
+    /** Which edge to draw the drop line on, or null. */
+    dropSide?: 'before' | 'after' | null;
+    /** Renders the leading checkbox cell. */
+    checkboxColumn: boolean;
+    /** Renders the leading row-number cell (gap analysis P3.5). */
+    rowNumberColumn?: boolean;
+    /**
+     * This cell's note, or null (gap analysis P3.3). Only the MARKER is decided
+     * here — the text itself is revealed by the tooltip layer, which reads the
+     * same source at hover time.
+     *
+     * Called once per rendered cell, so the config's `get` has to be a lookup.
+     */
+    getNote?: (rowKey: RowKey, columnId: string, row: TRow) => string | null | undefined;
+    /**
+     * How this row takes part in a merged block for a column (gap analysis P3.1),
+     * or null when the column does not merge here.
+     *
+     * Resolved by the caller: deciding it needs the run list AND the window's
+     * bounds, and the row knows neither. `height` is already in pixels because
+     * only the caller can ask the engine what the covered rows really measure —
+     * an `autoHeight` row in the middle of a block is not `rowHeight` tall.
+     *
+     * Takes the row index rather than arriving pre-bound to it. A closure per row
+     * defeats this component's memo, and with an `autoHeight` column that turns
+     * into a measure/re-render loop React ends with "Maximum update depth
+     * exceeded".
+     */
+    getSpan?: (rowIndex: number, columnId: string) => {
+        kind: 'draw';
+        height: number;
+        offset: number;
+    } | {
+        kind: 'covered';
+    } | null;
+    /**
+     * The number to show, already resolved (see `rowNumberAt` in geometry).
+     *
+     * Resolved by the caller rather than derived from `index` here, because the
+     * ordinal is NOT the number: group banners occupy view positions, and
+     * pagination offsets the count. A row that computed it itself would have to
+     * know about both.
+     *
+     * `null` means this row is not part of the numbering and gets an empty cell.
+     * Pinned rows are the case: they sit outside the result rather than at a
+     * position in it, and numbering them from their own index made a pinned row
+     * and the first data row both claim to be row 1.
+     */
+    rowNumber?: number | null;
+    /** Number of non-data rows above (header, and the filter row when shown). */
+    headerRowCount: number;
+    /**
+     * The extra arguments are OPTIONAL on purpose, and ordered to match
+     * `onRowContextMenu` below. The grid passes them so the adapter can resolve
+     * WHICH CELL was hit (`closest('[data-column-id]')`) and publish
+     * `cellClicked` / `rowClicked`; a caller that only wants the row keeps
+     * passing a one-argument function, which stays assignable.
+     */
+    onRowClick?: (node: RowNode<TRow>, rowIndex?: number, event?: React.MouseEvent) => void;
+    onRowMouseDown?: (node: RowNode<TRow>, event: React.MouseEvent) => void;
+    onRowDoubleClick?: (node: RowNode<TRow>, rowIndex?: number, event?: React.MouseEvent) => void;
+    onToggleSelect?: (node: RowNode<TRow>) => void;
+    onCellMouseDown?: (node: RowNode<TRow>, columnId: string) => void;
+    /** Right-click on a data row (row menu). */
+    onRowContextMenu?: (node: RowNode<TRow>, rowIndex: number, event: React.MouseEvent) => void;
+    onToggleGroup?: (groupKey: string) => void;
+    /** Tree data (P1.4): expand/collapse from the first column's toggle. */
+    onToggleTreeRow?: (rowKey: RowKey) => void;
+    /**
+     * Bumped by `controller.refreshCells()` (P1.7). Read by nothing — its only
+     * job is to differ, so the row memo lets a re-render through when the DATA
+     * behind a `valueGetter` changed without the node identity changing.
+     */
+    revision?: number;
+    /**
+     * Lower-cased search term to mark up inside cell text (gap analysis P2.4).
+     *
+     * A PROP rather than a read of the controller, so it takes part in the row
+     * memo: when the search changes, the rows that need new markup re-render, and
+     * when it does not, they do not.
+     */
+    searchNeedle?: string;
+    /** Aggregate definitions rendered inside group headers (Enterprise). */
+    summaryDefs?: readonly SummaryDef<TRow>[];
+    /** Render a leading expander cell for master-detail (Enterprise). */
+    detailColumn?: boolean;
+    /** Whether THIS row's detail panel is open. */
+    detailExpanded?: boolean;
+    onToggleDetail?: (rowKey: RowKey) => void;
+    /** Panel body for a detail row (Enterprise slot). */
+    renderDetail?: (row: TRow) => React.ReactNode;
+    /**
+     * Body for an in-grid edit form (Enterprise slot, `mode: 'form'`).
+     *
+     * `row` is undefined for a record that does not exist yet — the form is
+     * still opened, because the alternative is pressing "New row" and seeing
+     * nothing happen.
+     */
+    renderEditForm?: (rowKey: RowKey, row: TRow | undefined) => React.ReactNode;
+    /**
+     * This row's own height, when it is NOT the standard one — a measured
+     * `autoHeight` row, or one `getRowHeight` sized.
+     *
+     * Undefined means standard, and undefined is the case worth optimizing: the
+     * element gets no inline style at all and inherits `--dg-row-height`, so a
+     * grid with uniform rows renders exactly the markup it did before any of this
+     * existed. Panels do not use this — they carry their height on the node.
+     */
+    height?: number;
+    renderCellContent?: (ctx: CellSlotContext<TRow>) => React.ReactNode | undefined;
+    getCellClassName?: (ctx: CellSlotContext<TRow>) => string | undefined;
+    onCellPointerDown?: (ctx: CellSlotContext<TRow>, event: React.MouseEvent) => void;
+    onCellPointerEnter?: (ctx: CellSlotContext<TRow>, event: React.MouseEvent) => void;
+    onCellDoubleClick?: (ctx: CellSlotContext<TRow>) => void;
+}
+declare function GridRowImpl<TRow = GridRowData>({ gridId, node, index, layout, columnModel, centerColumns, centerIndices, stickyInsets, leadingSpacer, trailingSpacer, striped, selected, focusedColumnId, rowFocused, renderRow, checkboxColumn, rowNumberColumn, rowNumber, getNote, getSpan, headerRowCount, onRowClick, onRowMouseDown, onRowDoubleClick, onToggleSelect, onCellMouseDown, onRowContextMenu, searchNeedle, onToggleGroup, summaryDefs, detailColumn, detailExpanded, onToggleDetail, onToggleTreeRow, renderDetail, renderEditForm, renderCellContent, getCellClassName, onCellPointerDown, onCellPointerEnter, onCellDoubleClick, rowDrag, dropSide, height, }: GridRowProps<TRow>): react.JSX.Element | null;
+declare const GridRow: typeof GridRowImpl;
+
+interface GridFilterRowProps<TRow = GridRowData> {
+    /**
+     * Total height of the band rows above the header, in pixels.
+     *
+     * Published as a custom property and added to the header height IN CSS,
+     * because the header height is density-dependent (28/32/40) and lives in a
+     * variable — computing the sum here would fork that mapping into JS. The
+     * stylesheet used to stick this row at the header height alone, ignoring the
+     * bands, so a banded grid parked the filter row inside the header and the two
+     * drew over each other as soon as the user scrolled.
+     */
+    bandOffset?: number;
+    layout: ColumnLayout<TRow>;
+    centerColumns: ReactColumnRuntime<TRow>[];
+    /** Inset per STICKY center column, by id. See RenderGeometry.stickyInsets. */
+    stickyInsets?: ReadonlyMap<string, number>;
+    leadingSpacer: number;
+    trailingSpacer: number;
+    /** Raw text per column id (controlled by the grid). */
+    values: Record<string, string>;
+    /** Leading non-data columns, so the row lines up with the header. */
+    checkboxColumn?: boolean;
+    detailColumn?: boolean;
+    /** Leading row-number column (gap analysis P3.5). */
+    rowNumberColumn?: boolean;
+    placeholder?: string;
+    onChange: (columnId: string, raw: string) => void;
+    /**
+     * The user has finished typing (Enter, or focus left the box). Applies the
+     * filter without waiting out the debounce.
+     */
+    onCommit?: (columnId: string, raw: string) => void;
+}
+/**
+ * Translate a raw input string into a filter node for one column.
+ * Exported because it is pure and worth testing without a DOM.
+ */
+declare function parseFilterInput(columnId: string, raw: string, dataType: GridDataType | undefined): FilterNode | null;
+/**
+ * The text that would produce `node` if it were typed into this column's box,
+ * or null when no text would.
+ *
+ * Used to show a restored filter in the box that owns it. The candidate is
+ * checked by parsing it back rather than trusted: a `contains` whose value
+ * happens to start with `>=` would parse as an operator and quietly become a
+ * different filter, and a box whose text does not mean what the grid is
+ * filtering by is worse than an empty one.
+ */
+declare function filterInputFromNode(columnId: string, node: FilterNode | null, dataType: GridDataType | undefined): string | null;
+/** What the reconciler needs to know about one column. Kept tiny so it is testable. */
+interface FilterInputSyncProbe {
+    /** The text is still on its way to the controller behind a debounce. */
+    isPending(columnId: string): boolean;
+    /**
+     * The text this column's box should show for the filter-row part the
+     * controller holds — `''` when it holds none, and null when the part cannot
+     * be written as text (set by code in a shape no box can express).
+     */
+    textFor(columnId: string): string | null;
+}
+/**
+ * Bring the boxes back in line with what the controller actually holds.
+ *
+ * The filter row's text is React state, not a view of the controller, so the
+ * two drift in both directions: a `clearColumnFilters()` from the filter panel
+ * left a box reading `Ankara` with nothing filtered, and a restored saved view
+ * filtered rows with every box blank. Since P3.7 the header popup keeps its own
+ * part on the same column, so a lying box is not a lone oddity any more — it is
+ * one of two visible surfaces contradicting the other.
+ *
+ * Two columns are deliberately left alone:
+ *  - one with a pending debounce — its text has not reached the controller yet,
+ *    so "no filter" means "not yet", not "cleared";
+ *  - one whose part cannot be expressed as text (`textFor` returns null), where
+ *    writing anything would misrepresent the filter.
+ *
+ * Text the user is in the middle of typing is protected by the caller, which
+ * does not treat its own commits as an external change — otherwise the `>` on
+ * the way to `> 100` would be deleted mid-keystroke.
+ *
+ * Returns `prev` unchanged when nothing needs to move, so React can skip the
+ * re-render entirely.
+ */
+declare function reconcileFilterInputs(prev: Record<string, string>, probe: FilterInputSyncProbe, columnIds?: readonly string[]): Record<string, string>;
+declare function GridFilterRowImpl<TRow = GridRowData>({ bandOffset, stickyInsets, layout, centerColumns, leadingSpacer, trailingSpacer, values, checkboxColumn, detailColumn, rowNumberColumn, placeholder, onChange, onCommit, }: GridFilterRowProps<TRow>): react.JSX.Element;
+declare const GridFilterRow: typeof GridFilterRowImpl;
+
+interface DistinctEntry {
+    value: unknown;
+    label: string;
+}
+interface GridHeaderFilterPopupProps {
+    /** Scopes the popup's remembered scroll/size so two grids do not share it. */
+    gridId?: string;
+    columnId: string;
+    headerLabel: string;
+    entries: DistinctEntry[];
+    /** Labels currently selected; empty means "no filter" (all shown). */
+    initialSelected: string[] | null;
+    anchor: {
+        left: number;
+        top: number;
+    };
+    /**
+     * The values are still being fetched (remote grids). The popup opens straight
+     * away — the user has already said where they want it — and fills in when they
+     * arrive. Apply is disabled meanwhile: applying an EMPTY list would mean
+     * "nothing selected", which on this grid means a filter, not a no-op.
+     */
+    loading?: boolean;
+    dark?: boolean;
+    /**
+     * The chosen filter, or null for "no constraint".
+     *
+     * Only the AST — the ticked labels are deliberately NOT reported. The caller
+     * used to store them and hand them back as `initialSelected`, which made the
+     * ticks a second source of truth that drifted from the filter itself (visibly,
+     * after a page reload). They are now derived from the filter via
+     * `selectedLabelsFromFilter`.
+     */
+    onApply: (filter: FilterNode | null) => void;
+    onClose: () => void;
+    /**
+     * `entries` is only the first page of a longer list.
+     *
+     * The list is capped so a million-value column does not build a million
+     * checkboxes. What was missing is saying so: a capped list looked exactly
+     * like a complete one, so a column of a million ids appeared to hold a
+     * thousand. When this is set the popup shows a notice and routes SEARCH
+     * through `onSearch` instead of filtering what it already has.
+     */
+    truncated?: boolean;
+    /**
+     * Look a needle up across the WHOLE dataset. Without it, searching a capped
+     * list can only find what was already loaded — typing an id past the cap
+     * matched nothing even though the value exists.
+     */
+    onSearch?: (needle: string) => void;
+    labels?: Partial<Record<'search' | 'selectAll' | 'clear' | 'apply' | 'cancel' | 'blank' | 'noMatch' | 'loading' | 'truncated', string>>;
+}
+declare function GridHeaderFilterPopup({ gridId, columnId, headerLabel, entries, initialSelected, anchor, loading, dark, onApply, onClose, truncated, onSearch, labels, }: GridHeaderFilterPopupProps): react.JSX.Element;
+
+interface GridContextMenuProps<TContext> {
+    x: number;
+    y: number;
+    items: GridMenuItem<TContext>[];
+    context: TContext;
+    onClose: () => void;
+    dark?: boolean;
+    /** Aria label for the menu itself. */
+    label?: string;
+}
+declare function GridContextMenu<TContext>({ x, y, items, context, onClose, dark, label, }: GridContextMenuProps<TContext>): react.JSX.Element;
+
+interface GridPortalProps {
+    children: ReactNode;
+    dark?: boolean;
+}
+declare function GridPortal({ children, dark }: GridPortalProps): react.ReactPortal | null;
+
+interface GridGroupPanelProps<TRow = GridRowData> {
+    /** Columns offered for grouping (groupable and visible). */
+    columns: ColumnRuntime<TRow>[];
+    /** Active grouping levels, outermost first. */
+    levels: readonly string[];
+    onSetLevels: (levels: string[]) => void;
+    /** Maximum number of levels the current edition allows. Default 1. */
+    maxLevels?: number;
+    onExpandAll?: () => void;
+    onCollapseAll?: () => void;
+    emptyText?: string;
+}
+declare function GridGroupPanelImpl<TRow = GridRowData>({ columns, levels, onSetLevels, maxLevels, onExpandAll, onCollapseAll, emptyText, }: GridGroupPanelProps<TRow>): react.JSX.Element;
+declare const GridGroupPanel: typeof GridGroupPanelImpl;
+
+interface GridSummaryBarProps<TRow = GridRowData> {
+    defs: readonly SummaryDef<TRow>[];
+    values: Record<string, number | null>;
+    columnModel: ColumnModel<TRow>;
+    /** Row count shown alongside the totals. */
+    rowCount?: number;
+    rowCountLabel?: string;
+}
+declare function GridSummaryBarImpl<TRow = GridRowData>({ defs, values, columnModel, rowCount, rowCountLabel, }: GridSummaryBarProps<TRow>): react.JSX.Element | null;
+declare const GridSummaryBar: typeof GridSummaryBarImpl;
+
+interface GridFooterRowProps<TRow = GridRowData> {
+    layout: ColumnLayout<TRow>;
+    centerColumns: ReactColumnRuntime<TRow>[];
+    leadingSpacer: number;
+    trailingSpacer: number;
+    /** Every definition currently active, keyed to columns by `columnId`. */
+    defs: readonly SummaryDef<TRow>[];
+    values: Record<string, number | null>;
+    checkboxColumn?: boolean;
+    detailColumn?: boolean;
+    /** Leading row-number column (gap analysis P3.5). */
+    rowNumberColumn?: boolean;
+    /** Opens the aggregation menu for a column. */
+    onPickSummary?: (columnId: string, event: React.MouseEvent) => void;
+    /** Shown in a cell with no aggregation, as the affordance for the menu. */
+    emptyHint?: string;
+    /**
+     * Which edge the totals stick to (P2.8). Bottom is the default and the
+     * spreadsheet convention; top is for a grid read top-down, where the totals
+     * are the headline and the rows are the evidence.
+     */
+    position?: 'top' | 'bottom';
+    /** Pixels of BAND rows above — only meaningful at the top. */
+    bandOffset?: number;
+    /** Header-height rows between this row and its edge. See GridPinnedRows. */
+    headerRowsBetween?: number;
+}
+declare function GridFooterRowImpl<TRow = GridRowData>({ layout, centerColumns, leadingSpacer, trailingSpacer, defs, values, checkboxColumn, detailColumn, rowNumberColumn, onPickSummary, emptyHint, position, bandOffset, headerRowsBetween, }: GridFooterRowProps<TRow>): react.JSX.Element;
+declare const GridFooterRow: typeof GridFooterRowImpl;
+
+interface GridFilterPanelProps<TRow = GridRowData> {
+    controller: DataGridController<TRow>;
+    /**
+     * Opens whatever built the filter. Omitted when the grid has no builder — a
+     * chevron that opens nothing is worse than no chevron.
+     */
+    onOpenBuilder?: () => void;
+    /**
+     * Keep the bar visible with "no filter" when nothing is filtered.
+     * Default false: an empty bar is a permanent strip of chrome explaining that
+     * nothing is happening.
+     */
+    alwaysVisible?: boolean;
+    /** Wording for the conditions themselves — `and` / `or` / `is` / `blank`… */
+    describeOptions?: DescribeFilterOptions;
+    labels?: Partial<Record<'clear' | 'toggle' | 'builder' | 'empty', string>>;
+}
+declare function GridFilterPanelImpl<TRow = GridRowData>({ controller, onOpenBuilder, alwaysVisible, describeOptions, labels, }: GridFilterPanelProps<TRow>): react.JSX.Element | null;
+declare const GridFilterPanel: typeof GridFilterPanelImpl;
+
+/** English captions, kept as the exported constant this package already had. */
+declare const SUMMARY_TYPE_LABEL: Record<SummaryType, string>;
+/** The same map in the grid's own language. */
+declare function summaryTypeLabels(t: GridDictionary): Record<SummaryType, string>;
+/**
+ * What the footer prints beside the value. A custom reducer's own `label` wins
+ * — "Custom" beside a number tells the reader nothing about what it measures.
+ *
+ * `labels` is the resolved dictionary's map; omitted, it falls back to English
+ * so the helper stays usable outside a grid (it is exported).
+ */
+declare function summaryLabel<TRow = unknown>(def: SummaryDef<TRow>, labels?: Record<SummaryType, string>): string;
+declare function formatSummaryValue<TRow>(def: SummaryDef<TRow>, value: number | null | undefined, column: GridColumnDef<TRow> | undefined): string;
+/**
+ * Aggregations that make sense for a column's data type.
+ *
+ * `sum`/`avg` over text would coerce every cell through `Number()` and total a
+ * column of names as 0 — a number that looks authoritative and means nothing.
+ * min/max stay available for dates because ordering is defined there.
+ */
+declare function allowedSummaryTypes(dataType: GridColumnDef['dataType']): readonly SummaryType[];
+
+interface GridToolbarProps<TRow = GridRowData> {
+    controller: DataGridController<TRow>;
+    search?: boolean;
+    exportCsv?: boolean;
+    exportExcel?: boolean;
+    /**
+     * Offer PDF. Off by default for the same reason Excel is: `jspdf` and
+     * `jspdf-autotable` are OPTIONAL peers, so a menu entry that is always there
+     * would fail on a grid that never installed them.
+     */
+    exportPdf?: boolean;
+    columnChooser?: boolean;
+    dark?: boolean;
+    /**
+     * Opens the field chooser anchored under the button. The panel itself is
+     * owned by the grid, because the header menu can open it in a grid that
+     * renders no toolbar.
+     */
+    onOpenColumnChooser?: (anchor: {
+        left: number;
+        top: number;
+    }) => void;
+    /**
+     * Extra controls. `before` sits ahead of the built-ins, `after` behind them —
+     * the spacer between search and the buttons keeps the two groups apart.
+     *
+     * Nodes rather than a descriptor object: a toolbar item is arbitrary UI (a
+     * date range, a saved-view picker, a refresh button wired to the app's own
+     * store), and every descriptor schema ends up chasing the next widget.
+     */
+    itemsBefore?: React.ReactNode;
+    itemsAfter?: React.ReactNode;
+    /** Milliseconds to wait after the last keystroke. Default 200. */
+    searchDebounce?: number;
+    labels?: Partial<Record<'search' | 'csv' | 'excel' | 'excelSelected' | 'pdf' | 'columns' | 'exporting' | 'exportMenu', string>>;
+}
+declare function GridToolbarImpl<TRow = GridRowData>({ controller, search, exportCsv, exportExcel, exportPdf, columnChooser, dark, onOpenColumnChooser, itemsBefore, itemsAfter, searchDebounce, labels, }: GridToolbarProps<TRow>): react.JSX.Element;
+declare const GridToolbar: typeof GridToolbarImpl;
+
+interface GridColumnChooserProps<TRow = GridRowData> {
+    controller: DataGridController<TRow>;
+    /** Passed in so the panel re-renders when visibility changes. */
+    columns: ColumnState[];
+    anchor: {
+        left: number;
+        top: number;
+    };
+    onClose: () => void;
+    dark?: boolean;
+    labels?: Partial<Record<'title' | 'empty' | 'showAll' | 'ok', string>>;
+}
+declare function GridColumnChooser<TRow = GridRowData>({ controller, columns, anchor, onClose, dark, labels, }: GridColumnChooserProps<TRow>): react.JSX.Element;
+
+interface GridLoadingOverlayProps<TRow> {
+    controller: DataGridController<TRow>;
+    /** Milliseconds of continuous work before the overlay appears. Default 300. */
+    delay?: number;
+    labels?: Partial<Record<BusyPhase | 'busy' | 'cancel', string>>;
+    /**
+     * Offer a Cancel button for phases that can actually stop. Default true.
+     *
+     * Only shown for the off-thread phases — the ones that check between chunks.
+     * A button that does nothing is worse than no button.
+     */
+    cancellable?: boolean;
+    /**
+     * Show it regardless of what the grid is doing, and without the delay
+     * (gap analysis P2.11) — `controller.showLoadingOverlay()` sets this.
+     *
+     * The delay exists to stop the overlay strobing over work that finishes in a
+     * few milliseconds. An explicit call is a decision, not a flicker to absorb,
+     * and the application making it usually has nothing else to show yet.
+     */
+    forced?: boolean;
+}
+declare function GridLoadingOverlay<TRow>({ controller, delay, labels, cancellable, forced, }: GridLoadingOverlayProps<TRow>): react.JSX.Element | null;
+
+interface GridPopupPanelProps {
+    anchor: {
+        left: number;
+        top: number;
+    };
+    onClose: () => void;
+    children: ReactNode;
+    dark?: boolean;
+    className?: string;
+    label: string;
+    role?: 'dialog' | 'menu';
+}
+declare function GridPopupPanel({ anchor, onClose, children, dark, className, label, role, }: GridPopupPanelProps): react.JSX.Element;
+
+interface GridNoteEditorProps {
+    anchor: {
+        left: number;
+        top: number;
+    };
+    /** Text already on the cell, or '' for a new note. */
+    value: string;
+    dark?: boolean;
+    /** `null` means the user cleared it — delete the note. */
+    onCommit: (text: string | null) => void;
+    onCancel: () => void;
+}
+declare function GridNoteEditor({ anchor, value, dark, onCommit, onCancel }: GridNoteEditorProps): react.JSX.Element;
+
+interface GridPagerProps {
+    page: number;
+    pageCount: number;
+    pageSize: number;
+    pageSizes?: number[];
+    /** Rows after filtering (the thing being paged through). */
+    totalRows: number;
+    /** Absolute jump (first/last). */
+    onPage: (page: number) => void;
+    /**
+     * RELATIVE moves go through their own callbacks so they read the controller's
+     * current page instead of this component's prop: two clicks landing in the
+     * same React commit would otherwise both compute `page + 1` from the same
+     * stale value and advance only one page.
+     */
+    onNext: () => void;
+    onPrevious: () => void;
+    onPageSize: (size: number) => void;
+    labels?: Partial<Record<'first' | 'previous' | 'next' | 'last' | 'page' | 'of' | 'rowsPerPage', string>>;
+}
+declare function GridPagerImpl({ page, pageCount, pageSize, pageSizes, totalRows, onPage, onNext, onPrevious, onPageSize, labels, }: GridPagerProps): react.JSX.Element;
+declare const GridPager: react.MemoExoticComponent<typeof GridPagerImpl>;
+
+/** Labels, so the menu can be localized without rebuilding the item list. */
+interface HeaderMenuLabels {
+    sortAsc: string;
+    sortDesc: string;
+    clearSort: string;
+    groupBy: string;
+    ungroup: string;
+    showGroupPanel: string;
+    hideGroupPanel: string;
+    showFooter: string;
+    hideFooter: string;
+    showGroupFooters: string;
+    hideGroupFooters: string;
+    hideColumn: string;
+    fieldChooser: string;
+    bestFit: string;
+    bestFitAll: string;
+    fixedPosition: string;
+    pinLeft: string;
+    pinRight: string;
+    pinSticky: string;
+    unpin: string;
+    moveLeft: string;
+    moveRight: string;
+}
+
+/** The menu's captions in one language. */
+declare function headerMenuLabels(t: GridDictionary): HeaderMenuLabels;
+/** English, kept as the constant this package already exported. */
+declare const DEFAULT_HEADER_MENU_LABELS: HeaderMenuLabels;
+interface HeaderMenuDeps<TRow = GridRowData> {
+    controller: DataGridController<TRow>;
+    /** Current UI switches the menu toggles operate on. */
+    groupPanelVisible: boolean;
+    footerVisible: boolean;
+    /** False in Community — per-group aggregates are Enterprise (decision #4). */
+    groupFootersAvailable: boolean;
+    groupFootersVisible: boolean;
+    onToggleGroupPanel: () => void;
+    onToggleFooter: () => void;
+    onToggleGroupFooters: () => void;
+    onOpenFieldChooser: () => void;
+    onBestFit: (columnId: string) => void;
+    onBestFitAll: () => void;
+    /** Grouping levels allowed — 1 in Community, unbounded in Enterprise. */
+    maxGroupLevels: number;
+    labels?: Partial<HeaderMenuLabels>;
+}
+declare function buildHeaderMenu<TRow = GridRowData>(context: HeaderMenuContext, deps: HeaderMenuDeps<TRow>): GridMenuItem<HeaderMenuContext>[];
+
+/**
+ * Width that fits the header and every rendered cell of `columnId`.
+ * Returns null when nothing could be measured (no such column on screen, or no
+ * canvas — jsdom, SSR), so the caller can leave the width alone.
+ */
+declare function measureBestFitWidth(root: HTMLElement, columnId: string): number | null;
+
+interface AnchoredPopupOptions {
+    /** Where the popup wants to appear, in viewport coordinates. */
+    anchor: {
+        left: number;
+        top: number;
+    };
+    /** Called on outside click, Escape, or a scroll under the popup. */
+    onClose: () => void;
+    /** Gap kept from the viewport edges. Default 8. */
+    margin?: number;
+    /** Focus the popup when it attaches. Default false. */
+    autoFocus?: boolean;
+}
+interface AnchoredPopupResult<T extends HTMLElement> {
+    /** Spread onto the popup's style. */
+    position: {
+        left: number;
+        top: number;
+    };
+    /** Attach to the popup element's `ref`. */
+    ref: (el: T | null) => void;
+    /** The live element, for callers that need it. */
+    elementRef: React.MutableRefObject<T | null>;
+}
+declare function useAnchoredPopup<T extends HTMLElement>({ anchor, onClose, margin, autoFocus, }: AnchoredPopupOptions): AnchoredPopupResult<T>;
+
+interface AlignedGridsApi {
+    /** Called from the grid's scroll handler with the PHYSICAL scrollLeft. */
+    syncScroll: (scrollLeft: number) => void;
+}
+/**
+ * Keep this grid's column layout and horizontal scroll in step with the others
+ * in `group`.
+ *
+ * A group of one is the ordinary case and costs a Map lookup: the hook
+ * registers, finds no peers, and every propagation returns immediately.
+ */
+declare function useAlignedGrids<TRow = GridRowData>(controller: DataGridController<TRow>, group: string | undefined, scrollerRef: React.RefObject<HTMLElement | null>): AlignedGridsApi;
+
+/** What the tooltip should say and where it should point. */
+interface TooltipState {
+    text: string;
+    /** Viewport rectangle of the element being described. */
+    anchor: {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+}
+interface CellTooltipOptions<TRow = GridRowData> {
+    rootRef: RefObject<HTMLElement | null>;
+    columnModel: ColumnModel<TRow>;
+    /**
+     * This cell's note (P3.3), read at hover time. A function rather than a map
+     * so the hook never holds a snapshot that the app has since edited.
+     */
+    getNote?: (rowKey: RowKey, columnId: string, row: TRow) => string | null | undefined;
+    /**
+     * Resolves a row node from the RAW `data-row-key` attribute — a string, even
+     * when the grid's keys are numbers. Coercing is the caller's job because only
+     * it knows which type the keys really are.
+     */
+    getRowNode: (rawKey: string) => DataRowNode<TRow> | undefined;
+    config?: GridTooltipConfig;
+}
+declare function useCellTooltip<TRow = GridRowData>({ rootRef, columnModel, getRowNode, getNote, config, }: CellTooltipOptions<TRow>): TooltipState | null;
+
+interface GridTooltipProps {
+    state: TooltipState;
+    dark?: boolean;
+}
+declare function GridTooltip({ state, dark }: GridTooltipProps): react.JSX.Element;
+
+interface GridPinnedRowsProps<TRow = GridRowData> {
+    gridId: string;
+    /** Which edge — decides the sticky side and the border. */
+    side: 'top' | 'bottom';
+    rows: readonly TRow[];
+    layout: ColumnLayout<TRow>;
+    columnModel: ColumnModel<TRow>;
+    centerColumns: ReactColumnRuntime<TRow>[];
+    centerIndices?: readonly number[];
+    stickyInsets?: ReadonlyMap<string, number>;
+    leadingSpacer: number;
+    trailingSpacer: number;
+    checkboxColumn?: boolean;
+    detailColumn?: boolean;
+    /** Leading row-number column (gap analysis P3.5). */
+    rowNumberColumn?: boolean;
+    rowHeight: number;
+    /** Pixels of BAND rows above. Zero on a grid without column bands. */
+    bandOffset?: number;
+    /**
+     * How many header-height rows sit between this block and its sticky edge:
+     * above, the header (1) plus the filter row when shown (2); below, the footer
+     * row (1) or nothing (0).
+     *
+     * A count rather than a pixel offset because the header's height is a THEME
+     * token — `--dg-header-height` changes with the theme and the density, and a
+     * number measured in JS at render time would be the previous theme's.
+     */
+    headerRowsBetween: number;
+    /**
+     * Rows that precede this block in the ARIA row numbering: the header rows for
+     * a top block, plus the pinned-top rows and every data row for a bottom one.
+     *
+     * A pinned row IS a row to a screen reader even though it is not one to the
+     * row model, so it has to take a number in the same sequence — and the data
+     * rows have to move down to make room. `DataGrid` does both from one count.
+     */
+    ariaRowBase: number;
+}
+declare function GridPinnedRowsImpl<TRow = GridRowData>({ gridId, side, rows, layout, columnModel, centerColumns, centerIndices, stickyInsets, leadingSpacer, trailingSpacer, checkboxColumn, detailColumn, rowNumberColumn, rowHeight, bandOffset, headerRowsBetween, ariaRowBase, }: GridPinnedRowsProps<TRow>): react.JSX.Element | null;
+declare const GridPinnedRows: typeof GridPinnedRowsImpl;
+
+type UseDataGridOptions<TRow = GridRowData> = DataGridCoreConfig<TRow>;
+interface UseDataGridResult<TRow = GridRowData> {
+    controller: DataGridController<TRow>;
+    rows: RowNode<TRow>[];
+    window: VirtualWindow;
+    layout: ColumnLayout<TRow>;
+    sort: SortDescriptor[];
+    rowHeight: number;
+    /** Rows passing filter/search. */
+    visibleCount: number;
+    /** Rows in the source data. */
+    totalCount: number;
+}
+declare function useDataGrid<TRow = GridRowData>(options: UseDataGridOptions<TRow>): UseDataGridResult<TRow>;
+
+declare function useGridChartData<TRow = GridRowData>(controller: DataGridController<TRow> | null, 
+/** Memoize this — a new reference recomputes. Null renders no chart. */
+spec: ChartSpec<TRow> | null): ChartModel | null;
+
+declare const SHORTCUT_COPY: string;
+declare const SHORTCUT_CUT: string;
+declare const SHORTCUT_PASTE: string;
+/**
+ * Write the grid's current clipboard text and publish the gesture.
+ *
+ * The single copy implementation, shared by Ctrl+C and by every Copy entry in
+ * the menu. `performed` is false when there was nothing to copy or the
+ * platform withholds the async clipboard — the bracket still closes, because a
+ * listener asked to be told about the gesture, not only about its successes.
+ */
+declare function copyToClipboard<TRow>(controller: DataGridController<TRow>, options?: {
+    includeHeaders?: boolean;
+    includeGroupHeaders?: boolean;
+}): void;
+/**
+ * Write to the system clipboard, swallowing the platform's refusal.
+ *
+ * `writeText` REJECTS when the document is not focused or permission is
+ * withheld, and an un-awaited promise then surfaces as an uncaught rejection
+ * in the console — noise that looks like a grid bug and is not one. Swallowed
+ * rather than reported because the caller has already published the gesture
+ * through `notifyClipboardGesture`, which is the hook an application uses to
+ * observe (or replace) copying.
+ */
+declare function writeClipboardText(text: string): void;
+/**
+ * Build the built-in entries for one opened menu.
+ *
+ * `needsSeparator` is the caller telling us whether anything sits above us —
+ * the divider belongs to the boundary, not to this list, so an app menu that
+ * turned out to be empty does not leave a rule floating at the top.
+ */
+declare function buildCellMenuItems<TRow = GridRowData>(controller: DataGridController<TRow>, text: GridDictionary, option: boolean | CellMenuOptions | undefined, needsSeparator: boolean, onExportError?: (message: string) => void): GridMenuItem<RowMenuContext<TRow>>[];
+
+interface GridSurfaceProviderProps {
+    theme?: GridTheme;
+    density?: GridDensity;
+    palette?: GridPalette;
+    children: ReactNode;
+}
+declare function GridSurfaceProvider({ theme, density, palette, children, }: GridSurfaceProviderProps): react.JSX.Element;
+/**
+ * The theme + density modifier classes for a surface rendered outside the grid.
+ * `''` when the grid is unthemed, so appending it is always safe.
+ */
+declare function useGridSurfaceClass(): string;
+
+interface GridTextProviderProps {
+    locale?: string;
+    messages?: Partial<GridDictionary>;
+    children: ReactNode;
+}
+declare function GridTextProvider({ locale, messages, children }: GridTextProviderProps): react.JSX.Element;
+/** The resolved dictionary. Stable between language changes. */
+declare function useGridText(): GridDictionary;
+/**
+ * Substitute `{name}` placeholders.
+ *
+ * Deliberately not a template engine: the dictionary's placeholders are a fixed
+ * contract checked by `locales.test.ts`, so anything cleverer would be a
+ * feature nobody asked for on a hot path.
+ */
+declare function fillText(template: string, values: Record<string, string | number>): string;
+
+export { type AlignedGridsApi, BAND_ROW_HEIGHT, type CellMenuOptions, type CellRenderContext, type CellSlotContext, type CellTooltipOptions, DEFAULT_HEADER_MENU_LABELS, DENSITY_ROW_HEIGHT, DataGrid, type DataGridProps, type DistinctEntry, type EditorRenderContext, type ExportOutcome, GRID_PALETTES, GRID_THEMES, GridColumnChooser, type GridColumnChooserProps, GridContextMenu, type GridContextMenuProps, type GridDensity, GridFilterPanel, type GridFilterPanelProps, GridFilterRow, type GridFilterRowProps, GridFooterRow, type GridFooterRowProps, GridGroupPanel, type GridGroupPanelProps, GridHeader, GridHeaderBands, type GridHeaderBandsProps, GridHeaderFilterPopup, type GridHeaderFilterPopupProps, type GridHeaderProps, GridLoadingOverlay, type GridLoadingOverlayProps, type GridMenuItem, GridNoteEditor, type GridNotesConfig, GridPager, type GridPagerProps, type GridPalette, GridPinnedRows, type GridPinnedRowsProps, GridPopupPanel, type GridPopupPanelProps, GridPortal, type GridPortalProps, GridRow, type GridRowProps, GridSummaryBar, type GridSummaryBarProps, GridSurfaceProvider, type GridSurfaceProviderProps, GridTextProvider, type GridTextProviderProps, type GridTheme, GridToolbar, type GridToolbarProps, GridTooltip, type GridTooltipConfig, type GridTooltipProps, type HeaderMenuContext, type HeaderMenuDeps, type HeaderMenuLabels, type HeaderRenderContext, type NoteCellContext, PRINT_MAX_ROWS, type PrintLayoutOptions, type PrintLayoutState, ROW_DRAG_MIME, type ReactColumnRuntime, type ReactGridColumnDef, type RowDragConfig, type RowDragHandlers, type RowDragPayload, type RowDropEvent, type RowMenuContext, type RowReorderEvent, type RowTemplateContext, SHORTCUT_COPY, SHORTCUT_CUT, SHORTCUT_PASTE, SUMMARY_TYPE_LABEL, THEME_ROW_HEIGHT, type TooltipState, type UseDataGridOptions, type UseDataGridResult, allowedSummaryTypes, buildCellMenuItems, buildHeaderMenu, copyToClipboard, fillText, filterInputFromNode, formatSummaryValue, headerMenuLabels, measureBestFitWidth, parseFilterInput, reconcileFilterInputs, runGridExport, summaryLabel, summaryTypeLabels, themeClassName, useAlignedGrids, useAnchoredPopup, useCellTooltip, useDataGrid, useGridChartData, useGridSurfaceClass, useGridText, usePrintLayout, useRowDrag, useStateStoring, writeClipboardText };