---
id: "packages/active-grid/api/types-grid"
title: "Grid (types)"
description: "Cell, CellContext, Column, ColumnFiltersState and 12 more: generated from the source of active-grid."
url: "/packages/active-grid/api/types-grid"
locale: "en"
revision: "g0mvjxwj5c-88bdbe1c:types-grid"
---

# Grid (types)

Exported by `@workspace/active-grid`. Generated from the package source; part of [the index of every export](/packages/active-grid/api).

## Types

**Cell**

```ts
type Cell<TData = DefaultRowData, TValue = unknown> =
  SourceCell<TData, TValue> | GeneratedCell<TData, TValue>;
```

One row paired with one column: a cell of a record's row, or of a generated
row. `cell.row.getIsGrouped()` tells the two apart.

**CellContext**

```ts
interface CellContext<
  TData = DefaultRowData,
  TValue = unknown,
> extends CellContextBase<TData, TValue> {
  readonly row: SourceRow<TData>;
  readonly cell: SourceCell<TData, TValue>;
}
```

What a body-cell renderer receives: a cell of a row that stands for a
record, so `row.original` is that record.

**Column**

```ts
interface Column<TData = DefaultRowData, TValue = unknown> {
  readonly id: string;
  readonly depth: number;
  readonly columnDef: GridColumnDef<TData>;
  readonly accessorFn?: AccessorFn<TData, TValue>;
  readonly parent?: Column<TData, TValue>;
  readonly columns: readonly Column<TData, TValue>[];
  readonly grid: Grid<TData>;
  getFlatColumns(): readonly Column<TData, TValue>[];
  getLeafColumns(): readonly Column<TData, TValue>[];
  getIsVisible(): boolean;
  getCanHide(): boolean;
  toggleVisibility(value?: boolean): void;
  getToggleVisibilityHandler(): (event: unknown) => void;
  getIndex(position?: ColumnArrangementPosition): number;
  getIsFirstColumn(position?: ColumnArrangementPosition): boolean;
  getIsLastColumn(position?: ColumnArrangementPosition): boolean;
  getIsPinned(): ColumnPinningPosition;
  getPinnedIndex(): number;
  getCanPin(): boolean;
  pin(position: ColumnPinningPosition): void;
  getSize(): number;
  getStart(position?: ColumnArrangementPosition): number;
  getAfter(position?: ColumnArrangementPosition): number;
  getCanResize(): boolean;
  getIsResizing(): boolean;
  resetSize(): void;
  getCanSort(): boolean;
  getCanMultiSort(): boolean;
  getIsSorted(): false | SortDirection;
  getSortIndex(): number;
  getFirstSortDir(): SortDirection;
  getNextSortingOrder(multi?: boolean): SortDirection | false;
  getAutoSortDir(): SortDirection;
  getSortFn(): SortFn<TData>;
  getAutoSortFn(): SortFn<TData>;
  toggleSorting(desc?: boolean, isMulti?: boolean): void;
  clearSorting(): void;
  getToggleSortingHandler(): ((event: unknown) => void) | undefined;
  getCanFilter(): boolean;
  getCanGlobalFilter(): boolean;
  getIsFiltered(): boolean;
  getFilterIndex(): number;
  getFilterValue(): unknown;
  setFilterValue(updater: Updater<unknown>): void;
  getFilterFn(): FilterFn<TData> | undefined;
  getAutoFilterFn(): FilterFn<TData> | undefined;
  getCanGroup(): boolean;
  getIsGrouped(): boolean;
  getGroupedIndex(): number;
  toggleGrouping(): void;
  getToggleGroupingHandler(): () => void;
  getAggregationFn(): AggregationFn<TData> | undefined;
  getAutoAggregationFn(): AggregationFn<TData> | undefined;
  getFacetedRowModel(): RowModel<TData>;
  getFacetedUniqueValues(): FacetedUniqueValueMap;
  getFacetedMinMaxValues(): [number, number] | undefined;
}
```

One column of the catalogue.

**ColumnFiltersState**

```ts
type ColumnFiltersState = ColumnFilter[];
```

The active column filters, in the order they were declared.

**GeneratedCell**

