@gridkitjs/core 0.7.0 → 0.9.0

package/dist/index.d.ts

@@ -35,16 +35,27 @@ interface CellTemplateContext<Row> {
     value: unknown;
     /** The whole row, for a template that needs a sibling field. */
     row: Row;
-    /**
-     * Position among the rows as rendered. Once paging exists this is the index
-     * within the page; an index into the whole dataset would be a second field.
-     */
+    /** Position among the rows as rendered — the index within the current page once paging is on. */
     rowIndex: number;
+    /** This row's absolute position in the whole filtered/sorted/grouped dataset, unaffected by which page is showing. */
+    datasetIndex: number;
     /** This row's id, as `resolveRowId` settled it. */
     rowId: string;
     /** Whether this row is selected, so a template can style itself to match. */
     selected: boolean;
 }
+/**
+ * What a column's `footerTemplate` receives. Mirrors `CellTemplateContext`'s
+ * shape where it applies — `value`, `rows` — minus everything scoped to one
+ * rendered row (`rowIndex`, `rowId`, `selected`), since a footer addresses
+ * every row an aggregate was computed over at once, not a single one.
+ */
+interface FooterTemplateContext<Row> {
+    /** This column's aggregate result, as `computeAggregates` produced it. */
+    value: unknown;
+    /** Every row the aggregate was computed over — the grand total's full dataset, or one group's full leaf descendants. */
+    rows: readonly Row[];
+}
 /**
  * @typeParam Node - What a header or cell renders to. This package is
  * framework-agnostic so it defaults to `string`; `@gridkitjs/react` binds it to
@@ -71,6 +82,13 @@ interface ColumnDefinition<Row, Node = string> {
      * it never repeats the field path.
      */
     cellTemplate?: ((context: CellTemplateContext<Row>) => Node) | undefined;
+    /**
+     * Renders this column's own aggregate result in a group footer or the
+     * grand-total footer, in place of the raw computed value. Absent for a
+     * column with no aggregate: nothing is shown, the same way a column
+     * missing from `AggregateState` contributes no cell to either footer.
+     */
+    footerTemplate?: ((context: FooterTemplateContext<Row>) => Node) | undefined;
     /**
      * The value type of this column's cells. This package is framework-agnostic so it
      * defaults to `string`;
@@ -99,6 +117,24 @@ interface ColumnDefinition<Row, Node = string> {
     reorderable?: boolean;
     /** Whether this column can be sorted, overriding the grid-level default. */
     sortable?: boolean;
+    /** Whether this column can be grouped by, overriding the grid-level default. */
+    groupable?: boolean;
+    /**
+     * Whether this column's header shows its group-toggle icon, overriding
+     * the grid-level default. Purely a rendering choice — it does not affect
+     * whether the column can be grouped by (`groupable`) or the
+     * `Alt+ArrowDown` shortcut, which keeps working with the icon hidden, the
+     * same way the resize handle stays `aria-hidden` while `Alt+ArrowLeft`/
+     * `ArrowRight` still resize.
+     */
+    groupToggleIcon?: boolean;
+    /**
+     * Whether this column's header may be dragged into the group-by bar to
+     * add it to the active grouping, overriding the grid-level default.
+     * Distinct from `groupable`: a column can be groupable via its header's
+     * click/`Alt+ArrowDown` toggle, via this drag, both, or neither.
+     */
+    groupByDraggable?: boolean;
     /**
      * Lets this column's header and/or cell text wrap onto multiple lines
      * instead of the grid's default single line with an ellipsis. Off by
@@ -132,6 +168,16 @@ interface ColumnWrapConfig {
  * still takes effect, and resetting is discarding the state.
  */
 type ColumnSizingState = Readonly<Record<string, number>>;
