@gridkitjs/react 0.0.0-dev-20261106222533

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Blagoja Blazhevski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# @gridkitjs/react
+
+React data-grid components built on
+[`@gridkitjs/core`](https://www.npmjs.com/package/@gridkitjs/core) for the
+grid's logic and [`@gridkitjs/dom`](https://www.npmjs.com/package/@gridkitjs/dom)
+for its browser behaviours. Both are installed with it.
+
+> **Early development.** The API is still moving and may break between minor
+> versions.
+
+```bash
+pnpm add @gridkitjs/react
+```
+
+```tsx
+import { defineColumnsFromRows } from "@gridkitjs/core";
+import { DataGrid, type ColumnDefinition } from "@gridkitjs/react";
+
+const rows = [
+  { Id: 1, Application: { Id: 9, Name: "Portal" }, Cost: 1250.5 },
+  { Id: 2, Application: { Id: 4, Name: "Admin" }, Cost: 87.25 },
+];
+
+type Row = (typeof rows)[number];
+
+const columns: readonly ColumnDefinition<Row>[] = [
+  ...defineColumnsFromRows(rows),
+  {
+    field: "Cost",
+    id: "Cost.currency",
+    type: "currency",
+    header: "Cost",
+  },
+];
+
+<DataGrid
+  dataSource={rows}
+  columns={columns}
+  getRowId={(row) => String(row.Id)}
+  label="Application costs"
+  resizableColumns
+  resizeMode="fit"
+  selectable={{ rows: "multiple", cells: "single" }}
+  onRowSelectionChange={({ selected }) => persist(selected)}
+/>;
+```
+
+Columns can be inferred from the data or declared outright — a column's `type`
+drives its default alignment. With `resizableColumns`, a column edge can be
+dragged to resize or double-clicked to fit its content. `resizeMode="fit"`
+keeps columns filling the grid; `"fixed"` lets each keep its own width.
+
+`selectable` says which parts of the grid the user may select and how many of
+each — `false`, `"single"` or `"multiple"` per member, off by default. Click
+replaces, Ctrl-click toggles, Shift-click takes a range, and thirteen callbacks
+report it with the resolved row, column or cell value rather than a bare id.
+Give `getRowId` alongside it for data that sorts, filters or pages.
+
+The grid is an ARIA grid: one tab stop, with the arrow keys moving cell to cell
+within it, `Ctrl+Arrow` reordering a column and `Alt+Arrow` resizing one. Name
+it with `label`, or a screen reader announces only "grid".
+
+`contextMenu` gives headers, cells and group rows a menu of their own — sort,
+group, autofit, hide and choose columns, select and clear, expand and collapse
+— and `toolbar` puts a toolbar above the grid, with a search box, "Clear
+filters" and "Choose columns" by default. Both list built-in commands by id,
+and `commands` adds your own beside them; the column chooser shows and hides
+columns from either. `messages` translates every string the grid shows or
+announces, and `locale` formats dates and numbers.
+
+Requires React 19.
+
+Full documentation: [github.com/gridkitjs/gridkitjs](https://github.com/gridkitjs/gridkitjs#readme)
+
+## License
+
+MIT © Blagoja Blazhevski

package/dist/index.d.ts

@@ -0,0 +1,495 @@
+import * as react from 'react';
+import { ReactNode, Ref, RefObject } from 'react';
+import { ExportWriter, GridExportOptions, PrintOptions, CellSelectEvent as CellSelectEvent$1, CellSelectionChangeEvent as CellSelectionChangeEvent$1, ColumnDefinition as ColumnDefinition$1, ColumnSelectEvent as ColumnSelectEvent$1, ColumnSelectionChangeEvent as ColumnSelectionChangeEvent$1, ColumnsSelectEvent as ColumnsSelectEvent$1, DataColumn as DataColumn$1, GridOptions, PaginationState, SelectionCallbacks as SelectionCallbacks$1, ResolvedRow, DisplayRow, ResolvedColumn as ResolvedColumn$1, ColumnSizingState, ColumnOrderState, ColumnVisibilityState, ColumnSortState, FilterState, GroupByState, GroupExpansionState, AggregateResults, SelectionState, CellSelectionState, GridState, SerializedGridState, GridContextMenuTarget, GridCommandTarget, SelectedCell as SelectedCell$1, SelectedColumn as SelectedColumn$1 } from '@gridkitjs/core';
+export { Borders, CellSelectionMode, CellSelectionState, CellTemplateContext, ColumnResizeEvent, ColumnSizeDefaults, ColumnSizingState, ColumnVisibilityEvent, ColumnVisibilityState, ContextMenuOpenChangeEvent, ExportFile, ExportOptions, ExportWriter, FilterChangeEvent, FilterEntry, FilterState, GridCommand, GridCommandEvent, GridCommandTarget, GridContextMenuOptions, GridContextMenuRequest, GridContextMenuTarget, GridExportOptions, GridMessages, GridOptions, GridState, GridToolbarOptions, GroupByBarVisibility, HoverableConfig, MenuEntry, PrintOptions, ResizeMode, ResolvedRow, RowPointerEvent, RowProps, RowSelectEvent, RowSelectionChangeEvent, RowsSelectEvent, SelectableConfig, SelectedCellRef, SelectionMode, SelectionState, SerializedGridState, ToolbarEntry, excelFilter, serializeGridState } from '@gridkitjs/core';
+
+/** What `DataGridApi` carries for exporting. */
+interface GridExportApi {
+    /**
+     * The grid's view exported as `format` — `"csv"`, `"json"`, a format
+     * registered through `exportWriters`, or a writer passed as it is — and
+     * handed back as a `Blob`, under the grid's `export` option with
+     * `options` over it, field by field. Nothing is downloaded:
+     * `runCommand("export.csv")` downloads.
+     *
+     * Rejects for a format no writer is registered for, and when the writer
+     * fails.
+     */
+    exportData(format: string | ExportWriter, options?: GridExportOptions): Promise<Blob>;
+}
+
+/** What `DataGridApi` carries for the grid's panels. */
+interface GridPanelApi {
+    /**
+     * Opens the column chooser at the grid's top-end corner, in place of any
+     * panel open; it gives focus back to what had it when it closes.
+     */
+    openColumnChooser(): void;
+    /**
+     * Opens the filter menu of the column `columnId` below its header, in
+     * place of any panel open, and says whether it opened: not for a column
+     * with no filter menu, nor one not shown. It gives focus back to the
+     * header when it closes.
+     */
+    openFilterMenu(columnId: string): boolean;
+    /** Closes the filter menu, if one is open, leaving any other panel open. */
+    closeFilterMenu(): void;
+}
+
+/** What `DataGridApi` carries for printing. */
+interface GridPrintApi {
+    /**
+     * Prints the grid's view through the browser's print dialog — every row
+     * the filter leaves, across pages and collapsed groups, not only those
+     * drawn — under the grid's `print` option with `options` over it, field
+     * by field. Resolves once the dialog has closed, or at once while another
+     * print is open.
+     */
+    print(options?: PrintOptions): Promise<void>;
+}
+
+/**
+ * A column whose header and cells may render arbitrary React content.
+ * @gridkitjs/core stays framework-agnostic and so leaves that output type open;
+ * this is the binding React consumers want, and the one they should import.
+ */
+type ColumnDefinition<Row> = ColumnDefinition$1<Row, ReactNode>;
+/** A column paired with the width it renders at. */
+type ResolvedColumn<Row> = ResolvedColumn$1<Row, ReactNode>;
+/** A column paired with its id, hidden or not — what `getDataColumns()` lists. */
+type DataColumn<Row> = DataColumn$1<Row, ReactNode>;
+/**
+ * The selection payloads, bound to React's node type for the same reason
+ * `ColumnDefinition` is: they carry a resolved column, whose label is whatever
+ * a `headerTemplate` returned.
+ *
+ * The row payloads name no node type at all and so are re-exported from
+ * `@gridkitjs/core` as they are.
+ */
+type SelectedColumn<Row> = SelectedColumn$1<Row, ReactNode>;
+type SelectedCell<Row> = SelectedCell$1<Row, ReactNode>;
+type ColumnSelectEvent<Row> = ColumnSelectEvent$1<Row, ReactNode>;
+type ColumnsSelectEvent<Row> = ColumnsSelectEvent$1<Row, ReactNode>;
+type ColumnSelectionChangeEvent<Row> = ColumnSelectionChangeEvent$1<Row, ReactNode>;
+type CellSelectEvent<Row> = CellSelectEvent$1<Row, ReactNode>;
+type CellSelectionChangeEvent<Row> = CellSelectionChangeEvent$1<Row, ReactNode>;
+type SelectionCallbacks<Row> = SelectionCallbacks$1<Row, ReactNode>;
+/**
+ * Imperative handle for a mounted `DataGrid`, reached via its `ref` prop:
+ * the grid's DOM nodes, getters for its live state, the actions every grid
+ * ref carries (focus, select all, scroll-to), and a setter for every slice of
+ * state, for a toolbar, a saved layout or a test to drive it from outside.
+ *
+ * Every getter reads the grid's state at call time, so a read straight after
+ * an action sees its result. Every setter changes the grid as the user's own
+ * interaction would: it fires the slice's `on*Change` callback, and, for a
+ * slice held through a controlled prop, only asks. `subscribe` is the
+ * notify channel for state that changes; see
+ * `packages/react/src/DataGrid/hooks/` for the public hooks built on it.
+ */
+interface DataGridApi<Row> extends GridExportApi, GridPrintApi, GridPanelApi {
+    /** The grid's scrollable viewport element. */
+    readonly element: HTMLDivElement | null;
+    /**
+     * The grid's row-area `<table>` element — the one holding `<tbody>`. The
+     * header and, when aggregates are active, footer render as their own
+     * sibling `<table>`s outside this one; use `element` to reach the whole
+     * scrollable viewport instead.
+     */
+    readonly table: HTMLTableElement | null;
+    /** Rows as currently filtered and sorted — what's rendered, ungrouped. */
+    getRows(): readonly ResolvedRow<Row>[];
+    /**
+     * `getRows()` regrouped into the active `groupBy` — group headers
+     * interleaved with data rows, in render order. Identical to `getRows()`
+     * when `groupBy` is empty.
+     */
+    getDisplayRows(): readonly DisplayRow<Row>[];
+    /**
+     * The current page of `getDisplayRows()` — exactly the rows the body
+     * renders. All of `getDisplayRows()` when `paginated` is off.
+     */
+    getPageRows(): readonly DisplayRow<Row>[];
+    /** Columns as currently sized and ordered — what's rendered, so hidden columns are left out. */
+    getColumns(): readonly ResolvedColumn<Row>[];
+    /** Every column in its current order, hidden ones included — what sorting, filtering and grouping read. */
+    getDataColumns(): readonly DataColumn<Row>[];
+    getColumnSizing(): ColumnSizingState;
+    getColumnOrder(): ColumnOrderState;
+    /** Columns shown or hidden since the grid mounted. A column absent from it follows its definition's `hidden`. */
+    getColumnVisibility(): ColumnVisibilityState;
+    getColumnSort(): ColumnSortState;
+    /** The filter the rows are shown through — every entry, ANDed together. */
+    getFilter(): FilterState<Row>;
+    getGroupBy(): GroupByState;
+    getGroupExpansion(): GroupExpansionState;
+    /** The active page and page size. Meaningful even when `paginated` is off — it stays at page 0 over the grid's whole (single) page. */
+    getPagination(): PaginationState;
+    /** How many pages the current `pagination.pageSize` splits the grid's rows into — `1` whenever `paginated` is off. */
+    getPageCount(): number;
+    /**
+     * The grand-total aggregate results — every active aggregate computed over
+     * the whole filtered/sorted dataset, ungrouped and unpaginated. A specific
+     * group's own results are read off `getDisplayRows()` instead, on that
+     * group header's `aggregates` field.
+     */
+    getAggregates(): AggregateResults;
+    getRowSelection(): SelectionState;
+    /**
+     * The selected rows themselves, in the order they were selected — among
+     * every row the filter lets through, on any page or in any group, so a row
+     * filtered out while selected is left out until it is back.
+     */
+    getSelectedRows(): readonly ResolvedRow<Row>[];
+    getColumnSelection(): SelectionState;
+    getCellSelection(): CellSelectionState;
+    /** The cell currently holding the grid's single tab stop. */
+    getFocusedCell(): {
+        rowIndex: number;
+        columnIndex: number;
+    };
+    /**
+     * Every slice of state as the grid applies it, in one object — what
+     * `restoreState` takes back. Pass it through `serializeGridState` before
+     * saving it as JSON.
+     */
+    getState(): GridState<Row>;
+    /**
+     * Puts back state saved earlier, whole or in part — from `getState()`, or
+     * from `serializeGridState` and back through JSON. Each slice given is set
+     * as its setter would set it, firing its callback when it changes; the
+     * grid re-renders once.
+     */
+    restoreState(saved: Partial<GridState<Row>> | Partial<SerializedGridState<Row>>): void;
+    focusCell(rowIndex: number, columnIndex: number): void;
+    clearSelection(): void;
+    selectAllRows(): void;
+    /**
+     * Selects rows by id, as far as `selectable.rows` allows: `"replace"` (the
+     * default) selects exactly these — only the last of them under
+     * `"single"` — and `"toggle"` flips each one. Fires the row selection
+     * callbacks once for the whole call, and none when nothing changed.
+     */
+    selectRows(rowIds: readonly string[], intent?: "replace" | "toggle"): void;
+    /** Expands every group at once, as the `group.expandAll` command does. */
+    expandAllGroups(): void;
+    /** Collapses every group currently shown at once — see `collapseAllGroups` in `@gridkitjs/core` for what "currently shown" means for a group already nested under a collapsed one. */
+    collapseAllGroups(): void;
+    /** Moves to the given page, clamped into range. */
+    goToPage(pageIndex: number): void;
+    /** Moves to the next page. A no-op on the last page. */
+    nextPage(): void;
+    /** Moves to the previous page. A no-op on the first page. */
+    previousPage(): void;
+    /** Changes the page size, resetting to the first page. */
+    setPageSize(pageSize: number): void;
+    /**
+     * Shows the columns with the given ids, each in the place it held when
+     * hidden. Reports one `onColumnVisibilityChange` for the whole call, and
+     * none if every column was already showing.
+     */
+    showColumns(columnIds: readonly string[]): void;
+    /**
+     * Hides the columns with the given ids. A hidden column still sorts,
+     * filters and groups, and keeps its place in the column order.
+     */
+    hideColumns(columnIds: readonly string[]): void;
+    /**
+     * Replaces the filter, the way a filter UI would, and sends an uncontrolled
+     * grid back to its first page. Reports one `onFilterChange`, and none when
+     * `filter` is equal to the current one. With a controlled `filter` prop it
+     * only asks, as any change does.
+     */
+    setFilter(filter: FilterState<Row>): void;
+    /**
+     * Replaces the sort. Reports one `onColumnSortChange`, naming the first
+     * column whose place or direction changed, and none for an equal sort —
+     * the rule every setter below follows for its own slice and callback.
+     */
+    setColumnSort(sort: ColumnSortState): void;
+    /** Replaces the group-by stack. Reports through `onGroupByChange`. */
+    setGroupBy(groupBy: GroupByState): void;
+    /** Replaces the collapsed groups. Reports through `onGroupExpansionChange` with `groupId: null`. */
+    setGroupExpansion(expansion: GroupExpansionState): void;
+    /** Replaces the page and page size as given. Reports through `onPaginationChange`. */
+    setPagination(pagination: PaginationState): void;
+    /** Replaces the column widths. Reports through `onColumnResize`, as the `"end"` of a resize. */
+    setColumnSizing(sizing: ColumnSizingState): void;
+    /** Replaces the column order. Reports through `onColumnOrderChange`. */
+    setColumnOrder(order: ColumnOrderState): void;
+    /** Replaces the column visibility state. Reports through `onColumnVisibilityChange`. */
+    setColumnVisibility(visibility: ColumnVisibilityState): void;
+    /** Replaces the selected row ids as given, whatever `selectable` allows. Fires the row selection callbacks. */
+    setRowSelection(selection: SelectionState): void;
+    /** Replaces the selected column ids as given. Fires the column selection callbacks. */
+    setColumnSelection(selection: SelectionState): void;
+    /** Replaces the selected cell as given, `null` for none. Fires the cell selection callbacks. */
+    setCellSelection(selection: CellSelectionState): void;
+    /**
+     * Sizes a shown column to fit its content, as double-clicking its resize
+     * handle does, reporting through `onColumnResize`. A hidden column, or one
+     * with no rows to measure, is left as it is.
+     */
+    autoFitColumn(columnId: string): void;
+    /**
+     * `autoFitColumn` for each of the given columns, or for every column shown
+     * when given none.
+     */
+    autoFitColumns(columnIds?: readonly string[]): void;
+    /**
+     * Opens the context menu `target` has, as a right-click there would —
+     * selecting it and focusing its cell first — beside `anchor`, a point in
+     * viewport coordinates or an element, or else below its cell. Says whether
+     * it opened: not for a target not on screen, nor where `contextMenu`
+     * gives no menu.
+     */
+    openContextMenu(target: GridContextMenuTarget, anchor?: {
+        readonly x: number;
+        readonly y: number;
+    } | Element): boolean;
+    /** Closes the context menu, if one is open. */
+    closeContextMenu(): void;
+    /**
+     * Runs a command by id — a built-in or one of `commands` — on `target`,
+     * `{ area: "grid" }` when left out, when it is visible and enabled there.
+     * Reports it through `onCommand` with `source: "api"`, and says whether it
+     * ran.
+     */
+    runCommand(commandId: string, target?: GridCommandTarget): boolean;
+    /** Scrolls the row with the given id into view, if it is currently shown. */
+    scrollToRow(rowId: string, options?: ScrollIntoViewOptions): void;
+    /** Scrolls the column with the given id into view. */
+    scrollToColumn(columnId: string, options?: ScrollIntoViewOptions): void;
+    /**
+     * Registers `listener` to be called after any render in which the grid's
+     * internal state may have changed — every getter above may return a
+     * different value once `listener` fires, not just one. Returns an
+     * unsubscribe function. The primitive the `use*State` hooks under
+     * `packages/react/src/DataGrid/hooks/` build on; most consumers should
+     * reach for one of those instead of calling `subscribe` directly.
+     */
+    subscribe(listener: () => void): () => void;
+}
+
+/**
+ * Everything a `pager.template` render prop needs to rebuild the built-in
+ * pager's UI itself. Passed fresh on every render where pagination-relevant
+ * state changed, so it's current by construction — unlike `DataGridApi`'s
+ * imperative methods and snapshot getters, which carry no "something
+ * changed, re-render" signal of their own.
+ */
+interface PagerTemplateContext {
+    /** Same shape as `DataGridApi.getPagination()` — 0-based `pageIndex`. */
+    pagination: PaginationState;
+    /** `pagination.pageIndex + 1`, clamped — the display-ready page number. */
+    currentPage: number;
+    pageCount: number;
+    /** Passthrough of `pager.sizeOptions`, undefined when not given. */
+    pageSizeOptions: readonly number[] | undefined;
+    /** 0-based, same as `DataGridApi.goToPage` — not `currentPage`'s numbering. */
+    goToPage: (pageIndex: number) => void;
+    nextPage: () => void;
+    previousPage: () => void;
+    setPageSize: (pageSize: number) => void;
+}
+/** Presentation options for the grid's built-in pager. */
+interface PagerConfig {
+    /** Page sizes offered by the built-in pager's page-size control. */
+    sizeOptions?: readonly number[] | undefined;
+    /** Defaults to `"compact"` — today's Prev/status/Next. */
+    variant?: "compact" | "numbered" | undefined;
+    /** Numbered variant only. How many pages to always show at each end. Defaults to 1. */
+    boundaryCount?: number | undefined;
+    /** Numbered variant only. How many pages to show on each side of the current page. Defaults to 1. */
+    siblingCount?: number | undefined;
+    /** Replaces the built-in pager entirely when given. `variant` is ignored. */
+    template?: ((context: PagerTemplateContext) => ReactNode) | undefined;
+}
+/**
+ * Loads more rows as the user scrolls near the bottom, in place of paging.
+ * Appends only — there is no equivalent of `paginated`'s reset-to-page-0 for
+ * a result set that shrinks out from under the current position.
+ */
+interface InfiniteScrollConfig {
+    /** Whether a further `onLoadMore` could still return more rows. `false` removes the sentinel entirely, so no further scrolling can trigger a load. */
+    readonly hasMore: boolean;
+    /**
+     * Called at most once per genuine threshold-crossing: fires when the
+     * sentinel comes within `rootMargin` of the body's viewport, and not again
+     * until `isLoadingMore` has gone back to `false`.
+     */
+    readonly onLoadMore: () => void;
+    /** Whether a load triggered by `onLoadMore` is still in flight. Suppresses further calls to it until this goes back to `false`. */
+    readonly isLoadingMore?: boolean | undefined;
+    /**
+     * How far from the bottom of the scrollable body `onLoadMore` fires, ahead
+     * of the sentinel actually scrolling into view, as CSS margins — an
+     * intersection observer's `rootMargin`. Defaults to `"200px"`.
+     */
+    readonly rootMargin?: string | undefined;
+    /** Replaces the built-in "Loading more…" row (`messages.loadingMore`). */
+    readonly loadingTemplate?: (() => ReactNode) | undefined;
+}
+/**
+ * The props that name a React type, and so have no place in the
+ * framework-free `GridOptions`: columns whose templates return `ReactNode`,
+ * the pager and infinite-scroll configs whose templates do too, and the
+ * toolbar's custom entries.
+ */
+interface ReactRenderSlots<Row> {
+    columns?: readonly ColumnDefinition<Row>[] | undefined;
+    /** Presentation options for the built-in pager. */
+    pager?: PagerConfig | undefined;
+    /**
+     * Loads more rows as the user scrolls near the bottom, instead of paging.
+     * Mutually exclusive with `paginated` — setting both logs a dev-time
+     * `console.error` and only `paginated` takes effect. Recommended (not
+     * required) alongside `virtualized` for a dataset that grows without
+     * bound, so the mounted row count never grows with it either.
+     */
+    infiniteScroll?: InfiniteScrollConfig | undefined;
+    /** Draws the toolbar's custom entries — `{ type: "custom", id }` — by id. */
+    renderToolbarItem?: ((id: string) => ReactNode) | undefined;
+}
+/**
+ * Every grid setting in `@gridkitjs/core`'s `GridOptions`, plus what only
+ * React can express: render slots, selection callbacks carrying React-bound
+ * columns, and the `ref`.
+ */
+interface DataGridProps<Row> extends GridOptions<Row>, ReactRenderSlots<Row>, SelectionCallbacks<Row> {
+    /** Imperative handle for reading live grid state and triggering actions. */
+    ref?: Ref<DataGridApi<Row>> | undefined;
+}
+declare function DataGrid<Row>(props: DataGridProps<Row>): react.JSX.Element;
+
+interface PaginationStateApi {
+    pagination: PaginationState;
+    pageCount: number;
+    goToPage: (pageIndex: number) => void;
+    nextPage: () => void;
+    previousPage: () => void;
+    setPageSize: (pageSize: number) => void;
+}
+/**
+ * Reactive pagination state read off a mounted `DataGrid`'s `ref`,
+ * for building a pager entirely outside the grid's own DOM — a toolbar or
+ * sidebar `pager.template` can't reach. Updates on every pagination change,
+ * including the silent page-0 reset a filter/sort/group change triggers,
+ * which carries no `onPaginationChange` of its own.
+ *
+ * Before the grid mounts, `pagination` reads `{ pageIndex: 0, pageSize: 0 }`
+ * and `pageCount` reads `0`; the actions are no-ops until then.
+ */
+declare function usePaginationState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): PaginationStateApi;
+
+interface GroupByStateApi {
+    groupBy: GroupByState;
+    groupExpansion: GroupExpansionState;
+    expandAllGroups: () => void;
+    collapseAllGroups: () => void;
+}
+/**
+ * Reactive group-by and group-expansion state read off a mounted
+ * `DataGrid`'s `ref`, for a group-by bar or summary sidebar living
+ * outside the grid's own DOM.
+ *
+ * The ref's `setGroupBy` and `setGroupExpansion` change the grouping and the
+ * collapsed groups for a custom group-by UI; this hook carries only the
+ * all-at-once expansion actions. A specific
+ * group's own computed aggregates are read off `getDisplayRows()`'s
+ * per-header `aggregates` field instead of a getter here — see
+ * `useAggregateState` for the grand-total equivalent.
+ *
+ * Before the grid mounts, both fields read as empty and the actions are
+ * no-ops.
+ */
+declare function useGroupByState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): GroupByStateApi;
+
+/**
+ * Reactive column-sort state read off a mounted `DataGrid`'s `ref`,
+ * for a sort indicator living outside the grid's own DOM.
+ *
+ * Reads only; change the sort through the ref's `setColumnSort`, or hold it
+ * yourself with the controlled `columnSort` prop.
+ *
+ * Before the grid mounts, reads as an empty array.
+ */
+declare function useColumnSortState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): ColumnSortState;
+
+interface SelectionStateApi {
+    rowSelection: SelectionState;
+    columnSelection: SelectionState;
+    cellSelection: CellSelectionState;
+    clearSelection: () => void;
+    selectAllRows: () => void;
+}
+/**
+ * Reactive row/column/cell selection state read off a mounted
+ * `DataGrid`'s `ref`, for a "N rows selected" toolbar living
+ * outside the grid's own DOM. One combined hook rather than three, matching
+ * how `useGridSelection` already treats all three as one concern
+ * internally.
+ *
+ * Before the grid mounts, the row/column fields read as empty arrays and
+ * the cell field reads `null`; the actions are no-ops.
+ */
+declare function useSelectionState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): SelectionStateApi;
+
+/**
+ * Reactive grand-total aggregate results read off a mounted
+ * `DataGrid`'s `ref`, for a summary footer or bar living outside
+ * the grid's own DOM — mirroring the built-in one the grid renders itself.
+ *
+ * Read-only: `getAggregates` is already read-only on `DataGridApi`, computed
+ * over the whole filtered/sorted dataset rather than driven by any action.
+ * A specific group's own subtotal is read off `getDisplayRows()`'s
+ * per-header `aggregates` field instead — see `useGroupByState`.
+ *
+ * Before the grid mounts, reads as an empty map.
+ */
+declare function useAggregateState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): AggregateResults;
+
+/**
+ * Reactive column-sizing state read off a mounted `DataGrid`'s
+ * `ref`. Reads only; change the widths through the ref's `setColumnSizing`,
+ * or hold them yourself with the controlled `columnSizing` prop.
+ *
+ * Before the grid mounts, reads as an empty object.
+ */
+declare function useColumnSizingState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): ColumnSizingState;
+
+/**
+ * Reactive column-order state read off a mounted `DataGrid`'s
+ * `ref`. Reads only; change the order through the ref's `setColumnOrder`,
+ * or hold it yourself with the controlled `columnOrder` prop.
+ *
+ * Before the grid mounts, reads as an empty array.
+ */
+declare function useColumnOrderState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): ColumnOrderState;
+
+/**
+ * Reactive column-visibility state read off a mounted `DataGrid`'s `ref` —
+ * the columns shown or hidden since it mounted, keyed by id. Read-only:
+ * change it through the ref's `showColumns`/`hideColumns`. A column absent
+ * from it follows its definition's `hidden`.
+ *
+ * Before the grid mounts, reads as an empty object.
+ */
+declare function useColumnVisibilityState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): ColumnVisibilityState;
+
+interface FilterStateApi<Row> {
+    filter: FilterState<Row>;
+    setFilter: (filter: FilterState<Row>) => void;
+}
+/**
+ * Reactive filter state read off a mounted `DataGrid`'s `ref`, for a filter
+ * bar or search box living outside the grid's own DOM, which sees every change
+ * however it was made — the toolbar's search box included. `setFilter`
+ * replaces the whole filter and sends the grid back to its first page.
+ *
+ * Before the grid mounts, `filter` reads as an empty array and `setFilter`
+ * is a no-op.
+ */
+declare function useFilterState<Row>(gridRef: RefObject<DataGridApi<Row> | null>): FilterStateApi<Row>;
+
+export { type CellSelectEvent, type CellSelectionChangeEvent, type ColumnDefinition, type ColumnSelectEvent, type ColumnSelectionChangeEvent, type ColumnsSelectEvent, type DataColumn, DataGrid, type DataGridApi, type DataGridProps, type FilterStateApi, type GroupByStateApi, type InfiniteScrollConfig, type PagerConfig, type PagerTemplateContext, type PaginationStateApi, type ReactRenderSlots, type ResolvedColumn, type SelectedCell, type SelectedColumn, type SelectionStateApi, useAggregateState, useColumnOrderState, useColumnSizingState, useColumnSortState, useColumnVisibilityState, useFilterState, useGroupByState, usePaginationState, useSelectionState };