```ts
interface GeneratedCell<
  TData = DefaultRowData,
  TValue = unknown,
> extends CellBase<TData, TValue> {
  readonly row: GeneratedRow<TData>;
  getContext(): GeneratedCellContext<TData, TValue>;
}
```

A cell of a row that grouping generated.

**GeneratedCellContext**

```ts
interface GeneratedCellContext<
  TData = DefaultRowData,
  TValue = unknown,
> extends CellContextBase<TData, TValue> {
  readonly row: GeneratedRow<TData>;
  readonly cell: GeneratedCell<TData, TValue>;
}
```

What the renderer of a generated row's cell receives: a row that stands for
a value several records share and carries no record of its own.

**GeneratedRow**

```ts
interface GeneratedRow<TData = DefaultRowData> extends RowBase<TData> {
  readonly original: undefined;
  readonly originalSubRows?: undefined;
  readonly groupingColumnId: string;
  readonly groupingValue: unknown;
  getAllCells(): readonly GeneratedCell<TData, unknown>[];
  getAllCellsByColumnId(): Readonly<
    Record<string, GeneratedCell<TData, unknown>>
  >;
  getVisibleCells(): readonly GeneratedCell<TData, unknown>[];
  getAllVisibleCells(): readonly GeneratedCell<TData, unknown>[];
  getStartVisibleCells(): readonly GeneratedCell<TData, unknown>[];
  getCenterVisibleCells(): readonly GeneratedCell<TData, unknown>[];
  getEndVisibleCells(): readonly GeneratedCell<TData, unknown>[];
}
```

A row grouping generated: it stands for a value several records share, and
there is no record it stands for.

**Grid**