+/** The active page, and how many rows/units make one up. */
+interface PaginationState {
+    readonly pageIndex: number;
+    readonly pageSize: number;
+}
+/** Reports a user page/page-size change whole — the one to persist from, mirroring ColumnSortEvent. */
+interface PaginationChangeEvent {
+    readonly pagination: PaginationState;
+    readonly pageCount: number;
+}
 /** Sizes used for a column that does not specify its own. */
 interface ColumnSizeDefaults {
     width: number;
@@ -153,6 +199,8 @@ interface ColumnResolveOptions {
     resizable?: boolean | undefined;
     /** Whether columns are reorderable, unless a column says otherwise. */
     reorderable?: boolean | undefined;
+    /** Whether columns may be dragged into the group-by bar, unless a column says otherwise. */
+    groupByDraggable?: boolean | undefined;
 }
 /**
  * A column paired with everything it takes to render it. Each field is a
@@ -179,6 +227,8 @@ interface ResolvedColumn<Row, Node = string> {
     resizable: boolean;
     /** Whether this column can be dragged, after the grid-level default. */
     reorderable: boolean;
+    /** Whether this column's header may be dragged into the group-by bar, after the grid-level default. */
+    groupByDraggable: boolean;
     /** How this column's cells align, after falling back to its type. */
     alignment: ColumnAlignment;
 }
@@ -242,6 +292,150 @@ interface ColumnSortEvent {
     readonly columnId: string;
     readonly sort: ColumnSortState;
 }
+/** One level of a stacked group-by, outer to inner. Mirrors ColumnSortEntry. */
+interface GroupByEntry {
+    readonly columnId: string;
+    /** Order of this level's own group values (not row order within a group). Defaults to "asc". */
+    readonly direction?: SortDirection;
+}
+/**
+ * The active grouping, outer to inner: index 0 groups first, each
+ * subsequent index nests inside it. Empty for an ungrouped grid, mirroring
+ * ColumnSortState's empty array for "no sort".
+ */
+type GroupByState = readonly GroupByEntry[];
+/**
+ * Reports a user group-by change whole — the stack to persist from. Mirrors
+ * ColumnSortEvent's `{columnId, sort}` shape.
+ */
+interface GroupByEvent {
+    readonly columnId: string;
+    readonly groupBy: GroupByState;
+}
+/**
+ * Group keys collapsed by the user — holding only the exceptions, the same
+ * way ColumnSizingState holds only resized widths. A key absent from this
+ * set is expanded; there is no separate "collapsed by default" concept.
+ */
+type GroupExpansionState = readonly string[];
+/**
+ * Reports a user expansion change. `groupId` is the group toggled, or `null`
+ * for expandAllGroups/collapseAllGroups, which touch every group in one call
+ * rather than one at a time.
+ */
+interface GroupExpansionEvent {
+    readonly groupId: string | null;
+    readonly expansion: GroupExpansionState;
+}
+/**
+ * One group header in a grouped result. `path` is every ancestor value
+ * down to and including this group's own, outermost first — what a header
+ * template needs to render "West / Enterprise", not just "Enterprise".
+ *
+ * Not parameterized by `Row`: nothing here holds a `Row`-typed value today —
+ * `aggregates` holds computed `unknown` results, not rows themselves.
+ */
+interface ResolvedGroupRow {
+    readonly kind: "group";
+    /** Stable id for this node: this plan's join of `path`, used as the React key and the GroupExpansionState entry. Opaque — build it with `groupRowId`, never construct one by hand. */
+    readonly groupId: string;
+    /** Nesting depth, 0 for a top-level group. */
+    readonly level: number;
+    readonly columnId: string;
+    /** This level's own value — the last entry of `path`. */
+    readonly value: unknown;
+    readonly path: readonly unknown[];
+    readonly expanded: boolean;
+    /** Leaf row count under this group, regardless of collapse state. */
+    readonly count: number;
+    /** Position among the display rows as rendered — same invariant ResolvedRow.rowIndex keeps. */
+    readonly rowIndex: number;
+    /** This header's absolute position in the whole filtered/sorted/grouped dataset, matching ResolvedRow.datasetIndex. */
+    readonly datasetIndex: number;
+    /**
+     * This group's own aggregate results, computed over its full leaf-row
+     * descendants regardless of collapse state — see `withGroupAggregates`.
+     * Empty when no `AggregateState` is active.
+     */
+    readonly aggregates: AggregateResults;
+}
+/**
+ * A group's own aggregate results, rendered as a row of its own rather than
+ * inline in its header — see `groupAggregateDisplay: "row"`. Emitted by
+ * `withGroupAggregates` immediately after a group's last visible
+ * descendant (its last nested group or data row, or immediately after its
+ * own header when collapsed), at that same group's `level`, one per group
+ * with `AggregateState` active — mirroring `ResolvedGroupRow` closely
+ * enough that the two are meant to be read side by side.
+ */
+interface ResolvedGroupSummaryRow {
+    readonly kind: "group-summary";
+    /** The group this summary belongs to — shared with that group's own `ResolvedGroupRow.groupId`, not a new id of its own. */
+    readonly groupId: string;
+    /** Nesting depth, matching the group's own `level`. */
+    readonly level: number;
+    /** Position among the display rows as rendered — same invariant every other DisplayRow's `rowIndex` keeps. */
+    readonly rowIndex: number;
+    /** This row's absolute position in the whole filtered/sorted/grouped dataset, matching ResolvedRow.datasetIndex. */
+    readonly datasetIndex: number;
+    /** This group's own aggregate results — identical to its `ResolvedGroupRow.aggregates`, computed once and shared rather than recomputed. */
+    readonly aggregates: AggregateResults;
+}
+/**
+ * One entry of a grouped result: an ordinary data row (no `kind` field at
+ * all — ResolvedRow is unchanged, so every existing consumer of plain
+ * ResolvedRow[] keeps compiling), a group header, or — only when
+ * `groupAggregateDisplay: "row"` is active — that group's own summary row.
+ * Discriminate with `"kind" in entry`, then `entry.kind`.
+ */
+type DisplayRow<Row> = ResolvedRow<Row> | ResolvedGroupRow | ResolvedGroupSummaryRow;
+/** A reducer this package computes without a custom `AggregateFn`. */
+type BuiltInAggregate = "sum" | "avg" | "min" | "max" | "count" | "countDistinct";
+/**
+ * Called with every raw row in scope — always the full leaf set, never a
+ * partial reduction combined from child groups, so a non-associative
+ * aggregate (median, distinct count) is never computed from
+ * already-aggregated values. Mirrors `FilterPredicate`'s shape, minus the
+ * per-row `value` since an aggregate reduces across rows rather than
+ * testing one.
+ */
+type AggregateFn<Row> = (rows: readonly Row[]) => unknown;
+/** One aggregate to compute against a column — a built-in reducer, or custom logic via `fn`. */
+interface AggregateSpec<Row> {
+    readonly columnId: string;
+    readonly fn: BuiltInAggregate | AggregateFn<Row>;
+    /** Distinguishes two aggregates on the same column (e.g. both sum and avg of Amount). Defaults to columnId, mirroring ColumnDefinition.id defaulting to field. */
+    readonly id?: string;
+    /**
+     * Overrides this aggregate's own cell alignment, in the grand-total
+     * footer and a group's own summary row (`groupAggregateDisplay: "row"`)
+     * — inline rendering (`"inline"`) is text, not a cell, so this has no
+     * effect there. Falls back to the column's own `alignment` when omitted.
+     * When two specs share a column and disagree, the first one in
+     * `AggregateState` wins for that shared cell, since one `<td>` can only
+     * take one `text-align`.
+     */
+    readonly alignment?: ColumnAlignment;
+}
+/**
+ * The active aggregates to compute. Empty for a grid with none, mirroring
+ * `FilterState`'s empty array for "no filter". A fully controlled prop —
+ * unlike `sort`/`filter`/`groupBy`/`pagination`, there is no built-in UI
+ * affordance for a user to add or remove an aggregate interactively.
+ */
+type AggregateState<Row> = readonly AggregateSpec<Row>[];
+/** One computed aggregate result, keyed by `spec.id ?? spec.columnId`. */
+type AggregateResults = ReadonlyMap<string, unknown>;
+/**
+ * Where a group's own aggregate results render. `"inline"` (the default)
+ * keeps them as text in the group header itself, next to its leaf-row
+ * count. `"row"` instead emits a `ResolvedGroupSummaryRow` immediately
+ * after that group's last visible descendant, with each aggregate's value
+ * in the `<td>` for its own column — the same alignment a grand-total
+ * footer cell has to its column, just scoped to one group instead of the
+ * whole dataset.
+ */
+type GroupAggregateDisplay = "inline" | "row";
 interface FilterEntryBase<Row> {
     readonly columnId?: FieldPath<Row> | (string & {});
 }