```ts
interface Grid<TData = DefaultRowData> {
  readonly options: GridOptions<TData>;
  readonly initialState: GridState;
  setOptions(updater: Updater<GridOptions<TData>>): void;
  getState(): GridState;
  subscribe(listener: () => void): () => void;
  getDefaultColumnDef(): Partial<GridColumnDef<TData, unknown>>;
  getRowId(
    originalRow: TData,
    index: number,
    parent?: SourceRow<TData>,
  ): string;
  getCoreRowModel(): RowModel<TData>;
  getPreFilteredRowModel(): RowModel<TData>;
  getFilteredRowModel(): RowModel<TData>;
  getPreGroupedRowModel(): RowModel<TData>;
  getGroupedRowModel(): RowModel<TData>;
  getPreSortedRowModel(): RowModel<TData>;
  getSortedRowModel(): RowModel<TData>;
  getPreExpandedRowModel(): RowModel<TData>;
  getExpandedRowModel(): RowModel<TData>;
  getPrePaginatedRowModel(): RowModel<TData>;
  getPaginatedRowModel(): RowModel<TData>;
  getRowModel(): RowModel<TData>;
  getPreSelectedRowModel(): RowModel<TData>;
  getSelectedRowModel(): RowModel<TData>;
  getFilteredSelectedRowModel(): RowModel<TData>;
  getGroupedSelectedRowModel(): RowModel<TData>;
  getRow(id: string, searchAll?: boolean): Row<TData>;
  getRowCount(): number;
  getTopRows(): readonly Row<TData>[];
  getCenterRows(): readonly Row<TData>[];
  getBottomRows(): readonly Row<TData>[];
  getIsSomeRowsPinned(position?: RowPinningPosition): boolean;
  getColumn(columnId: string): Column<TData, unknown> | undefined;
  getAllColumns(): readonly Column<TData, unknown>[];
  getAllFlatColumns(): readonly Column<TData, unknown>[];
  getAllFlatColumnsById(): Readonly<Record<string, Column<TData, unknown>>>;
  getAllLeafColumns(): readonly Column<TData, unknown>[];
  getVisibleFlatColumns(): readonly Column<TData, unknown>[];
  getVisibleLeafColumns(): readonly Column<TData, unknown>[];
  getStartLeafColumns(): readonly Column<TData, unknown>[];
  getCenterLeafColumns(): readonly Column<TData, unknown>[];
  getEndLeafColumns(): readonly Column<TData, unknown>[];
  getStartVisibleLeafColumns(): readonly Column<TData, unknown>[];
  getCenterVisibleLeafColumns(): readonly Column<TData, unknown>[];
  getEndVisibleLeafColumns(): readonly Column<TData, unknown>[];
  getIsAllColumnsVisible(): boolean;
  getIsSomeColumnsVisible(): boolean;
  getIsSomeColumnsPinned(position?: ColumnPinningPosition): boolean;
  toggleAllColumnsVisible(value?: boolean): void;
  getToggleAllColumnsVisibilityHandler(): (event: unknown) => void;
  getHeaderGroups(): readonly HeaderGroup<TData>[];
  getStartHeaderGroups(): readonly HeaderGroup<TData>[];
  getCenterHeaderGroups(): readonly HeaderGroup<TData>[];
  getEndHeaderGroups(): readonly HeaderGroup<TData>[];
  getFooterGroups(): readonly HeaderGroup<TData>[];
  getStartFooterGroups(): readonly HeaderGroup<TData>[];
  getCenterFooterGroups(): readonly HeaderGroup<TData>[];
  getEndFooterGroups(): readonly HeaderGroup<TData>[];
  getFlatHeaders(): readonly Header<TData, unknown>[];
  getStartFlatHeaders(): readonly Header<TData, unknown>[];
  getCenterFlatHeaders(): readonly Header<TData, unknown>[];
  getEndFlatHeaders(): readonly Header<TData, unknown>[];
  getLeafHeaders(): readonly Header<TData, unknown>[];
  getStartLeafHeaders(): readonly Header<TData, unknown>[];
  getCenterLeafHeaders(): readonly Header<TData, unknown>[];
  getEndLeafHeaders(): readonly Header<TData, unknown>[];
  getTotalSize(): number;
  getStartTotalSize(): number;
  getCenterTotalSize(): number;
  getEndTotalSize(): number;
  getGlobalFilterFn(): FilterFn<TData> | undefined;
  getGlobalAutoFilterFn(): FilterFn<TData> | undefined;
  getGlobalFacetedRowModel(): RowModel<TData>;
  getGlobalFacetedUniqueValues(): FacetedUniqueValueMap;
  getGlobalFacetedMinMaxValues(): [number, number] | undefined;
  getIsAllRowsSelected(): boolean;
  getIsSomeRowsSelected(): boolean;
  getIsAllPageRowsSelected(): boolean;
  getIsSomePageRowsSelected(): boolean;
  toggleAllRowsSelected(value?: boolean): void;
  toggleAllPageRowsSelected(value?: boolean): void;
  getToggleAllRowsSelectedHandler(): (event: unknown) => void;
  getToggleAllPageRowsSelectedHandler(): (event: unknown) => void;
  getCanSomeRowsExpand(): boolean;
  getIsAllRowsExpanded(): boolean;
  getIsSomeRowsExpanded(): boolean;
  getExpandedDepth(): number;
  toggleAllRowsExpanded(expanded?: boolean): void;
  getToggleAllRowsExpandedHandler(): (event: unknown) => void;
  getPageCount(): number;
  getPageOptions(): number[];
  getCanPreviousPage(): boolean;
  getCanNextPage(): boolean;
  previousPage(): void;
  nextPage(): void;
  firstPage(): void;
  lastPage(): void;
  setPageIndex(updater: Updater<number>): void;
  setPageSize(updater: Updater<number>): void;
  setSorting(updater: Updater<SortingState>): void;
  setColumnFilters(updater: Updater<ColumnFiltersState>): void;
  setGlobalFilter(updater: Updater<string | undefined>): void;
  setGrouping(updater: Updater<GroupingState>): void;
  setExpanded(updater: Updater<ExpandedState>): void;
  setPagination(updater: Updater<PaginationState>): void;
  setRowSelection(updater: Updater<RowSelectionState>): void;
  setColumnVisibility(updater: Updater<ColumnVisibilityState>): void;
  setColumnOrder(updater: Updater<ColumnOrderState>): void;
  setColumnPinning(updater: Updater<ColumnPinningState>): void;
  setColumnSizing(updater: Updater<ColumnSizingState>): void;
  setColumnResizing(updater: Updater<ColumnResizingState>): void;
  setRowPinning(updater: Updater<RowPinningState>): void;
  reset(): void;
  resetSorting(defaultState?: boolean): void;
  resetColumnFilters(defaultState?: boolean): void;
  resetGlobalFilter(defaultState?: boolean): void;
  resetGrouping(defaultState?: boolean): void;
  resetExpanded(defaultState?: boolean): void;
  resetPagination(defaultState?: boolean): void;
  resetPageIndex(defaultState?: boolean): void;
  resetPageSize(defaultState?: boolean): void;
  resetRowSelection(defaultState?: boolean): void;
  resetColumnVisibility(defaultState?: boolean): void;
  resetColumnOrder(defaultState?: boolean): void;
  resetColumnPinning(defaultState?: boolean): void;
  resetColumnSizing(defaultState?: boolean): void;
  resetHeaderSizeInfo(defaultState?: boolean): void;
  resetRowPinning(defaultState?: boolean): void;
}
```