@@ -363,6 +557,8 @@ interface ResolvedRow<Row> {
     readonly row: Row;
     /** Position among the rows as rendered, matching `CellTemplateContext`. */
     readonly rowIndex: number;
+    /** This row's absolute position in the whole filtered/sorted/grouped dataset, matching `CellTemplateContext`. */
+    readonly datasetIndex: number;
 }
 /**
  * A selected column. Carries the resolved column rather than the bare
@@ -487,6 +683,7 @@ interface KeyShortcutCapabilities {
     reorderable: boolean;
     resizable: boolean;
     sortable: boolean;
+    groupable: boolean;
 }
 /**
  * The `aria-keyshortcuts` string for a column header, naming only the keys
@@ -534,8 +731,16 @@ declare function clampFocus(focus: GridFocus, rowCount: number, columnCount: num
  * `pageSize` is a pre-measured row count rather than a callback: this
  * function takes plain data only, so a caller measures the viewport once and
  * hands over the number.
- */
-declare function nextFocusForKey(key: string, modifiers: NavigationModifiers, focus: GridFocus, rowCount: number, columnCount: number, pageSize: number): GridFocus | null;
+ *
+ * `isSkippableRow` names rows the vertical moves (`ArrowUp`/`ArrowDown`/
+ * `PageUp`/`PageDown`/`Ctrl+End`) never land a tab stop on — a group's own
+ * summary row (`groupAggregateDisplay: "row"`), which still occupies a real
+ * row slot for `rowCount`/`aria-rowindex` purposes but is presentational,
+ * not a stop of its own. Left/right and plain `Home`/`End` stay row-scoped
+ * and so never consult it. Defaults to skipping nothing, so every existing
+ * caller (and every horizontal move) is unaffected.
+ */
+declare function nextFocusForKey(key: string, modifiers: NavigationModifiers, focus: GridFocus, rowCount: number, columnCount: number, pageSize: number, isSkippableRow?: (rowIndex: number) => boolean): GridFocus | null;
 
 /**
  * Puts `columns` in the order `order` gives. Ids it lists come first, in that
@@ -819,6 +1024,82 @@ declare function clearAllFilters<Row>(filter: FilterState<Row>): FilterState<Row
  */
 declare function filterRows<Row>(rows: readonly ResolvedRow<Row>[], filter: FilterState<Row>, columns: readonly ResolvedColumn<Row, unknown>[]): readonly ResolvedRow<Row>[];
 
+/**
+ * This group's id, from its path. Every group-id producer/consumer in this
+ * package goes through this — never join `path` by hand elsewhere.
+ *
+ * `JSON.stringify` rather than a delimiter join: a delimiter would have to be
+ * escaped in every segment to stay collision-free against a value that
+ * legitimately contains it, and `JSON.stringify` already draws that
+ * boundary between array entries for free.
+ */
+declare function groupRowId(path: readonly unknown[]): string;
+/**
+ * `rows`, regrouped into `groupBy`'s stacked levels — a group header per
+ * distinct value at each level, ordered by `compareValues` per that level's
+ * own `direction`, followed depth-first by its nested groups and/or data
+ * rows. A collapsed group (its `groupId` present in `expansion`) contributes
+ * only its own header, nothing beneath it — but its `count` still reports
+ * the group's full leaf-row count either way.
+ *
+ * Filter and sort are expected to have already run (see `resolveShownRows`):
+ * this only reshapes their output, and never changes which rows appear or
+ * their relative order within a group.
+ *
+ * `rowIndex` is renumbered across the whole flattened output, header rows
+ * included — the same invariant `sortRows`/`filterRows` keep for
+ * `ResolvedRow.rowIndex`, extended to `ResolvedGroupRow.rowIndex` since
+ * `GridBody` addresses both kinds by the same flat position.
+ *
+ * Returns `rows` itself, untouched, when `groupBy` is empty or names only
+ * columns absent from `columns` — a stored grouping tolerates a column
+ * removed from the definition the same way a stored `ColumnSortState` does.
+ */
+declare function groupRows<Row>(rows: readonly ResolvedRow<Row>[], groupBy: GroupByState, expansion: GroupExpansionState, columns: readonly ResolvedColumn<Row, unknown>[]): readonly DisplayRow<Row>[];
+/**
+ * The expansion with `groupId` collapsed if it was expanded, or expanded if
+ * it was collapsed.
+ */
+declare function toggleGroupExpansion(expansion: GroupExpansionState, groupId: string): GroupExpansionState;
+/** `expansion` reduced to empty — every group expanded. Mirrors `clearAllFilters`. */
+declare function expandAllGroups(expansion: GroupExpansionState): GroupExpansionState;
+/**
+ * Every group id present in `rows` — for collapsing every group currently
+ * shown in one call. Operates on the already-grouped display, not the raw
+ * grouping, so a group hidden beneath an already-collapsed ancestor (and so
+ * absent from `rows`) keeps whatever expansion it already had rather than
+ * being forced closed too; expanding that ancestor again reveals it exactly
+ * as it was left.
+ */
+declare function collapseAllGroups<Row>(rows: readonly DisplayRow<Row>[]): GroupExpansionState;
+/**
+ * `groupBy` with `columnId` positioned in front of `beforeColumnId` — or at
+ * the end when that is `null` — inserting a fresh entry if `columnId` isn't
+ * already part of the stack, or lifting its existing entry out and back in
+ * if it is. The one function both a header dropped on the group-by bar and
+ * a chip dragged within it need: the former's `columnId` is usually new to
+ * the stack, the latter's never is, and this doesn't need to be told which.
+ *
+ * An existing entry keeps its own object (and so its own `direction`)
+ * rather than being rebuilt, so a level merely repositioned stays
+ * reference-equal at its new index — the same reason `moveColumnBefore`
+ * moves ids rather than rebuilding them.
+ *
+ * Returns `groupBy` itself, untouched, when the move changes nothing: a
+ * drop on the entry's own id, or back into the gap it already occupies, or
+ * naming a `beforeColumnId` absent from the stack. Inserting a column not
+ * yet in the stack is never a no-op.
+ */
+declare function moveGroupByBefore(groupBy: GroupByState, columnId: string, beforeColumnId: string | null): GroupByState;
+/**
+ * Whether moving `columnId` in front of `beforeColumnId` would change
+ * `groupBy` at all, so that a drop indicator promises exactly the move that
+ * happens. Defined against `moveGroupByBefore` rather than restating its
+ * conditions, the same relationship `movesColumn` keeps with
+ * `moveColumnBefore`.
+ */
+declare function movesGroupBy(groupBy: GroupByState, columnId: string, beforeColumnId: string | null): boolean;
+
 /**
  * `rows`, filtered then sorted — the one function `DataGrid.tsx` (and any
  * future framework binding) calls instead of composing `filterRows`/
@@ -852,4 +1133,61 @@ declare function resolveColumns<Row, Node>(columns: readonly ResolvedColumn<Row,
  */
 declare function resolveCell<Row, Node>(rowsById: ReadonlyMap<string, ResolvedRow<Row>>, columns: readonly ResolvedColumn<Row, Node>[], cell: SelectedCellRef | null): SelectedCell<Row, Node> | null;
 