One grid instance.

The handle is stable for the lifetime of the instance: nothing may use its
identity as a signal that something changed. What changes is what it hands
back.

**GroupingState**

```ts
type GroupingState = string[];
```

The columns the rows are grouped by, outermost first.

**Header**

```ts
interface Header<TData = DefaultRowData, TValue = unknown> {
  readonly id: string;
  readonly index: number;
  readonly depth: number;
  readonly column: Column<TData, TValue>;
  readonly grid: Grid<TData>;
  readonly headerGroup: HeaderGroup<TData> | null;
  readonly isPlaceholder: boolean;
  readonly placeholderId?: string;
  readonly colSpan: number;
  readonly subHeaders: readonly Header<TData, TValue>[];
  getLeafHeaders(): readonly Header<TData, TValue>[];
  getSize(): number;
  getStart(position?: ColumnPinningPosition): number;
  getContext(): HeaderContext<TData, TValue>;
  getResizeHandler(context?: Document): (event: unknown) => void;
}
```

One header: a column, at a depth, over a run of laid-out leaf columns.

**HeaderContext**

```ts
interface HeaderContext<TData = DefaultRowData, TValue = unknown> {
  readonly grid: Grid<TData>;
  readonly column: Column<TData, TValue>;
  readonly header: Header<TData, TValue>;
}
```

What a header or footer renderer receives.

**HeaderGroup**

```ts
interface HeaderGroup<TData = DefaultRowData> {
  readonly id: string;
  readonly depth: number;
  readonly headers: readonly Header<TData, unknown>[];
}
```

One level of the header hierarchy.

**Row**

```ts
type Row<TData = DefaultRowData> =
  SourceRow<TData> | GeneratedRow<TData>;
```

One row of a model: a {@link SourceRow} that stands for a record, or a
{@link GeneratedRow} that grouping produced. `row.getIsGrouped()` tells the
two apart and narrows the row to the one it is; only a source row has a
record in `original`.

**SortingState**

```ts
type SortingState = ColumnSort[];
```

The sort entries, in priority order.

**SourceCell**

```ts
interface SourceCell<
  TData = DefaultRowData,
  TValue = unknown,
> extends CellBase<TData, TValue> {
  readonly row: SourceRow<TData>;
  getContext(): CellContext<TData, TValue>;
}
```

A cell of a row that stands for a record.

**SourceRow**

```ts
interface SourceRow<TData = DefaultRowData> extends RowBase<TData> {
  readonly original: TData;
  readonly originalSubRows?: readonly TData[];
  readonly groupingColumnId?: undefined;
  readonly groupingValue?: undefined;
  getAllCells(): readonly SourceCell<TData, unknown>[];
  getAllCellsByColumnId(): Readonly<Record<string, SourceCell<TData, unknown>>>;
  getVisibleCells(): readonly SourceCell<TData, unknown>[];
  getAllVisibleCells(): readonly SourceCell<TData, unknown>[];
  getStartVisibleCells(): readonly SourceCell<TData, unknown>[];
  getCenterVisibleCells(): readonly SourceCell<TData, unknown>[];
  getEndVisibleCells(): readonly SourceCell<TData, unknown>[];
}
```

A row that stands for one record of the data.