-export { type CellSelectEvent, type CellSelectionChangeEvent, type CellSelectionMode, type CellSelectionState, type CellTemplateContext, type ColumnAlignment, type ColumnConstraints, type ColumnDefinition, type ColumnOrderEvent, type ColumnOrderState, type ColumnResizeEvent, type ColumnResizeSession, type ColumnResolveOptions, type ColumnSelectEvent, type ColumnSelectionChangeEvent, type ColumnSizeDefaults, type ColumnSizingState, type ColumnSortEntry, type ColumnSortEvent, type ColumnSortState, type ColumnType, type ColumnWrapConfig, type ColumnsSelectEvent, DEFAULT_COLUMN_SIZES, type DropSide, type FieldPath, type FilterEntry, type FilterPredicate, type FilterState, type GridFocus, type GroupFilterEntry, HEADER_ROW, KEYBOARD_STEP, type KeyShortcutCapabilities, type NavigationModifiers, type PredicateFilterEntry, type ResolvedColumn, type ResolvedRow, type RowSelectEvent, type RowSelectionChangeEvent, type RowsSelectEvent, type SelectIntent, type SelectableConfig, type SelectedCell, type SelectedCellRef, type SelectedColumn, type SelectionDiff, type SelectionMode, type SelectionState, type SortDirection, type TextFilterEntry, type ValueFilterEntry, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, applySelectionIntent, beginColumnResize, buildKeyShortcuts, clampColumnWidth, clampFocus, clearAllFilters, clearSelection, compareValues, defineColumnsFromRows, diffSelection, filterQueryFor, filterRows, fitColumnsToWidth, getColumnId, intentOf, isSameCell, matchesQuery, moveColumnBefore, movesColumn, nextFocusForKey, resolveCell, resolveColumnConstraints, resolveColumnLabel, resolveColumnWidths, resolveColumns, resolveDropBefore, resolveKeyboardDropTarget, resolveRowId, resolveRows, resolveShownRows, revertColumnSize, selectAll, selectCell, selectOnly, selectRange, setColumnFilter, sizeColumnToContent, sortDirectionFor, sortPriorityFor, sortRows, toggleCellSelection, toggleColumnSort, toggleSelection, totalColumnWidth };
+interface PaginatedRows<Row> {
+    readonly rows: readonly DisplayRow<Row>[];
+    readonly pageCount: number;
+    /**
+     * `pagination.pageIndex` clamped into `[0, pageCount - 1]` (or `0` when
+     * `pageCount` is `0`) — read this back rather than trusting the input
+     * verbatim, the same way `sortRows`/`filterRows` tolerate a stale stored
+     * state.
+     */
+    readonly pageIndex: number;
+}
+/**
+ * `rows` sliced into pages of `pagination.pageSize` units — see `unitsOf`
+ * for what a unit is. `pageIndex` is clamped into range, `pageSize <= 0` is
+ * clamped to `1` (this codebase's general tolerance for stale/odd stored
+ * state, matching `sortRows`/`filterRows`), and the returned page's
+ * `rowIndex` is renumbered to be page-relative — 0-based from the top of the
+ * page, header rows included, mirroring `groupRows`'s own renumbering
+ * invariant. `datasetIndex` is left untouched: it is assigned once, ahead of
+ * filter/sort/group/paginate, and reports each row's position in the whole
+ * dataset regardless of which page is showing.
+ */
+declare function paginateRows<Row>(rows: readonly DisplayRow<Row>[], pagination: PaginationState): PaginatedRows<Row>;
+
+type PaginationWindowEntry = number | "ellipsis";
+/**
+ * Which page numbers a numbered pager should show for `currentPage` of
+ * `pageCount`, collapsing any gap wider than one page into a single
+ * `"ellipsis"` entry — the boundary + sibling windowing MUI's
+ * `usePagination` and antd's `Pagination` both use. Always includes the
+ * first/last `boundaryCount` pages and `currentPage`'s `siblingCount`
+ * neighbors on each side; a gap of exactly one page is filled in rather than
+ * collapsed, since an ellipsis standing in for a single page saves no space.
+ */
+declare function paginationWindow(currentPage: number, pageCount: number, options?: {
+    boundaryCount?: number | undefined;
+    siblingCount?: number | undefined;
+}): readonly PaginationWindowEntry[];
+
+/**
+ * `rows` reduced through every spec in `specs`, keyed by `spec.id ??
+ * spec.columnId`. A custom `fn` (a plain function, not a `BuiltInAggregate`
+ * name) is called once with the raw `rows` — no wrapping, no
+ * pre-processing, so it sees exactly the same leaf set a built-in reducer
+ * does.
+ *
+ * Two specs resolving to the same key: the later one wins, matching
+ * `setColumnFilter`'s own silent-replace precedent for a key collision
+ * rather than throwing.
+ *
+ * Returns a fresh empty `Map` for empty `rows` or empty `specs` — never a
+ * shared singleton — matching this codebase's general avoidance of shared
+ * mutable module state.
+ */
+declare function computeAggregates<Row>(rows: readonly Row[], specs: AggregateState<Row>, columns: readonly ResolvedColumn<Row, unknown>[]): AggregateResults;
+declare function withGroupAggregates<Row>(displayRows: readonly DisplayRow<Row>[], flatRows: readonly ResolvedRow<Row>[], groupBy: GroupByState, specs: AggregateState<Row>, columns: readonly ResolvedColumn<Row, unknown>[], display?: GroupAggregateDisplay): readonly DisplayRow<Row>[];
+
+export { type AggregateFn, type AggregateResults, type AggregateSpec, type AggregateState, type BuiltInAggregate, type CellSelectEvent, type CellSelectionChangeEvent, type CellSelectionMode, type CellSelectionState, type CellTemplateContext, type ColumnAlignment, type ColumnConstraints, type ColumnDefinition, type ColumnOrderEvent, type ColumnOrderState, type ColumnResizeEvent, type ColumnResizeSession, type ColumnResolveOptions, type ColumnSelectEvent, type ColumnSelectionChangeEvent, type ColumnSizeDefaults, type ColumnSizingState, type ColumnSortEntry, type ColumnSortEvent, type ColumnSortState, type ColumnType, type ColumnWrapConfig, type ColumnsSelectEvent, DEFAULT_COLUMN_SIZES, type DisplayRow, type DropSide, type FieldPath, type FilterEntry, type FilterPredicate, type FilterState, type FooterTemplateContext, type GridFocus, type GroupAggregateDisplay, type GroupByEntry, type GroupByEvent, type GroupByState, type GroupExpansionEvent, type GroupExpansionState, type GroupFilterEntry, HEADER_ROW, KEYBOARD_STEP, type KeyShortcutCapabilities, type NavigationModifiers, type PaginatedRows, type PaginationChangeEvent, type PaginationState, type PaginationWindowEntry, type PredicateFilterEntry, type ResolvedColumn, type ResolvedGroupRow, type ResolvedGroupSummaryRow, type ResolvedRow, type RowSelectEvent, type RowSelectionChangeEvent, type RowsSelectEvent, type SelectIntent, type SelectableConfig, type SelectedCell, type SelectedCellRef, type SelectedColumn, type SelectionDiff, type SelectionMode, type SelectionState, type SortDirection, type TextFilterEntry, type ValueFilterEntry, accessDotted, alignmentForType, applyColumnOrder, applyColumnResize, applySelectionIntent, beginColumnResize, buildKeyShortcuts, clampColumnWidth, clampFocus, clearAllFilters, clearSelection, collapseAllGroups, compareValues, computeAggregates, defineColumnsFromRows, diffSelection, expandAllGroups, filterQueryFor, filterRows, fitColumnsToWidth, getColumnId, groupRowId, groupRows, intentOf, isSameCell, matchesQuery, moveColumnBefore, moveGroupByBefore, movesColumn, movesGroupBy, nextFocusForKey, paginateRows, paginationWindow, resolveCell, resolveColumnConstraints, resolveColumnLabel, resolveColumnWidths, resolveColumns, resolveDropBefore, resolveKeyboardDropTarget, resolveRowId, resolveRows, resolveShownRows, revertColumnSize, selectAll, selectCell, selectOnly, selectRange, setColumnFilter, sizeColumnToContent, sortDirectionFor, sortPriorityFor, sortRows, toggleCellSelection, toggleColumnSort, toggleGroupExpansion, toggleSelection, totalColumnWidth, withGroupAggregates };