ag-grid-community

ag-grid-community

Version 35.3.0
Published 9 days ago
20 MB
1 dependency
MIT license

Install

npm i ag-grid-community

yarn add ag-grid-community

pnpm add ag-grid-community

Overview

Advanced Data Grid / Data Table supporting Javascript / Typescript / React / Angular / Vue

Index

Variables

variable agTestIdFor

const agTestIdFor: {
    grid(gridId: string): string;
    headerGroupCell(colId: string | null): string;
    headerCell(colId: string | null): string;
    headerCheckbox(colId: string | null): string;
    headerFilterButton(colId: string | null): string;
    floatingFilter(colId: string | null): string;
    floatingFilterButton(colId: string | null): string;
    headerCellMenuButton(colId: string | null): string;
    headerResizeHandle(colId?: string | null): string;
    filterInstancePickerDisplay(spec: FilterSpec): string;
    numberFilterInstanceInput(spec: FilterSpec): string;
    textFilterInstanceInput(spec: FilterSpec): string;
    dateFilterInstanceInput(spec: FilterSpec): string;
    setFilterInstanceMiniFilterInput(spec: FilterSpec): string;
    setFilterInstanceItem(spec: FilterSpec, itemLabel?: string | null): string;
    setFilterApplyPanelButton(spec: FilterSpec, buttonLabel?: string | null): string;
    filterConditionRadioButton(
        spec: FilterSpec,
        buttonLabel?: string | null
    ): string;
    advancedFilterInput(): string;
    advancedFilterButton(label?: string | null): string;
    advancedFilterBuilderButton(): string;
    advancedFilterPanelMaximiseButton(): string;
    advancedFilterPanelCloseButton(): string;
    advancedFilterPill(label?: string | null): string;
    advancedFilterBuilderAddItemButton(): string;
    rowNode(rowId: string | null): string;
    cell(rowId: string | null, colId: string | null): string;
    autoGroupCell(rowId: string | null): string;
    checkbox(rowId: string | null, colId: string | null): string;
    selectionColumnCheckbox(rowId: string | null): string;
    autoGroupColumnCheckbox(rowId: string | null): string;
    dragHandle(rowId: string | null, colId: string | null): string;
    groupContracted(rowId: string | null, colId: string | null): string;
    groupExpanded(rowId: string | null, colId: string | null): string;
    autoGroupContracted(rowId: string | null): string;
    autoGroupExpanded(rowId: string | null): string;
    rowNumber(rowId: string | null): string;
    menu(): string;
    menuOption(option?: string | null): string;
    sideBar(): string;
    sideBarButton(label?: string | null): string;
    columnToolPanel(): string;
    pivotModeSelect(): string;
    columnPanelSelectHeaderCheckbox(): string;
    columnPanelSelectHeaderFilter(): string;
    columnSelectListItemGroupClosedIcon(label?: string | null): string;
    columnSelectListItemCheckbox(label?: string | null): string;
    columnSelectListItemDragHandle(label?: string | null): string;
    columnDropCellDragHandle(
        source: 'panel' | 'toolbar',
        area?: string | null,
        label?: string | null
    ): string;
    columnDropCellCancelButton(
        source: 'panel' | 'toolbar',
        area?: string | null,
        label?: string | null
    ): string;
    columnDropArea(source: 'panel' | 'toolbar', name?: string | null): string;
    filterToolPanel(): string;
    filterToolPanelAddFilterButton(): string;
    filterToolPanelFilterTypeSelector(colLabel?: string | null): string;
    filterToolPanelSearchInput(): string;
    filterToolPanelGroup(title?: string | null): string;
    filterToolPanelGroupCollapsedIcon(title?: string | null): string;
    statusBarTotalAndFilteredRowCount(): string;
    statusBarTotalRowCount(): string;
    statusBarFilteredRowCount(): string;
    statusBarSelectedRowCount(): string;
    statusBarAggregations(): string;
    paginationPanelSizePickerDisplay(value?: string | null): string;
    paginationPanelFirstRowOnPage(value?: string | null): string;
    paginationPanelLastRowOnPage(value?: string | null): string;
    paginationPanelRecordCount(value?: string | null): string;
    paginationSummaryPanelButton(label?: string | null): string;
    paginationSummaryPanelCurrentPage(value?: string | null): string;
    paginationSummaryPanelTotalPage(value?: string | null): string;
    fillHandle(): string;
    columnChooserCloseButton(): string;
    columnChooserSearchBarCheckbox(): string;
    columnChooserSearchBarFilter(): string;
    columnChooserListItemGroupClosedIcon(label: string | null): string;
    columnChooserListItemCheckbox(label: string | null): string;
    columnChooserListItemDragHandle(label: string | null): string;
    overlay(): string;
};

variable buttonStyleAlpine

const buttonStyleAlpine: Part<ButtonStyleParams>;

variable buttonStyleBalham

const buttonStyleBalham: Part<ButtonStyleParams>;

variable buttonStyleBase

const buttonStyleBase: Part<ButtonStyleParams>;

variable buttonStyleQuartz

const buttonStyleQuartz: Part<ButtonStyleParams>;

variable CellSpanModule

const CellSpanModule: _ModuleWithoutApi;

Spanning -> Cell Spanning colDef.rowSpan, colDef.colSpan

variable CellStyleModule

const CellStyleModule: _ModuleWithoutApi;

Cells -> Styling Cells cellStyle, cellClass, cellClassRules

variable checkboxStyleDefault

const checkboxStyleDefault: Part<CheckboxStyleParams>;

variable ClientSideRowModelApiModule

const ClientSideRowModelApiModule: _ModuleWithApi<_ClientSideRowModelGridApi<any>>;

Client-Side Row Model

variable ClientSideRowModelModule

const ClientSideRowModelModule: _ModuleWithoutApi;

Client-Side Row Model

variable colorSchemeDark

const colorSchemeDark: Part<{
    readonly backgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly foregroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly chromeBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly rowHoverColor: import('../../../main-umd-noStyles').ColorValue;
    readonly selectedRowBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly menuBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly browserColorScheme: import('../../../main-umd-noStyles').ColorSchemeValue;
    readonly popupShadow: import('../../../main-umd-noStyles').ShadowValue;
    readonly cardShadow: import('../../../main-umd-noStyles').ShadowValue;
    readonly advancedFilterBuilderJoinPillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly advancedFilterBuilderColumnPillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly advancedFilterBuilderOptionPillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly advancedFilterBuilderValuePillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly filterPanelApplyButtonColor: import('../../../main-umd-noStyles').ColorValue;
    readonly columnPanelApplyButtonColor: import('../../../main-umd-noStyles').ColorValue;
    readonly findMatchColor: import('../../../main-umd-noStyles').ColorValue;
    readonly findActiveMatchColor: import('../../../main-umd-noStyles').ColorValue;
    readonly checkboxUncheckedBorderColor: import('../../../main-umd-noStyles').ColorValue;
    readonly toggleButtonOffBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly rowBatchEditBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken1Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken2Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken3Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken4Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken5Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken6Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken7Color: import('../../../main-umd-noStyles').ColorValue;
    readonly cellBatchEditBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly cellBatchEditTextColor: import('../../../main-umd-noStyles').ColorValue;
    readonly rowBatchEditTextColor: import('../../../main-umd-noStyles').ColorValue;
    readonly borderColor: import('../../../main-umd-noStyles').ColorValue;
}>;

variable colorSchemeDarkBlue

const colorSchemeDarkBlue: Part<{
    readonly backgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly foregroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly chromeBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly rowHoverColor: import('../../../main-umd-noStyles').ColorValue;
    readonly selectedRowBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly menuBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly browserColorScheme: import('../../../main-umd-noStyles').ColorSchemeValue;
    readonly popupShadow: import('../../../main-umd-noStyles').ShadowValue;
    readonly cardShadow: import('../../../main-umd-noStyles').ShadowValue;
    readonly advancedFilterBuilderJoinPillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly advancedFilterBuilderColumnPillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly advancedFilterBuilderOptionPillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly advancedFilterBuilderValuePillColor: import('../../../main-umd-noStyles').ColorValue;
    readonly filterPanelApplyButtonColor: import('../../../main-umd-noStyles').ColorValue;
    readonly columnPanelApplyButtonColor: import('../../../main-umd-noStyles').ColorValue;
    readonly findMatchColor: import('../../../main-umd-noStyles').ColorValue;
    readonly findActiveMatchColor: import('../../../main-umd-noStyles').ColorValue;
    readonly checkboxUncheckedBorderColor: import('../../../main-umd-noStyles').ColorValue;
    readonly toggleButtonOffBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly rowBatchEditBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken1Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken2Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken3Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken4Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken5Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken6Color: import('../../../main-umd-noStyles').ColorValue;
    readonly formulaToken7Color: import('../../../main-umd-noStyles').ColorValue;
    readonly cellBatchEditBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly cellBatchEditTextColor: import('../../../main-umd-noStyles').ColorValue;
    readonly rowBatchEditTextColor: import('../../../main-umd-noStyles').ColorValue;
    readonly borderColor: import('../../../main-umd-noStyles').ColorValue;
}>;

variable colorSchemeDarkWarm

const colorSchemeDarkWarm: Part<{
    backgroundColor: import('../../../main-umd-noStyles').ColorValue;
    foregroundColor: import('../../../main-umd-noStyles').ColorValue;
    browserColorScheme: import('../../../main-umd-noStyles').ColorSchemeValue;
}>;

variable colorSchemeLight

const colorSchemeLight: Part<{
    readonly backgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly foregroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly borderColor: import('../../../main-umd-noStyles').ColorValue;
    readonly chromeBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly browserColorScheme: import('../../../main-umd-noStyles').ColorSchemeValue;
}>;

variable colorSchemeLightCold

const colorSchemeLightCold: Part<{
    foregroundColor: import('../../../main-umd-noStyles').ColorValue;
    chromeBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    backgroundColor: import('../../../main-umd-noStyles').ColorValue;
    borderColor: import('../../../main-umd-noStyles').ColorValue;
    browserColorScheme: import('../../../main-umd-noStyles').ColorSchemeValue;
}>;

variable colorSchemeLightWarm

const colorSchemeLightWarm: Part<{
    foregroundColor: import('../../../main-umd-noStyles').ColorValue;
    borderColor: import('../../../main-umd-noStyles').ColorValue;
    chromeBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    backgroundColor: import('../../../main-umd-noStyles').ColorValue;
    browserColorScheme: import('../../../main-umd-noStyles').ColorSchemeValue;
}>;

variable colorSchemeVariable

const colorSchemeVariable: Part<{
    readonly backgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly foregroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly borderColor: import('../../../main-umd-noStyles').ColorValue;
    readonly chromeBackgroundColor: import('../../../main-umd-noStyles').ColorValue;
    readonly browserColorScheme: import('../../../main-umd-noStyles').ColorSchemeValue;
}>;

variable ColumnAutoSizeModule

const ColumnAutoSizeModule: _ModuleWithApi<_ColumnAutosizeApi>;

Columns -> Column Sizing autoSizeStrategy

variable columnDropStyleBordered

const columnDropStyleBordered: Part<{}>;

variable columnDropStylePlain

const columnDropStylePlain: Part<{}>;

variable ColumnHoverModule

const ColumnHoverModule: _ModuleWithApi<_ColumnHoverApi>;

Rows -> Styling Rows columnHoverHighlight

variable DETAIL_ROW_ID_PREFIX

const DETAIL_ROW_ID_PREFIX: string;

Prefix for detail row IDs in master-detail grids ('detail_'). A detail row ID is DETAIL_ROW_ID_PREFIX + masterRowNode.id.

variable DragAndDropModule

const DragAndDropModule: _ModuleWithoutApi;

Import & Export -> Drag & Drop dndSource, dndSourceOnRowDrag

variable ExternalFilterModule

const ExternalFilterModule: _ModuleWithoutApi;

Filtering -> External Filter doesExternalFilterPass

variable GRAND_TOTAL_ROW_ID

const GRAND_TOTAL_ROW_ID: string;

The row ID of the grand total row ('rowGroupFooter_ROOT_NODE_ID'). Use with api.getRowNode(GRAND_TOTAL_ROW_ID).

variable GROUP_AUTO_COLUMN_ID

const GROUP_AUTO_COLUMN_ID: string;

variable GROUP_HIERARCHY_COLUMN_ID_PREFIX

const GROUP_HIERARCHY_COLUMN_ID_PREFIX: string;

variable GROUP_TOTAL_ROW_ID_PREFIX

const GROUP_TOTAL_ROW_ID_PREFIX: string;

Prefix for group total (footer) row IDs ('rowGroupFooter_'). A group total row ID is GROUP_TOTAL_ROW_ID_PREFIX + groupRowNode.id.

variable HighlightChangesModule

const HighlightChangesModule: _ModuleWithApi<_HighlightChangesGridApi<any>>;

Cells -> Highlighting Changes enableCellChangeFlash

variable iconSetAlpine

const iconSetAlpine: Part<{}>;

variable iconSetBalham

const iconSetBalham: Part<{}>;

variable iconSetMaterial

const iconSetMaterial: Part<{}>;

variable iconSetQuartzBold

const iconSetQuartzBold: Part<unknown>;

variable iconSetQuartzLight

const iconSetQuartzLight: Part<unknown>;

variable iconSetQuartzRegular

const iconSetQuartzRegular: Part<unknown>;

variable InfiniteRowModelModule

const InfiniteRowModelModule: _ModuleWithApi<_InfiniteRowModelGridApi>;

Infinite Row Model

variable inputStyleBase

const inputStyleBase: Part<InputStyleParams>;

variable inputStyleBordered

const inputStyleBordered: Part<InputStyleParams>;

variable inputStyleUnderlined

const inputStyleUnderlined: Part<InputStyleParams>;

variable KeyCode

const KeyCode: {
    readonly BACKSPACE: 'Backspace';
    readonly TAB: 'Tab';
    readonly ENTER: 'Enter';
    readonly ESCAPE: 'Escape';
    readonly SPACE: ' ';
    readonly LEFT: 'ArrowLeft';
    readonly UP: 'ArrowUp';
    readonly RIGHT: 'ArrowRight';
    readonly DOWN: 'ArrowDown';
    readonly DELETE: 'Delete';
    readonly F2: 'F2';
    readonly PAGE_UP: 'PageUp';
    readonly PAGE_DOWN: 'PageDown';
    readonly PAGE_HOME: 'Home';
    readonly PAGE_END: 'End';
    readonly A: 'KeyA';
    readonly C: 'KeyC';
    readonly D: 'KeyD';
    readonly V: 'KeyV';
    readonly X: 'KeyX';
    readonly Y: 'KeyY';
    readonly Z: 'KeyZ';
};

variable LargeTextEditorModule

const LargeTextEditorModule: _ModuleWithoutApi;

Editing -> Large Text Editor

variable LocaleModule

const LocaleModule: _ModuleWithoutApi;

Interactivity -> Localisation localeText, getLocaleText

variable PinnedRowModule

const PinnedRowModule: _ModuleWithApi<_PinnedRowGridApi>;

Rows -> Row Pinning enableRowPinning, isRowPinnable, isRowPinned, pinnedTopRowData, pinnedBottomRowData

variable QuickFilterModule

const QuickFilterModule: _ModuleWithApi<_QuickFilterGridApi>;

Filtering -> Quick Filter quickFilterText

variable ROOT_NODE_ID

const ROOT_NODE_ID: string;

The row ID of the root node ('ROOT_NODE_ID'). Use with api.getRowNode(ROOT_NODE_ID).

variable ROW_NUMBERS_COLUMN_ID

const ROW_NUMBERS_COLUMN_ID: string;

variable RowStyleModule

const RowStyleModule: _ModuleWithoutApi;

Rows -> Styling Rows rowStyle, getRowStyle, rowClass, getRowClass, rowClassRules

variable SELECTION_COLUMN_ID

const SELECTION_COLUMN_ID: string;

variable STRUCTURED_SCHEMA_FEATURES

const STRUCTURED_SCHEMA_FEATURES: StructuredSchemaFeature[];

variable styleMaterial

const styleMaterial: Part<{ primaryColor: ColorValue }>;

variable tabStyleBase

const tabStyleBase: Part<TabStyleParams>;

This base tab style adds no visual styling, it provides a base upon which a tab style can be built by setting the tab-related params

variable tabStyleRolodex

const tabStyleRolodex: Part<TabStyleParams>;

Tabs where the selected tab appears raised and attached the the active content, like a rolodex or operating system tabs.

variable themeAlpine

const themeAlpine: Theme<ThemeDefaultParams>;

variable themeBalham

const themeBalham: Theme<ThemeDefaultParams>;

variable themeMaterial

const themeMaterial: Theme<
    CoreParams &
        ButtonStyleParams &
        CheckboxStyleParams &
        TabStyleParams &
        InputStyleParams &
        BatchEditStyleParams &
        FormulaStyleParams &
        NoteStyleParams &
        StyleMaterialParams
>;

variable themeQuartz

const themeQuartz: Theme<ThemeDefaultParams>;

variable TooltipModule

const TooltipModule: _ModuleWithoutApi;

Tooltips tooltipField, tooltipValueGetter, headerTooltip, tooltipComponentSelector

Functions

function convertColumnGroupState

convertColumnGroupState: (
    columnGroupState: { groupId: string; open: boolean }[]
) => Pick<GridState, 'columnGroup'>;

Converts state retrieved from api.getColumnGroupState() to grid state.
Returns
A partial GridState object containing only the properties relevant to column groups

function convertColumnState

convertColumnState: (
    columnState: ColumnState[],
    enablePivotMode?: boolean
) => Pick<
    GridState,
    | 'sort'
    | 'rowGroup'
    | 'aggregation'
    | 'pivot'
    | 'columnPinning'
    | 'columnVisibility'
    | 'columnSizing'
    | 'columnOrder'
>;

Converts state retrieved from api.getColumnState() to grid state.
Parameter columnState
Parameter enablePivotMode
Whether pivot mode should be enabled or not. Default false.
Returns
A partial GridState object containing only the properties relevant to columns

function createGrid

createGrid: <TData>(
    eGridDiv: HTMLElement,
    gridOptions: GridOptions<TData>,
    params?: Params
) => GridApi<TData>;

Creates a grid inside the provided HTML element.
Parameter eGridDiv
Parent element to contain the grid.
Parameter gridOptions
Configuration for the grid.
Parameter params
Individually register AG Grid Modules to this grid.
Returns
api to be used to interact with the grid.

function createPart

createPart: <T = unknown>(
    args: CreatePartArgs<T>
) => Part<ExpandTypeKeys<WithParamTypes<T>>>;

Create a new empty part.
Parameter feature
an The part feature, e.g. 'iconSet'. Adding a part to a theme will remove any existing part with the same feature.
Parameter variant
an optional identifier for debugging, if omitted one will be generated

function createTheme

createTheme: () => Theme<
    CoreParams &
        ButtonStyleParams &
        BatchEditStyleParams &
        FormulaStyleParams &
        NoteStyleParams
>;

Create a custom theme containing core grid styles but no parts.

function getGridApi

getGridApi: (
    gridElement: Element | string | null | undefined
) => GridApi | undefined;

Returns a GridApi instance that is associated with the grid rendered in gridElement.
The gridElement argument can be one of the following: - a DOM node - the grid ID as determined by the gridId grid option. - CSS selector string
When using a CSS selector, it must refer to the element passed to createGrid.
If passing a DOM node as an argument, this DOM node must be an immediate child of the element passed to createGrid. This is to support the case where multiple grids are instantiated in a single element.

function getGridElement

getGridElement: (api: GridApi) => Element | undefined;

Returns the Element instance associated with the grid instance referred to by GridApi

function iconOverrides

iconOverrides: (
    args: IconSetOverridesArgs
) => import('../../../../main-umd-noStyles').Part<{}>;

function iconSetQuartz

iconSetQuartz: (args?: { strokeWidth?: number }) => Part<unknown>;

function isColumn

isColumn: (
    col: Column | ColumnGroup | ProvidedColumnGroup
) => col is AgColumn<any>;

function isColumnGroup

isColumnGroup: (col: Column | ColumnGroup | string) => col is AgColumnGroup<any>;

function isCombinedFilterModel

isCombinedFilterModel: <M extends ISimpleFilterModel>(
    model: M | ICombinedSimpleModel<M>
) => model is ICombinedSimpleModel<M>;

function isProvidedColumnGroup

isProvidedColumnGroup: (
    col: Column | ProvidedColumnGroup | string | null
) => col is AgProvidedColumnGroup;

function provideGlobalGridOptions

provideGlobalGridOptions: (
    gridOptions: GridOptions,
    mergeStrategy?: GlobalGridOptionsMergeStrategy
) => void;

Provide gridOptions that will be shared by all grid instances. Individually defined GridOptions will take precedence over global options.
Parameter gridOptions
global grid options

function setupAgTestIds

setupAgTestIds: ({ testIdAttribute }?: TestIdSetupParams) => void;

function wrapAgTestIdFor

wrapAgTestIdFor: <TLocator>(fn: (str: string) => TLocator) => Locators<TLocator>;

Utility function to wrap the agTestIdFor functions to a specific testing framework to reduce code duplication and improve readability.
Parameter fn
A function that takes a string and returns a locator for that string.
Returns
Same functions as agTestIdFor, but returning a locator instead of a string.
Example 1
// Playwright // Before await expect(page.getByTestId(agTestIdFor.rowNode('0'))).toBeVisible(); await expect(page.getByTestId(agTestIdFor.cell('0', 'color'))).toBeVisible();
// After const agIdFor = wrapAgTestIdFor((testId) => page.getByTestId(testId));
await expect(agIdFor.rowNode('0')).toBeVisible(); await expect(agIdFor.cell('0', 'color')).toBeVisible();

Classes

class AgAbstractCellEditor

abstract class AgAbstractCellEditor<
        P extends ICellEditorParams,
        TValue,
        TEditorValue = TValue
    >
    extends AgPopupComponent<
        BeanCollection,
        GridOptionsWithDefaults,
        AgEventTypeParams,
        AgGridCommon<any, any>,
        GridOptionsService,
        AgComponentSelectorType
    >
    implements ICellEditorComp, AgBaseCellEditor<TValue> {}

property eEditor

protected abstract eEditor: AgAbstractField<
    BeanCollection,
    GridOptionsWithDefaults,
    {
        columnEverythingChanged: ColumnEverythingChangedEvent<any, any>;
        newColumnsLoaded: NewColumnsLoadedEvent<any, any>;
        columnPivotModeChanged: ColumnPivotModeChangedEvent<any, any>;
        pivotMaxColumnsExceeded: PivotMaxColumnsExceededEvent<any, any>;
        columnRowGroupChanged: ColumnRowGroupChangedEvent<any, any>;
        expandOrCollapseAll: ExpandOrCollapseAllEvent<any, any>;
        columnPivotChanged: ColumnPivotChangedEvent<any, any>;
        gridColumnsChanged: GridColumnsChangedEvent<any, any>;
        columnValueChanged: ColumnValueChangedEvent<any, any>;
        columnMoved: ColumnMovedEvent<any, any>;
        columnVisible: ColumnVisibleEvent<any, any>;
        columnPinned: ColumnPinnedEvent<any, any>;
        columnGroupOpened: ColumnGroupOpenedEvent<any, any>;
        columnResized: ColumnResizedEvent<any, any>;
        displayedColumnsChanged: DisplayedColumnsChangedEvent<any, any>;
        virtualColumnsChanged: VirtualColumnsChangedEvent<any, any>;
        columnHeaderMouseOver: ColumnHeaderMouseOverEvent<any, any>;
        columnHeaderMouseLeave: ColumnHeaderMouseLeaveEvent<any, any>;
        columnHeaderClicked: ColumnHeaderClickedEvent<any, any>;
        columnHeaderContextMenu: ColumnHeaderContextMenuEvent<any, any>;
        asyncTransactionsFlushed: AsyncTransactionsFlushedEvent<any, any>;
        rowGroupOpened: RowGroupOpenedEvent<any, any>;
        rowDataUpdated: RowDataUpdatedEvent<any, any>;
        pinnedRowDataChanged: PinnedRowDataChangedEvent<any, any>;
        pinnedRowsChanged: PinnedRowsChangedEvent<any, any>;
        rangeSelectionChanged: RangeSelectionChangedEvent<any, any>;
        cellSelectionChanged: CellSelectionChangedEvent<any, any>;
        chartCreated: ChartCreatedEvent<any, any>;
        chartRangeSelectionChanged: ChartRangeSelectionChangedEvent<any, any>;
        chartOptionsChanged: ChartOptionsChangedEvent<any, any>;
        chartDestroyed: ChartDestroyedEvent<any, any>;
        toolPanelVisibleChanged: ToolPanelVisibleChangedEvent<any, any>;
        toolPanelSizeChanged: ToolPanelSizeChangedEvent<any, any>;
        modelUpdated: ModelUpdatedEvent<any, any>;
        cutStart: CutStartEvent<any, any>;
        cutEnd: CutEndEvent<any, any>;
        pasteStart: PasteStartEvent<any, any>;
        pasteEnd: PasteEndEvent<any, any>;
        fillStart: FillStartEvent<any, any>;
        fillEnd: FillEndEvent<any, any>;
        cellSelectionDeleteStart: CellSelectionDeleteStartEvent<any, any>;
        cellSelectionDeleteEnd: CellSelectionDeleteEndEvent<any, any>;
        rangeDeleteStart: RangeDeleteStartEvent<any, any>;
        rangeDeleteEnd: RangeDeleteEndEvent<any, any>;
        undoStarted: UndoStartedEvent<any, any>;
        undoEnded: UndoEndedEvent<any, any>;
        redoStarted: RedoStartedEvent<any, any>;
        redoEnded: RedoEndedEvent<any, any>;
        cellClicked: CellClickedEvent<any, any, any>;
        cellDoubleClicked: CellDoubleClickedEvent<any, any, any>;
        cellMouseDown: CellMouseDownEvent<any, any, any>;
        cellContextMenu: CellContextMenuEvent<any, any, any>;
        cellValueChanged: CellValueChangedEvent<any, any, any, any>;
        cellEditRequest: CellEditRequestEvent<any, any, any>;
        rowValueChanged: RowValueChangedEvent<any, any>;
        headerFocused: HeaderFocusedEvent<any, any>;
        cellFocused: CellFocusedEvent<any, any>;
        rowSelected: RowSelectedEvent<any, any>;
        selectionChanged: SelectionChangedEvent<any, any>;
        tooltipShow: TooltipShowEvent<any, any>;
        tooltipHide: TooltipHideEvent<any, any>;
        cellKeyDown:
            | FullWidthCellKeyDownEvent<any, any>
            | CellKeyDownEvent<any, any, any>;
        cellMouseOver: CellMouseOverEvent<any, any, any>;
        cellMouseOut: CellMouseOutEvent<any, any, any>;
        filterChanged: FilterChangedEvent<any, any>;
        filterModified: FilterModifiedEvent<any, any>;
        filterUiChanged: FilterUiChangedEvent<any, any>;
        filterOpened: FilterOpenedEvent<any, any>;
        floatingFilterUiChanged: FloatingFilterUiChangedEvent<any, any>;
        advancedFilterBuilderVisibleChanged: AdvancedFilterBuilderVisibleChangedEvent<
            any,
            any
        >;
        sortChanged: SortChangedEvent<any, any>;
        virtualRowRemoved: VirtualRowRemovedEvent<any, any>;
        rowClicked: RowClickedEvent<any, any>;
        rowDoubleClicked: RowDoubleClickedEvent<any, any>;
        gridReady: GridReadyEvent<any, any>;
        gridPreDestroyed: GridPreDestroyedEvent<any, any>;
        gridSizeChanged: GridSizeChangedEvent<any, any>;
        viewportChanged: ViewportChangedEvent<any, any>;
        firstDataRendered: FirstDataRenderedEvent<any, any>;
        dragStarted: DragStartedEvent<any, any>;
        dragStopped: DragStoppedEvent<any, any>;
        dragCancelled: DragCancelledEvent<any, any>;
        rowEditingStarted: RowEditingStartedEvent<any, any>;
        rowEditingStopped: RowEditingStoppedEvent<any, any>;
        cellEditingStarted: CellEditingStartedEvent<any, any, any>;
        cellEditingStopped: CellEditingStoppedEvent<any, any, any>;
        bodyScroll: BodyScrollEvent<any, any>;
        bodyScrollEnd: BodyScrollEndEvent<any, any>;
        paginationChanged: PaginationChangedEvent<any, any>;
        componentStateChanged: ComponentStateChangedEvent<any, any>;
        storeRefreshed: StoreRefreshedEvent<any, any>;
        stateUpdated: StateUpdatedEvent<any, any>;
        columnMenuVisibleChanged: ColumnMenuVisibleChangedEvent<any, any>;
        contextMenuVisibleChanged: ContextMenuVisibleChangedEvent<any, any>;
        rowDragEnter: RowDragEnterEvent<any, any>;
        rowDragMove: RowDragMoveEvent<any, any>;
        rowDragLeave: RowDragLeaveEvent<any, any>;
        rowDragEnd: RowDragEndEvent<any, any>;
        rowDragCancel: RowDragCancelEvent<any, any>;
        findChanged: FindChangedEvent<any, any>;
        rowResizeStarted: RowResizeStartedEvent<any, any>;
        rowResizeEnded: RowResizeEndedEvent<any, any>;
        scrollbarWidthChanged: ScrollbarWidthChangedEvent<any, any>;
        keyShortcutChangedCellStart: KeyShortcutChangedCellStartEvent<any, any>;
        keyShortcutChangedCellEnd: KeyShortcutChangedCellEndEvent<any, any>;
        pinnedHeightChanged: PinnedHeightChangedEvent<any, any>;
        cellFocusCleared: CellFocusClearedEvent<any, any>;
        fullWidthRowFocused: FullWidthRowFocusedEvent<any, any>;
        checkboxChanged: CheckboxChangedEvent<any, any>;
        heightScaleChanged: HeightScaleChangedEvent<any, any>;
        suppressMovableColumns: SuppressMovableColumnsEvent<any, any>;
        suppressMenuHide: SuppressMenuHideEvent<any, any>;
        suppressFieldDotNotation: SuppressFieldDotNotationEvent<any, any>;
        columnPanelItemDragStart: ColumnPanelItemDragStartEvent<any, any>;
        columnPanelItemDragEnd: ColumnPanelItemDragEndEvent<any, any>;
        bodyHeightChanged: BodyHeightChangedEvent<any, any>;
        columnContainerWidthChanged: ColumnContainerWidthChangedEvent<any, any>;
        displayedColumnsWidthChanged: DisplayedColumnsWidthChangedEvent<
            any,
            any
        >;
        scrollVisibilityChanged: ScrollVisibilityChangedEvent<any, any>;
        scrollGapChanged: ScrollOverflowChangedEvent<any, any>;
        columnHoverChanged: ColumnHoverChangedEvent<any, any>;
        flashCells: FlashCellsEvent<any, any>;
        paginationPixelOffsetChanged: PaginationPixelOffsetChangedEvent<
            any,
            any
        >;
        displayedRowsChanged: DisplayedRowsChangedEvent<any, any>;
        leftPinnedWidthChanged: LeftPinnedWidthChangedEvent<any, any>;
        rightPinnedWidthChanged: RightPinnedWidthChangedEvent<any, any>;
        rowContainerHeightChanged: RowContainerHeightChangedEvent<any, any>;
        headerHeightChanged: HeaderHeightChangedEvent<any, any>;
        columnGroupHeaderHeightChanged: ColumnGroupHeaderHeightChangedEvent<
            any,
            any
        >;
        columnHeaderHeightChanged: ColumnHeaderHeightChangedEvent<any, any>;
        stylesChanged: StylesChangedEvent<any, any>;
        storeUpdated: StoreUpdatedEvent<any, any>;
        filterDestroyed: FilterDestroyedEvent<any, any>;
        filterHandlerDestroyed: FilterHandlerDestroyedEvent<any, any>;
        filterClosed: FilterClosedEvent<any, any>;
        rowDataUpdateStarted: RowDataUpdateStartedEvent<any, any>;
        rowCountReady: RowCountReadyEvent<any, any>;
        advancedFilterEnabledChanged: AdvancedFilterEnabledChangedEvent<
            any,
            any
        >;
        dataTypesInferred: DataTypesInferredEvent<any, any>;
        fieldValueChanged: FieldValueChangedEvent<any, any>;
        fieldPickerValueSelected: FieldPickerValueSelectedEvent<any, any>;
        richSelectListRowSelected: RichSelectListRowSelectedEvent<any, any>;
        sideBarUpdated: SideBarUpdatedEvent<any, any>;
        alignedGridScroll: AlignedGridScrollEvent<any, any>;
        alignedGridColumn: AlignedGridColumnEvent<any, any>;
        gridOptionsChanged: GridOptionsChangedEvent<any, any>;
        chartTitleEdit: ChartTitleEditEvent<any, any>;
        recalculateRowBounds: RecalculateRowBoundsEvent<any, any>;
        stickyTopOffsetChanged: StickyTopOffsetChangedEvent<any, any>;
        overlayExclusiveChanged: AgEvent<'overlayExclusiveChanged'>;
        rowNodeDataChanged: RowNodeDataChangedEvent<any, any>;
        columnsReset: ColumnsResetEvent<any, any>;
        cellEditValuesChanged: CellEditValuesChangedEvent<any, any, any>;
        filterSwitched: FilterSwitchedEvent<any, any>;
        batchEditingStarted: BatchEditingStartedEvent<any, any>;
        batchEditingStopped: BatchEditingStoppedEvent<any, any>;
        bulkEditingStarted: BulkEditingStartedEvent<any, any>;
        bulkEditingStopped: BulkEditingStoppedEvent<any, any>;
        headerRowsChanged: AgEvent<'headerRowsChanged'>;
        rowExpansionStateChanged: AgEvent<'rowExpansionStateChanged'>;
        showRowGroupColsSetChanged: AgEvent<'showRowGroupColsSetChanged'>;
        rowDragVisibilityChanged: AgEvent<'rowDragVisibilityChanged'>;
    },
    AgGridCommon<any, any>,
    GridOptionsService,
    AgComponentSelectorType,
    TEditorValue,
    any,
    any
>;

property errorMessages

errorMessages: string[];

property params

protected params: ICellEditorParams<any, any, any>;

method agSetEditValue

abstract agSetEditValue: (value: TValue | null | undefined) => void;

method destroy

destroy: () => void;

method getValidationElement

abstract getValidationElement: (
    tooltip: boolean
) => HTMLElement | HTMLInputElement;

method getValidationErrors

abstract getValidationErrors: () => string[] | null;

method getValue

abstract getValue: () => TValue | null | undefined;

method init

init: (params: P) => void;

method initialiseEditor

protected abstract initialiseEditor: (params: P) => void;

class AgPromise

class AgPromise<T> {}

constructor

constructor(callback: ResolveAndRejectCallback<T>);

method all

static all: <T>(promises: AgPromise<T | null>[]) => AgPromise<(T | null)[]>;

method resolve

static resolve: <T>(value?: T | null) => AgPromise<T>;

method then

then: <V>(func: (result: T | null) => V) => AgPromise<V>;

class BigIntFilter

class BigIntFilter extends SimpleFilter<
    BigIntFilterModel,
    bigint,
    GridInputTextField,
    BigIntFilterDisplayParams
> {}

constructor

constructor();

property defaultDebounceMs

protected defaultDebounceMs: number;

property filterType

readonly filterType: string;

method afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams | undefined) => void;

method areSimpleModelsEqual

protected areSimpleModelsEqual: (
    aSimple: BigIntFilterModel,
    bSimple: BigIntFilterModel
) => boolean;

method areStatesEqual

protected areStatesEqual: (
    stateA?: { isInvalid: boolean },
    stateB?: { isInvalid: boolean }
) => boolean;

method canApply

protected canApply: (
    _model: BigIntFilterModel | ICombinedSimpleModel<BigIntFilterModel> | null
) => boolean;

method createCondition

protected createCondition: (position: number) => BigIntFilterModel;

method createEValue

protected createEValue: () => HTMLElement;

method getInputs

protected getInputs: (position: number) => Tuple<GridInputTextField>;

method getState

protected getState: () => { isInvalid: boolean };

method getValues

protected getValues: (position: number) => Tuple<bigint>;

method hasInvalidInputs

protected hasInvalidInputs: () => boolean;

method positionHasInvalidInputs

protected positionHasInvalidInputs: (position: number) => boolean;

method refresh

refresh: (legacyNewParams: ProvidedFilterParams) => boolean;

method removeConditionsAndOperators

protected removeConditionsAndOperators: (
    startPosition: number,
    deleteCount?: number | undefined
) => void;

method removeEValues

protected removeEValues: (startPosition: number, deleteCount?: number) => void;

method setElementValue

protected setElementValue: (
    element: GridInputTextField<
        AgInputTextFieldParams<AgComponentSelectorType>,
        'fieldValueChanged'
    >,
    value: bigint | null,
    fromFloatingFilter?: boolean
) => void;

method shouldKeepInvalidInputState

protected shouldKeepInvalidInputState: () => boolean;

class CheckboxCellEditor

class CheckboxCellEditor extends AgAbstractCellEditor<
    ICellEditorParams<any, boolean>,
    boolean
> {}

constructor

constructor();

property eEditor

protected readonly eEditor: GridCheckbox<
    AgCheckboxParams<AgComponentSelectorType>
>;

method afterGuiAttached

afterGuiAttached: () => void;

method agSetEditValue

agSetEditValue: (value: boolean | null | undefined) => void;

method focusIn

focusIn: () => void;

method getValidationElement

getValidationElement: (tooltip: boolean) => HTMLElement | HTMLInputElement;

method getValidationErrors

getValidationErrors: () => string[] | null;

method getValue

getValue: () => boolean | undefined;

method initialiseEditor

initialiseEditor: (params: ICellEditorParams<any, boolean>) => void;

method isPopup

isPopup: () => boolean;

class CheckboxSelectionComponent

class CheckboxSelectionComponent extends Component {}

constructor

constructor();

method init

init: (params: {
    rowNode: RowNode;
    column?: AgColumn;
    overrides?: {
        isVisible:
            | boolean
            | CheckboxSelectionCallback
            | GroupCheckboxSelectionCallback
            | undefined;
        callbackParams: any;
        removeHidden: boolean;
    };
}) => void;

method postConstruct

postConstruct: () => void;

class DateCellEditor

class DateCellEditor extends SimpleCellEditor<
    Date,
    IDateCellEditorParams,
    GridInputDateField
> {}

constructor

constructor();

class DateFilter

class DateFilter extends SimpleFilter<
    DateFilterModel,
    Date,
    DateCompWrapper,
    DateFilterDisplayParams
> {}

constructor

constructor();

property filterType

readonly filterType: string;

method afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

method areSimpleModelsEqual

protected areSimpleModelsEqual: (
    aSimple: DateFilterModel,
    bSimple: DateFilterModel
) => boolean;

method areStatesEqual

protected areStatesEqual: (
    stateA?: { isInvalid: boolean },
    stateB?: { isInvalid: boolean }
) => boolean;

method canApply

protected canApply: (
    _model: DateFilterModel | ICombinedSimpleModel<DateFilterModel> | null
) => boolean;

method commonUpdateSimpleParams

protected commonUpdateSimpleParams: (params: DateFilterDisplayParams) => void;

method createCondition

protected createCondition: (position: number) => DateFilterModel;

method createEValue

protected createEValue: () => HTMLElement;

method getInputs

protected getInputs: (position: number) => Tuple<DateCompWrapper>;

method getState

protected getState: () => { isInvalid: boolean };

method getValues

protected getValues: (position: number) => Tuple<Date>;

method hasInvalidInputs

protected hasInvalidInputs: () => boolean;

method isConditionUiComplete

protected isConditionUiComplete: (position: number) => boolean;

method positionHasInvalidInputs

protected positionHasInvalidInputs: (position: number) => boolean;

method removeConditionsAndOperators

protected removeConditionsAndOperators: (
    startPosition: number,
    deleteCount?: number | undefined
) => void;

method removeDateComps

protected removeDateComps: (
    components: DateCompWrapper[],
    startPosition: number,
    deleteCount?: number
) => void;

method removeEValues

protected removeEValues: (startPosition: number, deleteCount?: number) => void;

method resetPlaceholder

protected resetPlaceholder: () => void;

method setElementDisabled

protected setElementDisabled: (
    element: DateCompWrapper,
    disabled: boolean
) => void;

method setElementDisplayed

protected setElementDisplayed: (
    element: DateCompWrapper,
    displayed: boolean
) => void;

method setElementValue

protected setElementValue: (
    element: DateCompWrapper,
    value: Date | null
) => void;

method shouldKeepInvalidInputState

protected shouldKeepInvalidInputState: () => boolean;

method translate

protected translate: (
    key: FilterLocaleTextKey,
    variableValues?: string[]
) => string;

class DateStringCellEditor

class DateStringCellEditor extends SimpleCellEditor<
    string,
    IDateStringCellEditorParams,
    GridInputDateField
> {}

constructor

constructor();

class GridOptionsService

class GridOptionsService
    extends BeanStub
    implements
        NamedBean,
        IPropertiesService<GridOptionsWithDefaults, AgGridCommon<any, any>> {}

property beanName

beanName: string;

method addCommon

addCommon: <
    T extends AgGridCommon<TData, TContext>,
    TData = any,
    TContext = any
>(
    params: WithoutGridCommon<T>
) => T;

Prefer _addGridCommonParams from gridOptionsUtils for bundle size savings

method addPropertyEventListener

addPropertyEventListener: <K extends keyof GridOptions<any>>(
    key: K,
    listener: PropertyValueChangedListener<K>
) => void;

method assertModuleRegistered

assertModuleRegistered: <
    TId extends 1 | 2 | 3,
    TShowMessageAtCallLocation = {
        readonly 1: 'Charting Aggregation';
        readonly 2: 'pivotResultFields';
        readonly 3: 'setTooltip';
    }[TId]
>(
    moduleName: ValidationModuleName | ValidationModuleName[],
    reasonOrId: string | TId
) => boolean;

method destroy

destroy: () => void;

method exists

exists: (property: keyof GridOptions) => boolean;

Returns true if a value has been specified for this GridOption.
Parameter property
GridOption property

method get

get: <K extends keyof GridOptions<any>>(property: K) => GridOptionOrDefault<K>;

Get the raw value of the GridOptions property provided.
Parameter property

method getCallback

getCallback: <K extends CallbackProps>(
    property: K
) => WrappedCallback<K, GridOptions[K]>;

Get the GridOption callback but wrapped so that the common params of api and context are automatically applied to the params.
Parameter property
GridOption callback properties based on the fact that this property has a callback with params extending AgGridCommon

method getDomDataKey

getDomDataKey: () => string;

method getModuleErrorParams

getModuleErrorParams: () => {
    gridScoped: boolean;
    gridId: string;
    rowModelType: RowModelType;
    isUmd: boolean;
    usesAgGridProvider: boolean;
};

method isElementInThisInstance

isElementInThisInstance: (element: HTMLElement) => boolean;

method isModuleRegistered

isModuleRegistered: (moduleName: ModuleName) => boolean;

method postConstruct

postConstruct: () => void;

method removePropertyEventListener

removePropertyEventListener: <K extends keyof GridOptions<any>>(
    key: K,
    listener: PropertyValueChangedListener<K>
) => void;

method setInstanceDomData

setInstanceDomData: (element: HTMLElement) => void;

method updateGridOptions

updateGridOptions: ({
    options,
    force,
    source,
}: {
    options: Partial<GridOptions>;
    force?: boolean;
    source?: AgPropertyChangedSource;
}) => void;

method validateColDef

validateColDef: (
    colDef: ColDef | ColGroupDef,
    colId: string,
    skipInferenceCheck?: boolean
) => void;

method wireBeans

wireBeans: (beans: BeanCollection) => void;

class LargeTextCellEditor

class LargeTextCellEditor extends AgAbstractCellEditor<
    ILargeTextEditorParams,
    string
> {}

constructor

constructor();

property eEditor

protected readonly eEditor: GridInputTextArea;

method afterGuiAttached

afterGuiAttached: () => void;

method agSetEditValue

agSetEditValue: (value: string | null | undefined) => void;

method getValidationElement

getValidationElement: () => HTMLElement | HTMLInputElement;

method getValidationErrors

getValidationErrors: () => string[] | null;

method getValue

getValue: () => any;

method initialiseEditor

initialiseEditor: (params: ILargeTextEditorParams) => void;

class ModuleRegistry

class ModuleRegistry {}

method register

static register: (module: Module) => void;

Deprecated
v33 Use registerModules([module]) instead.

method registerModules

static registerModules: (modules: Module[]) => void;

Globally register the given modules for all grids.
Parameter modules
modules to register

class NumberCellEditor

class NumberCellEditor extends SimpleCellEditor<
    number,
    INumberCellEditorParams,
    GridInputNumberField
> {}

constructor

constructor();

class NumberFilter

class NumberFilter extends SimpleFilter<
    NumberFilterModel,
    number,
    GridInputTextField | GridInputNumberField,
    NumberFilterDisplayParams
> {}

constructor

constructor();

property defaultDebounceMs

protected defaultDebounceMs: number;

property filterType

readonly filterType: string;

method afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams | undefined) => void;

method areSimpleModelsEqual

protected areSimpleModelsEqual: (
    aSimple: NumberFilterModel,
    bSimple: NumberFilterModel
) => boolean;

method areStatesEqual

protected areStatesEqual: (
    stateA?: { isInvalid: boolean },
    stateB?: { isInvalid: boolean }
) => boolean;

method canApply

protected canApply: (
    _model: NumberFilterModel | ICombinedSimpleModel<NumberFilterModel> | null
) => boolean;

method createCondition

protected createCondition: (position: number) => NumberFilterModel;

method createEValue

protected createEValue: () => HTMLElement;

method getInputs

protected getInputs: (
    position: number
) => Tuple<GridInputTextField | GridInputNumberField>;

method getState

protected getState: () => { isInvalid: boolean };

method getValues

protected getValues: (position: number) => Tuple<number>;

method hasInvalidInputs

protected hasInvalidInputs: () => boolean;

method positionHasInvalidInputs

protected positionHasInvalidInputs: (position: number) => boolean;

method refresh

refresh: (legacyNewParams: ProvidedFilterParams) => boolean;

method removeConditionsAndOperators

protected removeConditionsAndOperators: (
    startPosition: number,
    deleteCount?: number | undefined
) => void;

method removeEValues

protected removeEValues: (startPosition: number, deleteCount?: number) => void;

method setElementValue

protected setElementValue: (
    element: GridInputTextField | GridInputNumberField,
    value: number | null,
    fromFloatingFilter?: boolean
) => void;

method shouldKeepInvalidInputState

protected shouldKeepInvalidInputState: () => boolean;

class PinnedRowModel

class PinnedRowModel extends BeanStub implements NamedBean, IPinnedRowModel {}

property beanName

beanName: string;

method ensureRowHeightsValid

ensureRowHeightsValid: () => boolean;

method forEachPinnedRow

forEachPinnedRow: (
    container: NonNullable<RowPinnedType>,
    callback: (node: RowNode, index: number) => void
) => void;

method getGrandTotalPinned

getGrandTotalPinned: () => RowPinnedType;

method getPinnedBottomRow

getPinnedBottomRow: (index: number) => RowNode | undefined;

method getPinnedBottomRowCount

getPinnedBottomRowCount: () => number;

method getPinnedBottomTotalHeight

getPinnedBottomTotalHeight: () => number;

method getPinnedRowById

getPinnedRowById: (
    id: string,
    container: NonNullable<RowPinnedType>
) => RowNode<any> | undefined;

method getPinnedState

getPinnedState: () => RowPinningState;

method getPinnedTopRow

getPinnedTopRow: (index: number) => RowNode | undefined;

method getPinnedTopRowCount

getPinnedTopRowCount: () => number;

method getPinnedTopTotalHeight

getPinnedTopTotalHeight: () => number;

method isEmpty

isEmpty: (container: NonNullable<RowPinnedType>) => boolean;

method isManual

isManual: () => boolean;

method isRowsToRender

isRowsToRender: (container: NonNullable<RowPinnedType>) => boolean;

method pinRow

pinRow: (
    node: RowNode<any>,
    container: RowPinnedType,
    column?: AgColumn | null
) => void;

method postConstruct

postConstruct: () => void;

method reset

reset: () => void;

method setGrandTotalPinned

setGrandTotalPinned: (value: RowPinnedType) => void;

method setPinnedState

setPinnedState: (state: RowPinningState) => void;

class PopupEditorWrapper

class PopupEditorWrapper extends AgPopupComponent<
    BeanCollection,
    GridOptionsWithDefaults,
    AgEventTypeParams,
    AgGridCommon<any, any>,
    GridOptionsService,
    AgComponentSelectorType
> {}

constructor

constructor(params: ICellEditorParams<any, any, any>);

method postConstruct

postConstruct: () => void;

class ProvidedFilter

abstract class ProvidedFilter<
        M extends ProvidedFilterModel,
        V,
        P extends ProvidedFilterDisplayParams<M> = ProvidedFilterDisplayParams<M>
    >
    extends Component
    implements IProvidedFilter, IFilterComp {}

Contains common logic to all provided filters (apply button, clear button, etc). All the filters that come with AG Grid extend this class. User filters do not extend this class.
Parameter M
type of filter-model managed by the concrete sub-class that extends this type
Parameter V
type of value managed by the concrete sub-class that extends this type

constructor

constructor(
    filterNameKey:
        | 'empty'
        | 'applyFilter'
        | 'clearFilter'
        | 'resetFilter'
        | 'cancelFilter'
        | 'textFilter'
        | 'numberFilter'
        | 'bigintFilter'
        | 'dateFilter'
        | 'setFilter'
        | 'filterOoo'
        | 'equals'
        | 'notEqual'
        | 'lessThan'
        | 'greaterThan'
        | 'inRange'
        | 'inRangeStart'
        | 'inRangeEnd'
        | 'lessThanOrEqual'
        | 'greaterThanOrEqual'
        | 'contains'
        | 'notContains'
        | 'startsWith'
        | 'endsWith'
        | 'blank'
        | 'notBlank'
        | 'before'
        | 'after'
        | 'andCondition'
        | 'orCondition'
        | 'dateFormatOoo'
        | 'filterSummaryInactive'
        | 'filterSummaryContains'
        | 'filterSummaryNotContains'
        | 'filterSummaryTextEquals'
        | 'filterSummaryTextNotEqual'
        | 'filterSummaryStartsWith'
        | 'filterSummaryEndsWith'
        | 'filterSummaryBlank'
        | 'filterSummaryNotBlank'
        | 'filterSummaryEquals'
        | 'filterSummaryNotEqual'
        | 'filterSummaryGreaterThan'
        | 'filterSummaryGreaterThanOrEqual'
        | 'filterSummaryLessThan'
        | 'filterSummaryLessThanOrEqual'
        | 'filterSummaryInRange'
        | 'yesterday'
        | 'today'
        | 'tomorrow'
        | 'last7Days'
        | 'lastWeek'
        | 'thisWeek'
        | 'nextWeek'
        | 'last30Days'
        | 'lastMonth'
        | 'thisMonth'
        | 'nextMonth'
        | 'last90Days'
        | 'lastQuarter'
        | 'thisQuarter'
        | 'nextQuarter'
        | 'lastYear'
        | 'thisYear'
        | 'yearToDate'
        | 'nextYear'
        | 'last6Months'
        | 'last12Months'
        | 'last24Months'
        | 'filterSummaryInRangeValues'
        | 'filterSummaryTextQuote'
        | 'minDateValidation'
        | 'maxDateValidation'
        | 'strictMinValueValidation'
        | 'strictMaxValueValidation',
    cssIdentifier: string
);

property defaultDebounceMs

protected defaultDebounceMs: number;

property filterType

abstract readonly filterType:
    | 'number'
    | 'bigint'
    | 'date'
    | 'text'
    | 'set'
    | 'multi';

Used to get the filter type for filter models.

property lastContainerType

protected lastContainerType?: ContainerType;

property params

protected params: IProvidedFilterParams & FilterDisplayParams<any, any, M, any>;

property state

protected state: FilterDisplayState<M, any>;

method afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

method afterGuiDetached

afterGuiDetached: () => void;

method applyModel

applyModel: (_source?: 'api' | 'ui' | 'rowDataUpdated') => boolean;

Applies changes made in the UI to the filter, and returns true if the model has changed.

method areNonNullModelsEqual

protected abstract areNonNullModelsEqual: (a: M, b: M) => boolean;

method areStatesEqual

protected areStatesEqual: (stateA: any, stateB: any) => boolean;

method canApply

protected canApply: (_model: M | null) => boolean;

method createBodyTemplate

protected abstract createBodyTemplate: () => ElementParams | null;

method destroy

destroy: () => void;

method doesFilterPass

doesFilterPass: (params: IDoesFilterPassParams) => boolean;

Deprecated
v34 Use the same method on the filter handler (api.getColumnFilterHandler()) instead.

method getAgComponents

protected abstract getAgComponents: () => ComponentSelector[];

method getFilterTitle

getFilterTitle: () => string;

method getModel

getModel: () => M | null;

Deprecated
v34 Use (api.getColumnFilterModel()) instead.

method getModelFromUi

abstract getModelFromUi: () => M | null;

method getPositionableElement

protected getPositionableElement: () => HTMLElement;

method getState

protected getState: () => any;

method getUiChangeEventParams

protected getUiChangeEventParams: () => any;

method handleKeyDown

protected handleKeyDown: (_e: KeyboardEvent) => void;

method init

init: (legacyParams: ProvidedFilterParams) => void;

method isFilterActive

isFilterActive: () => boolean;

Deprecated
v34 Filters are active when they have a model. Use api.getColumnFilterModel() instead.

method onNewRowsLoaded

onNewRowsLoaded: () => void;

Deprecated
v34 Internal method - should only be called by the grid.

method onUiChanged

protected onUiChanged: (
    apply?: 'immediately' | 'debounce' | 'prevent',
    afterFloatingFilter?: boolean
) => void;

By default, if the change came from a floating filter it will be applied immediately, otherwise if there is no apply button it will be applied after a debounce, otherwise it will not be applied at all. This behaviour can be adjusted by using the apply parameter.

method postConstruct

postConstruct: () => void;

method refresh

refresh: (legacyNewParams: ProvidedFilterParams) => boolean;

method setModel

setModel: (model: M | null) => AgPromise<void>;

Deprecated
v34 Use (api.setColumnFilterModel()) instead.

method setModelIntoUi

protected abstract setModelIntoUi: (
    model: M | null,
    isInitialLoad?: boolean
) => AgPromise<void>;

method setParams

protected setParams: (params: P) => void;

Called on init only. Override in subclasses

method translate

protected translate: (
    key: FilterLocaleTextKey,
    variableValues?: string[]
) => string;

method updateParams

protected updateParams: (newParams: P, oldParams: P) => void;

Called on refresh only. Override in subclasses

method updateUiVisibility

protected abstract updateUiVisibility: () => void;

class SelectCellEditor

class SelectCellEditor<TValue = any> extends AgAbstractCellEditor<
    SelectCellEditorParams<any, TValue>,
    TValue
> {}

constructor

constructor();

property eEditor

protected readonly eEditor: GridSelect<TValue>;

method afterGuiAttached

afterGuiAttached: () => void;

method agSetEditValue

agSetEditValue: (value: TValue | null | undefined) => void;

method focusIn

focusIn: () => void;

method getValidationElement

getValidationElement: () => HTMLElement | HTMLInputElement;

method getValidationErrors

getValidationErrors: () => string[] | null;

method getValue

getValue: () => TValue | null | undefined;

method initialiseEditor

initialiseEditor: (params: SelectCellEditorParams<any, TValue>) => void;

method isPopup

isPopup: () => boolean;

method wireBeans

wireBeans: (beans: BeanCollection) => void;

class SortIndicatorComp

class SortIndicatorComp extends Component {}

constructor

constructor(skipTemplate?: boolean);

method attachCustomElements

attachCustomElements: (
    eSortOrder: HTMLElement | undefined,
    eSortAsc: HTMLElement | undefined,
    eSortDesc: HTMLElement | undefined,
    eSortMixed: HTMLElement | undefined,
    eSortNone: HTMLElement | undefined,
    eSortAbsoluteAsc: HTMLElement | undefined,
    eSortAbsoluteDesc: HTMLElement | undefined
) => void;

method refresh

refresh: () => void;

method setupSort

setupSort: (
    column: AgColumn,
    suppressOrder?: boolean,
    getSortDefOverride?: () => SortDef | null | undefined
) => void;

class TextCellEditor

class TextCellEditor extends SimpleCellEditor<
    any,
    ITextCellEditorParams,
    GridInputTextField
> {}

constructor

constructor();

class TextFilter

class TextFilter extends SimpleFilter<
    TextFilterModel,
    string,
    GridInputTextField,
    TextFilterDisplayParams
> {}

constructor

constructor();

property defaultDebounceMs

protected defaultDebounceMs: number;

property filterType

readonly filterType: string;

method areSimpleModelsEqual

protected areSimpleModelsEqual: (
    aSimple: TextFilterModel,
    bSimple: TextFilterModel
) => boolean;

method createCondition

protected createCondition: (position: number) => TextFilterModel;

method createEValue

protected createEValue: () => HTMLElement;

method getInputs

protected getInputs: (position: number) => Tuple<GridInputTextField>;

method getValues

protected getValues: (position: number) => Tuple<string>;

method removeEValues

protected removeEValues: (startPosition: number, deleteCount?: number) => void;

class TextFloatingFilter

class TextFloatingFilter extends TextInputFloatingFilter<
    ITextFloatingFilterParams,
    TextFilterModel
> {}

property defaultOptions

protected readonly defaultOptions: ISimpleFilterModelType[];

property FilterModelFormatterClass

protected readonly FilterModelFormatterClass: typeof TextFilterModelFormatter;

property filterType

protected readonly filterType: string;

method createFloatingFilterInputService

protected createFloatingFilterInputService: () => FloatingFilterInputService;

class TouchListener

class TouchListener implements IEventEmitter<TouchListenerEvent> {}

constructor

constructor(eElement: Element, preventClick?: boolean);

method addEventListener

addEventListener: <T extends TouchListenerEvent>(
    eventType: T,
    listener: IEventListener<T>
) => void;

method destroy

destroy: () => void;

method removeEventListener

removeEventListener: <T extends TouchListenerEvent>(
    eventType: T,
    listener: IEventListener<T>
) => void;

Interfaces

interface AbstractColDef

interface AbstractColDef<TData = any, TValue = any> {}

AbstractColDef can be a group or a column definition

property autoHeaderHeight

autoHeaderHeight?: boolean;

If enabled then the column header row will automatically adjust height to accommodate the size of the header cell. This can be useful when using your own headerComponent or long header names in conjunction with wrapHeaderText. false

property cellAriaRole

cellAriaRole?: string;

Used for screen reader announcements - the role property of the cells that belong to this column. 'gridcell'

property columnGroupShow

columnGroupShow?: ColumnGroupShowType;

Whether to only show the column when the group is open / closed. If not set the column is always displayed as part of the group.

property context

context?: any;

Context property that can be used to associate arbitrary application data with this column definition.

property headerClass

headerClass?: HeaderClass<TData, TValue>;

CSS class to use for the header cell. Can be a string, array of strings, or function.

property headerName

headerName?: string;

The name to render in the column header. If not specified and field is specified, the field name will be used as the header name.

property headerStyle

headerStyle?: HeaderStyle | HeaderStyleFunc<TData, TValue>;

An object of CSS values / or function returning an object of CSS values for a particular header.

property headerTooltip

headerTooltip?: string;

Tooltip for the column header, headerTooltipValueGetter takes precedence if set. TooltipModule

property headerTooltipValueGetter

headerTooltipValueGetter?: HeaderTooltipValueGetterFunc<TData, TValue>;

Callback that should return the string to use for a tooltip. TooltipModule

property headerValueGetter

headerValueGetter?: string | HeaderValueGetterFunc<TData, TValue>;

Function or expression. Gets the value for display in the header.

property pivotKeys

pivotKeys?: string[];

Never set this, it is used internally by grid when doing in-grid pivoting

property suppressColumnsToolPanel

suppressColumnsToolPanel?: boolean;

Set to true if you do not want this column or group to appear in the Columns Tool Panel. false ColumnsToolPanelModule

property suppressFiltersToolPanel

suppressFiltersToolPanel?: boolean;

Set to true if you do not want this column (filter) or group (filter group) to appear in the Filters Tool Panel. false ColumnsToolPanelModule

property suppressHeaderContextMenu

suppressHeaderContextMenu?: boolean;

Set to true to not display the column menu when the column header is right-clicked. Doesn't apply when columnMenu = 'legacy'. false

property suppressHeaderKeyboardEvent

suppressHeaderKeyboardEvent?: SuppressHeaderKeyboardEventFunc<TData, TValue>;

Suppress the grid taking action for the relevant keyboard event when a header is focused.

property toolPanelClass

toolPanelClass?: ToolPanelClass<TData, TValue>;

CSS class to use for the tool panel cell. Can be a string, array of strings, or function. ColumnsToolPanelModule

property tooltipComponent

tooltipComponent?: any;

Provide your own tooltip component for the column. See [Tooltip Component](https://www.ag-grid.com/javascript-data-grid/tooltips/) for framework specific implementation details. TooltipModule

property tooltipComponentParams

tooltipComponentParams?: any;

The params used to configure tooltipComponent. TooltipModule

property wrapHeaderText

wrapHeaderText?: boolean;

If enabled then column header names that are too long for the column width will wrap onto the next line. Default false

interface AdvancedFilterBuilderVisibleChangedEvent

interface AdvancedFilterBuilderVisibleChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'advancedFilterBuilderVisibleChanged', TData, TContext> {}

property source

source: 'api' | 'ui';

Source of the visibility status change.

property visible

visible: boolean;

True if now visible; false if now hidden.

interface AdvancedFilterEnabledChangedEvent

interface AdvancedFilterEnabledChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'advancedFilterEnabledChanged', TData, TContext> {}

property enabled

enabled: boolean;

interface AgComponentPopupPositionParams

interface AgComponentPopupPositionParams<TParams>
    extends AgPopupPositionParams<TParams> {}

property eventSource

eventSource: HTMLElement;

property type

type: string;

interface AgDragEvent

interface AgDragEvent<T extends AgEventType, TData = any, TContext = any>
    extends AgGlobalEvent<T, TData, TContext> {}

property target

target: Element;

The DOM element that started the event.

interface AgEvent

interface AgEvent<TEventType extends string = string> {}

property type

type: TEventType;

Event identifier

interface AgGlobalEvent

interface AgGlobalEvent<T extends AgEventType, TData = any, TContext = any>
    extends AgGridEvent<TData, TContext, T> {}

interface AggregationColumnState

interface AggregationColumnState {}

property aggFunc

aggFunc: string;

Only named aggregation functions can be used in state

property colId

colId: string;

interface AggregationState

interface AggregationState {}

property aggregationModel

aggregationModel: AggregationColumnState[];

interface AggregationStatusPanelParams

interface AggregationStatusPanelParams<TData = any, TContext = any>
    extends IAggregationStatusPanelParams,
        IStatusPanelParams<TData, TContext> {}

property aggFuncs

aggFuncs: AggregationStatusPanelAggFunc[];

interface AgGridCommon

interface AgGridCommon<TData, TContext> {}

property api

api: GridApi<TData>;

The grid api.

property context

context: TContext;

Application context as set on gridOptions.context.

interface AgGridEvent

interface AgGridEvent<
    TData = any,
    TContext = any,
    TEventType extends string = string
> extends AgGridCommon<TData, TContext>,
        AgEvent<TEventType> {}

interface AgMenuPopupPositionParams

interface AgMenuPopupPositionParams<TParams>
    extends BasePopupPositionParams<TParams> {}

property event

event?: MouseEvent | KeyboardEvent;

property eventSource

eventSource: HTMLElement;

interface AgMousePopupPositionParams

interface AgMousePopupPositionParams<TParams>
    extends AgPopupPositionParams<TParams> {}

property mouseEvent

mouseEvent: MouseEvent | Touch;

property type

type: string;

interface AgPopupPositionParams

interface AgPopupPositionParams<TParams> extends BasePopupPositionParams<TParams> {}

property alignSide

alignSide?: 'left' | 'right';

property keepWithinBounds

keepWithinBounds?: boolean;

property nudgeX

nudgeX?: number;

property nudgeY

nudgeY?: number;

property position

position?: 'over' | 'under';

property postProcessCallback

postProcessCallback?: () => void;

property skipObserver

skipObserver?: boolean;

property updatePosition

updatePosition?: () => {
    x: number;
    y: number;
};

interface AlignedGridColumnEvent

interface AlignedGridColumnEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'alignedGridColumn', TData, TContext> {}

property event

event: ColumnEvent<any> | ColumnGroupOpenedEvent;

interface AlignedGridScrollEvent

interface AlignedGridScrollEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'alignedGridScroll', TData, TContext> {}

property event

event: BodyScrollEvent;

interface AllChildrenCountChangedEvent

interface AllChildrenCountChangedEvent<TData = any>
    extends RowNodeEvent<'allChildrenCountChanged', TData> {}

interface ApplyColumnStateParams

interface ApplyColumnStateParams {}

property defaultState

defaultState?: ColumnStateParams;

State to apply to columns where state is missing for those columns

property state

state?: ColumnState[];

The state from getColumnState

interface AsyncTransactionsFlushed

interface AsyncTransactionsFlushed<TData = any, TContext = any>
    extends AsyncTransactionsFlushedEvent<TData, TContext> {}

Deprecated
v32 Use AsyncTransactionsFlushedEvent

interface AsyncTransactionsFlushedEvent

interface AsyncTransactionsFlushedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'asyncTransactionsFlushed', TData, TContext> {}

property results

results: (RowNodeTransaction<TData> | ServerSideTransactionResult<TData>)[];

Array of result objects. for SSRM it's always list of ServerSideTransactionResult. For Client-Side Row Model it's a list of RowNodeTransaction.

interface BaseCellEditor

interface BaseCellEditor {}

method focusIn

focusIn: () => void;

Optional: If doing full line edit, then gets called when focus should be put into the editor

method focusOut

focusOut: () => void;

Optional: If doing full line edit, then gets called when focus is leaving the editor

method getValidationElement

getValidationElement: (tooltip: boolean) => HTMLElement;

Optional: Returns the element to use for validation feedback.
Called by the grid in two contexts: - tooltip: true → used as the anchor for validation tooltips. - tooltip: false → receives the invalid CSS class for visual feedback.
If omitted, the grid falls back to the cell element for inline editors. Popup editors that do not implement this will not show validation styles or tooltips.
Parameter tooltip
Whether the element is for a tooltip or direct styling.
Returns
An HTML element for feedback, or null/undefined to use default behavior.

method getValidationErrors

getValidationErrors: () => string[] | null;

Optional: The error messages associated with the Editor

method isCancelAfterEnd

isCancelAfterEnd: () => boolean;

Optional: Gets called once after editing is complete. If your return true, then the new value will not be used. The editing will have no impact on the record. Use this if you do not want a new value from your gui, i.e. you want to cancel the editing.

method isCancelBeforeStart

isCancelBeforeStart: () => boolean;

Optional: Gets called once after initialised. If you return true, the editor will not be used and the grid will continue editing. Use this to make a decision on editing inside the init() function, eg maybe you want to only start editing if the user hits a numeric key, but not a letter, if the editor is for numbers.

interface BaseCreateChartParams

interface BaseCreateChartParams {}

property chartContainer

chartContainer?: HTMLElement;

Provide to display the chart outside the grid in your own container.

property chartThemeName

chartThemeName?: string;

The default theme to use, either a default option or your own custom theme.

property chartThemeOverrides

chartThemeOverrides?: AgChartThemeOverrides;

Allows specific chart options in the current theme to be overridden.

property unlinkChart

unlinkChart?: boolean;

When enabled the chart will be unlinked from the grid after creation, any updates to the data will not be reflected in the chart.

interface BaseDate

interface BaseDate {}

method afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen. If a parent popup is closed and reopened (e.g. for filters), this method is called each time the component is shown. This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.

method setDisabled

setDisabled: (disabled: boolean) => void;

Optional: Sets the disabled state of this component

method setInputAriaLabel

setInputAriaLabel: (placeholder: string) => void;

Optional: Sets the current input aria label

method setInputPlaceholder

setInputPlaceholder: (placeholder: string) => void;

Optional: Sets the current input placeholder

interface BaseDateParams

interface BaseDateParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property filterParams

filterParams: DateFilterParams;

property location

location?: 'filter' | 'floatingFilter';

property onFocusIn

onFocusIn?: () => void;

Method for component to tell AG Grid that an input has been focussed. Used by the grid to refresh validation messages when moving between inputs in an "inRange" filter.

interface BaseExportParams

interface BaseExportParams {}

property allColumns

allColumns?: boolean;

If true, all columns will be exported in the order they appear in the columnDefs. When false only the columns currently being displayed will be exported. false

property columnKeys

columnKeys?: (string | Column)[];

Provide a list (an array) of column keys or Column objects if you want to export specific columns.

property exportedRows

exportedRows?: 'all' | 'filteredAndSorted';

Determines whether rows are exported before being filtered and sorted. 'filteredAndSorted'

property fileName

fileName?: string | ExportFileNameGetter;

String to use as the file name or a function that returns a string.

property onlySelectedAllPages

onlySelectedAllPages?: boolean;

Only export selected rows including other pages (only makes sense when using pagination). false

property skipColumnGroupHeaders

skipColumnGroupHeaders?: boolean;

Set to true to exclude header column groups. false

property skipColumnHeaders

skipColumnHeaders?: boolean;

Set to true if you don't want to export column headers. false

property skipPinnedBottom

skipPinnedBottom?: boolean;

Set to true to suppress exporting rows pinned to the bottom of the grid. false

property skipPinnedTop

skipPinnedTop?: boolean;

Set to true to suppress exporting rows pinned to the top of the grid. false

property skipRowGroups

skipRowGroups?: boolean;

Set to true to skip row group headers if grouping rows. Only relevant when grouping rows. false

property valueFrom

valueFrom?: CellValueResolveFrom;

The source to use for getting cell values: 'data', 'batch', or 'edit'. - 'data': Returns values from the underlying row data - 'batch': Returns pending batch edit values (falls back to data if not in batch mode) - 'edit': Returns current editor values including live typing 'data'

method processCellCallback

processCellCallback: (params: ProcessCellForExportParams) => string;

A callback function invoked once per cell in the grid. Return a string value to be displayed in the export. For example this is useful for formatting date values.

method processGroupHeaderCallback

processGroupHeaderCallback: (
    params: ProcessGroupHeaderForExportParams
) => string;

A callback function invoked once per column group. Return a string to be displayed in the column group header. Note that column groups are exported by default, this option will not work with skipColumnGroupHeaders=true.

method processHeaderCallback

processHeaderCallback: (params: ProcessHeaderForExportParams) => string;

A callback function invoked once per column. Return a string to be displayed in the column header.

method processRowGroupCallback

processRowGroupCallback: (params: ProcessRowGroupForExportParams) => string;

A callback function invoked once per row group. Return a string to be displayed in the group cell.

method shouldRowBeSkipped

shouldRowBeSkipped: (params: ShouldRowBeSkippedParams) => boolean;

A callback function that will be invoked once per row in the grid. Return true to omit the row from the export.

interface BaseFilter

interface BaseFilter extends SharedFilterUi, ReadOnlyFloatingFilterParent {}

method doesFilterPass

doesFilterPass: (params: IDoesFilterPassParams) => boolean;

The grid will ask each active filter, in turn, whether each row in the grid passes. If any filter fails, then the row will be excluded from the final set. The method is provided a params object with attributes node (the rodNode the grid creates that wraps the data) and data (the data object that you provided to the grid for that row). Note that this is only called for the Client-Side Row Model, and can just return true if being used exclusively with other row models.

interface BaseFilterParams

interface BaseFilterParams<TData = any, TContext = any>
    extends SharedFilterParams<TData, TContext> {}

property rowModel

rowModel: IRowModel;

Deprecated
33.1 Use the corresponding methods on the grid API (api) instead.

interface BaseFloatingFilter

interface BaseFloatingFilter {}

method afterGuiAttached

afterGuiAttached: () => void;

Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen. This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.

interface BaseMenuItem

interface BaseMenuItem {}

method configureDefaults

configureDefaults: () => boolean | IMenuConfigParams;

Configure the default grid behaviour for this item, including styling, and mouse and keyboard interactions.
Returns
true to use all default behaviour, false to use no default behaviour (equivalent to configureDefaults not being defined), or IMenuConfigParams to choose what default behaviour to use.

method select

select: () => void;

Called when the item is selected, e.g. clicked or Enter is pressed.

interface BaseMenuItemParams

interface BaseMenuItemParams<TData = any, TContext = any>
    extends MenuItemDef,
        AgGridCommon<TData, TContext> {}

property isAnotherSubMenuOpen

isAnotherSubMenuOpen: () => boolean;

Returns true if another sub menu is open.

property level

level: number;

Level within the menu tree (starts at 0).

property openSubMenu

openSubMenu: (activateFirstItem?: boolean) => void;

Open the sub menu for this item.
Parameter activateFirstItem
If true, activate the first item in the sub menu.

property updateTooltip

updateTooltip: (tooltip?: string, shouldDisplayTooltip?: () => boolean) => void;

Updates the grid-provided tooltip this component.
Parameter tooltip
The value to be displayed by the tooltip
Parameter shouldDisplayTooltip
A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when enableBrowserTooltips={true}.

interface BaseToolPanelParams

interface BaseToolPanelParams<TData = any, TContext = any, TState = any>
    extends AgGridCommon<TData, TContext> {}

property initialState

initialState?: TState;

The tool-panel-specific initial state as provided in grid options if applicable

interface BatchEditingStartedEvent

interface BatchEditingStartedEvent<TData = any, TContext = any>
    extends BatchEditingEvent<'batchEditingStarted', TData, TContext> {}

interface BatchEditingStoppedEvent

interface BatchEditingStoppedEvent<TData = any, TContext = any>
    extends BatchEditingEvent<'batchEditingStopped', TData, TContext> {}

interface BigIntFilterModel

interface BigIntFilterModel extends ISimpleFilterModel {}

property filter

filter?: string | null;

The bigint value(s) associated with the filter. Custom filters can have no values (hence both are optional). Range filter has two values (from and to), where filter acts as a from value.

property filterTo

filterTo?: string | null;

Range filter to value.

interface BodyHeightChangedEvent

interface BodyHeightChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'bodyHeightChanged', TData, TContext> {}

interface BodyScrollEndEvent

interface BodyScrollEndEvent<TData = any, TContext = any>
    extends BaseBodyScrollEvent<'bodyScrollEnd', TData, TContext> {}

interface BodyScrollEvent

interface BodyScrollEvent<TData = any, TContext = any>
    extends BaseBodyScrollEvent<'bodyScroll', TData, TContext> {}

interface BooleanAdvancedFilterModel

interface BooleanAdvancedFilterModel {}

Represents a single filter condition for a boolean column

property colId

colId: string;

The ID of the column being filtered.

property filterType

filterType: 'boolean';

property type

type: BooleanAdvancedFilterModelType;

The filter option that is being applied.

interface BooleanDataTypeDefinition

interface BooleanDataTypeDefinition<TData = any, TContext = any>
    extends BaseDataTypeDefinition<'boolean', TData, boolean, TContext> {}

Represents a 'boolean' data type (type boolean).

interface BulkEditingStartedEvent

interface BulkEditingStartedEvent<TData = any, TContext = any>
    extends BulkEditingEvent<'bulkEditingStarted', TData, TContext> {}

interface BulkEditingStoppedEvent

interface BulkEditingStoppedEvent<TData = any, TContext = any>
    extends BulkEditingEvent<'bulkEditingStopped', TData, TContext> {}

interface CellChangedEvent

interface CellChangedEvent<TData = any> extends RowNodeEvent<'cellChanged', TData> {}

property column

column: Column;

property newValue

newValue: TData | undefined;

property oldValue

oldValue: TData | undefined;

interface CellClassParams

interface CellClassParams<TData = any, TValue = any, TContext = any>
    extends RowClassParams<TData, TContext> {}

property colDef

colDef: ColDef<TData, TValue>;

The colDef associated with the column for this cell

property column

column: Column<TValue>;

Column for this callback

property value

value: TValue | null | undefined;

The value to be rendered

interface CellClassRules

interface CellClassRules<TData = any, TValue = any, TContext = any> {}

index signature

[cssClassName: string]:
    | ((params: CellClassParams<TData, TValue, TContext>) => boolean)
    | string;

interface CellClickedEvent

interface CellClickedEvent<TData = any, TValue = any, TContext = any>
    extends CellMouseEvent<'cellClicked', TData, TValue, TContext> {}

interface CellContextMenuEvent

interface CellContextMenuEvent<TData = any, TValue = any, TContext = any>
    extends CellEvent<'cellContextMenu', TData, TValue, TContext> {}

interface CellDoubleClickedEvent

interface CellDoubleClickedEvent<TData = any, TValue = any, TContext = any>
    extends CellMouseEvent<'cellDoubleClicked', TData, TValue, TContext> {}

interface CellEditingStartedEvent

interface CellEditingStartedEvent<TData = any, TValue = any, TContext = any>
    extends CellEvent<'cellEditingStarted', TData, TValue, TContext> {}

interface CellEditingStoppedEvent

interface CellEditingStoppedEvent<TData = any, TValue = any, TContext = any>
    extends CellEvent<'cellEditingStopped', TData, TValue, TContext> {}

property newValue

newValue: TValue | null | undefined;

The value produced by the editor. This is the raw editor value, not resolved through the value getter.

property oldValue

oldValue: TValue | null | undefined;

The value of the cell before the edit.

property valueChanged

valueChanged: boolean;

Whether the value of the editor has changed.

interface CellEditorSelectorResult

interface CellEditorSelectorResult {}

property component

component?: any;

Equivalent of setting colDef.cellEditor

property params

params?: any;

Equivalent of setting colDef.cellEditorParams

popup?: boolean;

Equivalent of setting colDef.cellEditorPopup

property popupPosition

popupPosition?: 'over' | 'under';

Equivalent of setting colDef.cellEditorPopupPosition

interface CellEditRequestEvent

interface CellEditRequestEvent<TData = any, TValue = any, TContext = any>
    extends CellWithDataEvent<'cellEditRequest', TData, TValue, TContext> {}

property newValue

newValue: TValue | null | undefined;

The requested edit value. This is the raw value, not resolved through the value getter.

property oldValue

oldValue: TValue | null | undefined;

The value of the cell before the edit.

property source

source: string | undefined;

The source of the value change, e.g. 'edit', 'paste', 'undo', 'redo', 'data'.

interface CellEditValuesChangedEvent

interface CellEditValuesChangedEvent<TData = any, TValue = any, TContext = any>
    extends CellWithDataEvent<'cellEditValuesChanged', TData, TValue, TContext> {}

property newValue

newValue: TValue | null | undefined;

The pending edit value. This is the raw value, not resolved through the value getter.

property oldValue

oldValue: TValue | null | undefined;

The value of the cell before the edit.

property source

source: string | undefined;

The source of the value change, e.g. 'edit', 'paste', 'undo', 'redo', 'data'.

interface CellEvent

interface CellEvent<T extends AgEventType, TData = any, TValue = any, TContext = any>
    extends RowEvent<T, TData, TContext> {}

------------

property colDef

colDef: ColDef<TData, TValue>;

property column

column: Column<TValue>;

property value

value: TValue | null | undefined;

The value for the cell if available otherwise undefined.

interface CellFocusClearedEvent

interface CellFocusClearedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'cellFocusCleared', TData, TContext>,
        CellFocusClearedParams {}

interface CellFocusClearedParams

interface CellFocusClearedParams extends CommonCellFocusParams {}

interface CellFocusedEvent

interface CellFocusedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'cellFocused', TData, TContext>,
        CellFocusedParams {}

interface CellFocusedParams

interface CellFocusedParams extends CommonCellFocusParams {}

property forceBrowserFocus

forceBrowserFocus?: boolean;

Whether browser focus is also set (false when editing)

property preventScrollOnBrowserFocus

preventScrollOnBrowserFocus?: boolean;

When forceBrowserFocus is true, should scroll be prevented

interface CellKeyDownEvent

interface CellKeyDownEvent<TData = any, TValue = any, TContext = any>
    extends CellEvent<'cellKeyDown', TData, TValue, TContext> {}

interface CellMouseDownEvent

interface CellMouseDownEvent<TData = any, TValue = any, TContext = any>
    extends CellMouseEvent<'cellMouseDown', TData, TValue, TContext> {}

interface CellMouseOutEvent

interface CellMouseOutEvent<TData = any, TValue = any, TContext = any>
    extends CellEvent<'cellMouseOut', TData, TValue, TContext> {}

interface CellMouseOverEvent

interface CellMouseOverEvent<TData = any, TValue = any, TContext = any>
    extends CellEvent<'cellMouseOver', TData, TValue, TContext> {}

interface CellPosition

interface CellPosition extends RowPosition {}

property column

column: Column;

The grid column

interface CellRange

interface CellRange {}

Describes a single range of cells

property colorClass

colorClass?: string | null;

A custom color class to be applied to this range

property columns

columns: Column[];

The columns in the range

property endRow

endRow?: RowPosition;

The end row of the range

property id

id?: string;

property startRow

startRow?: RowPosition;

The start row of the range

property type

type?: CellRangeType;

interface CellRangeBoundaryParams

interface CellRangeBoundaryParams {}

property boundary

boundary: 'start' | 'end';

property cellPosition

cellPosition: CellPosition;

property cellRange

cellRange: CellRange;

property silent

silent?: boolean;

interface CellRangeParams

interface CellRangeParams {}

property columns

columns?: (string | Column)[];

Specify Columns to include instead of using columnStart and columnEnd

property rowEndPinned

rowEndPinned?: RowPinnedType;

Pinned state of end row. Either 'top', 'bottom' or null

property rowStartPinned

rowStartPinned?: RowPinnedType;

Pinned state of start row. Either 'top', 'bottom' or null

interface CellRendererDeferParams

interface CellRendererDeferParams {}

property deferRender

deferRender?: boolean;

Defer the rendering of the cell component

interface CellRendererSelectorResult

interface CellRendererSelectorResult {}

property component

component?: any;

Equivalent of setting colDef.cellRenderer

property params

params?: any;

Equivalent of setting colDef.cellRendererParams

interface CellSelectionCellState

interface CellSelectionCellState {}

property colIds

colIds: string[];

The columns in the range

property endRow

endRow?: RowPosition;

The end row of the range

property id

id?: string;

property startRow

startRow?: RowPosition;

The start row of the range

property type

type?: CellRangeType;

interface CellSelectionChangedEvent

interface CellSelectionChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'cellSelectionChanged', TData, TContext> {}

property finished

finished: boolean;

True for the last change event, otherwise false

property id

id?: string;

property started

started: boolean;

True for the first change event, otherwise false

interface CellSelectionDeleteEndEvent

interface CellSelectionDeleteEndEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'cellSelectionDeleteEnd', TData, TContext> {}

property source

source: 'deleteKey';

interface CellSelectionDeleteStartEvent

interface CellSelectionDeleteStartEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'cellSelectionDeleteStart', TData, TContext> {}

property source

source: 'deleteKey';

interface CellSelectionOptions

interface CellSelectionOptions<TData = any> {}

Cell selection options

property enableColumnSelection

enableColumnSelection?: boolean;

If true, allows selection of a column of cells when clicking the column header. false

property enableHeaderHighlight

enableHeaderHighlight?: boolean;

If true the header of cells containing ranges will be highlighted. false;

property handle

handle?: RangeHandleOptions | FillHandleOptions<TData>;

Determine the selection handle behaviour. Can be used to configure the range handle and the fill handle.

property suppressMultiRanges

suppressMultiRanges?: boolean;

If true, only a single range can be selected false

interface CellSelectionState

interface CellSelectionState {}

property cellRanges

cellRanges: CellSelectionCellState[];

interface CellStyle

interface CellStyle {}

index signature

[cssProperty: string]: string | number;

interface CellValueChangedEvent

interface CellValueChangedEvent<
    TData = any,
    TValue = any,
    TContext = any,
    TRawValue = any
> extends CellWithDataEvent<'cellValueChanged', TData, TValue, TContext> {}

property newRawValue

newRawValue: TRawValue | null | undefined;

The raw value from the edit, before any value getter is applied.

property newValue

newValue: TValue | null | undefined;

The new value of the cell after the edit, resolved through the value getter if one is configured.

property oldValue

oldValue: TValue | null | undefined;

The value of the cell before the edit.

property source

source: string | undefined;

The source of the value change, e.g. 'edit', 'paste', 'undo', 'redo', 'data'.

interface ChartCreated

interface ChartCreated<TData = any, TContext = any>
    extends ChartCreatedEvent<TData, TContext> {}

Deprecated
v32 Use ChartCreatedEvent instead

interface ChartCreatedEvent

interface ChartCreatedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'chartCreated', TData, TContext> {}

property chartId

chartId: string;

Id of the created chart. This can later be used to reference the chart via api methods.

property groups

groups?: ChartPanelGroupDef<ChartDataPanelGroup>[];

The set up panel group configurations, their order and whether they are shown. If not specified shows all groups

interface ChartDestroyed

interface ChartDestroyed<TData = any, TContext = any>
    extends ChartDestroyedEvent<TData, TContext> {}

Deprecated
v32 Use ChartDestroyedEvent instead

interface ChartDestroyedEvent

interface ChartDestroyedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'chartDestroyed', TData, TContext> {}

property chartId

chartId: string;

Id of the effected chart.

interface ChartDownloadParams

interface ChartDownloadParams {}

property chartId

chartId: string;

The id of the created chart.

property dimensions

dimensions?: {
    width: number;
    height: number;
};

Dimensions of downloaded chart image in pixels. The current chart dimensions will be used if not specified.

property fileFormat

fileFormat?: string;

A string indicating the image format. The default format type is image/png. Options: image/png, image/jpeg

property fileName

fileName?: string;

Name of downloaded image file. The chart title will be used by default

property groups

groups?: ChartPanelGroupDef<ChartFormatPanelGroup>[];

The customize panel group configurations, their order and whether they are shown. If not specified shows all groups

interface ChartGroupsDef

interface ChartGroupsDef {}

property areaGroup

areaGroup?: ('area' | 'stackedArea' | 'normalizedArea')[];

property barGroup

barGroup?: ('bar' | 'stackedBar' | 'normalizedBar')[];

property columnGroup

columnGroup?: ('column' | 'stackedColumn' | 'normalizedColumn')[];

property combinationGroup

combinationGroup?: ('columnLineCombo' | 'areaColumnCombo' | 'customCombo')[];

property funnelGroup

funnelGroup?: ('funnel' | 'coneFunnel' | 'pyramid')[];

property hierarchicalGroup

hierarchicalGroup?: ('treemap' | 'sunburst')[];

property lineGroup

lineGroup?: ('line' | 'stackedLine' | 'normalizedLine')[];

property pieGroup

pieGroup?: ('pie' | 'donut' | 'doughnut')[];

property polarGroup

polarGroup?: (
    | 'radarLine'
    | 'radarArea'
    | 'nightingale'
    | 'radialColumn'
    | 'radialBar'
)[];

property scatterGroup

scatterGroup?: ('scatter' | 'bubble')[];

property specializedGroup

specializedGroup?: ('heatmap' | 'waterfall')[];

property statisticalGroup

statisticalGroup?: ('boxPlot' | 'histogram' | 'rangeBar' | 'rangeArea')[];

interface ChartModel

interface ChartModel {}

property aggFunc

aggFunc?: string | IAggFunc;

property cellRange

cellRange: CellRangeParams;

property chartId

chartId: string;

property chartOptions

chartOptions: AgChartThemeOverrides;

property chartPalette

chartPalette?: AgChartThemePalette;

property chartThemeName

chartThemeName?: string;

property chartType

chartType: ChartType;

property modelType

modelType: ChartModelType;

property seriesChartTypes

seriesChartTypes?: SeriesChartType[];

property seriesGroupType

seriesGroupType?: SeriesGroupType;

property suppressChartRanges

suppressChartRanges?: boolean;

property switchCategorySeries

switchCategorySeries?: boolean;

property unlinkChart

unlinkChart?: boolean;

property useGroupColumnAsCategory

useGroupColumnAsCategory?: boolean;

property version

version?: string;

interface ChartOptionsChanged

interface ChartOptionsChanged<TData = any, TContext = any>
    extends ChartOptionsChangedEvent<TData, TContext> {}

Deprecated
v32 Use ChartOptionsChangedEvent instead

interface ChartOptionsChangedEvent

interface ChartOptionsChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'chartOptionsChanged', TData, TContext> {}

property chartId

chartId: string;

Id of the effected chart.

property chartThemeName

chartThemeName: string;

Chart theme name of currently selected theme.

interface ChartPanelGroupDef

interface ChartPanelGroupDef<GroupType> {}

property isOpen

isOpen?: boolean;

Whether the panel group is open by default. If not specified, it is closed

property type

type: GroupType;

The panel group type

interface ChartRangeSelectionChanged

interface ChartRangeSelectionChanged<TData = any, TContext = any>
    extends ChartRangeSelectionChangedEvent<TData, TContext> {}

Deprecated
v32 Use ChartRangeSelectionChangedEvent instead

interface ChartRangeSelectionChangedEvent

interface ChartRangeSelectionChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'chartRangeSelectionChanged', TData, TContext> {}

property chartId

chartId: string;

Id of the effected chart.

property id

id: string;

Same as chartId.

interface ChartRef

interface ChartRef {}

property chart

chart: any;

The chart instance that is produced by AG Charts which can be used to interact with the chart directly.

property chartElement

chartElement: HTMLElement;

The chart DOM element, which the application is responsible for placing into the DOM.

property chartId

chartId: string;

The id of the created chart.

property destroyChart

destroyChart: () => void;

The application is responsible for calling this when the chart is no longer needed.

property focusChart

focusChart: () => void;

Focuses the chart. If opening the dialog via the API, the chart is not focused by default, and this method can be used.

property setMaximized

setMaximized: (maximized: boolean) => void;

If opening the chart in a dialog, sets the maximized status of the dialog, else does nothing.

interface ChartRefParams

interface ChartRefParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext>,
        ChartRef {}

property chartGroupsDef

chartGroupsDef?: ChartGroupsDef;

Chart groups customisations for which charts are displayed in the chart panel

interface ChartTitleEditEvent

interface ChartTitleEditEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'chartTitleEdit', TData, TContext> {}

interface ChartToolPanelsDef

interface ChartToolPanelsDef {}

property defaultToolPanel

defaultToolPanel?: ChartToolPanelName;

The panel to open by default when the chart loads. If none specified, the tool panel is hidden by default and the first panel is open when triggered.

property panels

panels?: ChartToolPanelName[];

The ordered list of panels to show in the chart tool panels. If none specified, all panels are shown

property settingsPanel

settingsPanel?: ChartSettingsPanel;

Customisations for the chart panel and chart menu items in the Context Menu.

interface CheckboxChangedEvent

interface CheckboxChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'checkboxChanged', TData, TContext> {}

property id

id: string;

property name

name: string;

property previousValue

previousValue: boolean | undefined;

property selected

selected?: boolean;

interface CheckboxSelectionCallbackParams

interface CheckboxSelectionCallbackParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

interface ChildIndexChangedEvent

interface ChildIndexChangedEvent<TData = any>
    extends RowNodeEvent<'childIndexChanged', TData> {}

Deprecated
v33 Use the modelUpdated event instead and calculate whether the child index has changed.

interface ClearCellRangeParams

interface ClearCellRangeParams {}

property cellEventSource

cellEventSource?: string;

Source passed to cellValueChanged event

property cellRanges

cellRanges?: CellRange[];

property dispatchWrapperEvents

dispatchWrapperEvents?: boolean;

true to dispatch cellSelectionDeleteStart and cellSelectionDeleteEnd events

property restoreSourceInBatch

restoreSourceInBatch?: boolean;

When true and in batch editing mode, cells with pending edits are restored to their original sourceValue instead of being cleared to deleteValue. This is used by fill-handle reduction to undo a fill rather than clearing cells.

property wrapperEventSource

wrapperEventSource?: 'deleteKey';

Source passed to cellSelectionDeleteStart and cellSelectionDeleteEnd events

interface CloseChartToolPanelParams

interface CloseChartToolPanelParams {}

property chartId

chartId: string;

The id of the created chart.

interface ColDef

interface ColDef<TData = any, TValue = any>
    extends AbstractColDef<TData, TValue>,
        IFilterDef {}

Configuration options for columns in AG Grid.

property aggFunc

aggFunc?: string | IAggFunc<TData, TValue> | null;

Name of function to use for aggregation. In-built options are: sum, min, max, count, avg, first, last. Also accepts a custom aggregation name or an aggregation function. RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property allowedAggFuncs

allowedAggFuncs?: string[];

Aggregation functions allowed on this column e.g. ['sum', 'avg']. If missing, all installed functions are allowed. This will only restrict what the GUI allows a user to select, it does not impact when you set a function via the API. RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property allowFormula

allowFormula?: boolean;

Allow formulas to be entered and evaluated in this column. false FormulaModule

property autoHeight

autoHeight?: boolean;

Set to true to have the grid calculate the height of a row based on contents of this column. false RowAutoHeightModule

property cellClass

cellClass?: string | string[] | CellClassFunc<TData, TValue>;

Class to use for the cell. Can be string, array of strings, or function that returns a string or array of strings. CellStyleModule

property cellClassRules

cellClassRules?: CellClassRules<TData, TValue>;

Rules which can be applied to include certain CSS classes. CellStyleModule

property cellDataType

cellDataType?: boolean | string;

The data type of the cell values for this column. Can either infer the data type from the row data (true - the default behaviour), define a specific data type (string), or have no data type (false).
If setting a specific data type (string value), this can either be one of the pre-defined data types 'text', 'number', 'boolean', 'date', 'dateString' or 'object', or a custom data type that has been defined in the dataTypeDefinitions grid option.
Data type inference only works for the Client-Side Row Model, and requires non-null data. It will also not work if the valueGetter, valueParser or refData properties are defined, or if this column is a sparkline.
true

property cellEditor

cellEditor?: any;

Provide your own cell editor component for this column's cells.

property cellEditorParams

cellEditorParams?: any;

Params to be passed to the cellEditor component.

property cellEditorPopup

cellEditorPopup?: boolean;

Set to true, to have the cell editor appear in a popup.

property cellEditorPopupPosition

cellEditorPopupPosition?: 'over' | 'under';

Set the position for the popup cell editor. Possible values are - over Popup will be positioned over the cell - under Popup will be positioned below the cell leaving the cell value visible.
'over'

property cellEditorSelector

cellEditorSelector?: CellEditorSelectorFunc<TData, TValue>;

Callback to select which cell editor to be used for a given row within the same column.

property cellRenderer

cellRenderer?: any;

Provide your own cell Renderer component for this column's cells. See [Cell Renderer](https://www.ag-grid.com/javascript-data-grid/component-cell-renderer/) for framework specific implementation details.

property cellRendererParams

cellRendererParams?: any;

Params to be passed to the cellRenderer component.

property cellRendererSelector

cellRendererSelector?: CellRendererSelectorFunc<TData, TValue>;

Callback to select which cell renderer to be used for a given row within the same column.

property cellStyle

cellStyle?: CellStyle | CellStyleFunc<TData, TValue>;

An object of CSS values / or function returning an object of CSS values for a particular cell. CellStyleModule

property chartDataType

chartDataType?: 'category' | 'series' | 'time' | 'excluded';

Defines the chart data type that should be used for a column. IntegratedChartsModule

property checkboxSelection

checkboxSelection?: boolean | CheckboxSelectionCallback<TData, TValue>;

Deprecated
v32.2 Use the new selection API instead. See GridOptions.rowSelection
Set to true (or return true from function) to render a selection checkbox in the column. false

property colId

colId?: string;

The unique ID to give the column. This is optional. If missing, the ID will default to the field. If both field and colId are missing, a unique ID will be generated. This ID is used to identify the column in the API for sorting, filtering etc.

property colSpan

colSpan?: ColSpanFunc<TData, TValue>;

By default, each cell will take up the width of one column. You can change this behaviour to allow cells to span multiple columns.

property columnChooserParams

columnChooserParams?: ColumnChooserParams;

Params used to change the behaviour and appearance of the Column Chooser/Columns Menu tab. ColumnMenuModule

property comparator

comparator?:
    | SortComparatorFn<TData, TValue>
    | Partial<Record<SortType, SortComparatorFn<TData, TValue>>>;

Override the default sorting order by providing a custom sort comparator, or a map of comparators for different SortTypes.
- valueA, valueB are the values to compare. - nodeA, nodeB are the corresponding RowNodes. Useful if additional details are required by the sort. - isDescending - true if sort direction is desc. Not to be used for inverting the return value as the grid already applies asc or desc ordering.
Returns: - 0 valueA is the same as valueB - > 0 Sort valueA after valueB - < 0 Sort valueA before valueB

property contextMenuItems

contextMenuItems?:
    | (DefaultMenuItem | MenuItemDef<TData>)[]
    | GetContextMenuItems<TData>;

Customise the list of menu items available in the context menu. ContextMenuModule

property dateComponent

dateComponent?: any;

Custom date selection component to be used in Date Filters and Date Floating Filters for this column. See [Custom Selection Component](https://www.ag-grid.com/javascript-data-grid/filter-date/#custom-selection-component) for framework specific implementation detail.

property dateComponentParams

dateComponentParams?: any;

The parameters to be passed to the dateComponent.

property defaultAggFunc

defaultAggFunc?: string;

The name of the aggregation function to use for this column when it is enabled via the GUI. Note that this does not immediately apply the aggregation function like aggFunc 'sum' RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property dndSource

dndSource?: boolean | DndSourceCallback<TData, TValue>;

boolean or Function. Set to true (or return true from function) to allow dragging for native drag and drop. false DragAndDropModule

property dndSourceOnRowDrag

dndSourceOnRowDrag?: DndSourceOnRowDragFunc<TData>;

Function to allow custom drag functionality for native drag and drop. DragAndDropModule

property editable

editable?: boolean | EditableCallback<TData, TValue>;

Set to true if this column is editable, otherwise false. Can also be a function to have different rows editable. When grouping, see groupRowEditable instead for group rows. false

property enableCellChangeFlash

enableCellChangeFlash?: boolean;

Set to true to flash a cell when it's refreshed. false HighlightChangesModule

property enablePivot

enablePivot?: boolean;

Set to true if you want to be able to pivot by this column via the GUI. This will not block the API or properties being used to achieve pivot. false PivotModule

property enableRowGroup

enableRowGroup?: boolean;

Set to true if you want to be able to row group by this column via the GUI. This will not block the API or properties being used to achieve row grouping. false RowGroupingModule

property enableValue

enableValue?: boolean;

Set to true if you want to be able to aggregate by this column via the GUI. This will not block the API or properties being used to achieve aggregation. false RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property equals

equals?: EqualsFunc<TValue>;

Custom comparator for values, used by renderer to know if values have changed. Cells whose values have not changed don't get refreshed. By default the grid uses === which should work for most use cases.

property field

field?: ColDefField<TData, TValue>;

The field of the row object to get the cell's data from. Deep references into a row object is supported via dot notation, i.e 'address.firstLine'.

property filterValueGetter

filterValueGetter?: string | ValueGetterFunc<TData>;

Function or expression. Gets the value for filtering purposes.

property flex

flex?: number | null;

Equivalent to flex-grow in CSS. When flex is set on one or more columns, any width value is ignored and instead the remaining free space in the grid is divided among flex columns in proportion to their flex value, so a column with flex: 2 will be twice the size as one with flex: 1.

property floatingFilter

floatingFilter?: boolean;

Whether to display a floating filter for this column. false

property getFindText

getFindText?: GetFindTextFunc<TData, TValue>;

When using Find with custom cell renderers, this allows providing a custom value to search within. E.g. if the cell renderer is displaying text that is different from the cell formatted value. Returning null means Find will not search within the cell. FindModule

property getQuickFilterText

getQuickFilterText?: GetQuickFilterText<TData, TValue>;

A function to tell the grid what Quick Filter text to use for this column if you don't want to use the default (which is calling toString on the value). QuickFilterModule

property groupHierarchy

groupHierarchy?: (GroupHierarchyParts | string | ColDef<TData, TValue>)[];

Specify a grouping hierarchy for this column. This generates one or more virtual columns to group or pivot by when this column is grouped or pivoted.
This can be used to group/pivot by values derived from a source column. The grid provides hierarchy types related to date components. Users can provide their own hierarchy types by specifying a ColDef, or referring to the name of a hierarchy type defined in groupHierarchyConfig. RowGroupingModule / PivotModule

property groupRowEditable

groupRowEditable?: boolean | GroupRowEditableCallback<TData, TValue>;

Works like editable, but is evaluated only for group rows. When provided, group rows use this property instead of editable. Set to true to make group row cells editable, or use a callback to control editability per row.
When groupRowEditable is defined and no explicit groupRowValueSetter is provided, the built-in distributeGroupValue is used automatically.
Columns with groupRowEditable or groupRowValueSetter do not require field or valueSetter — the group row value setter handles the edit entirely.
Note: if groupRowValueSetter resolves to false or null (via distribution: false, a per-aggFunc record entry, or groupRowValueSetter: false), the cell is treated as not editable even when groupRowEditable is true.
RowGroupingEditModule

property groupRowValueSetter

groupRowValueSetter?:
    | boolean
    | GroupRowValueSetterFunc<TData, TValue>
    | GroupRowValueSetterOptions<TData, TValue>;

Controls how a group row value edit is distributed to descendant rows.
- **true**: Uses the built-in distributeGroupValue with default settings. Also enabled implicitly when groupRowEditable is defined and groupRowValueSetter is not set. - **false**: Explicitly disables group row value distribution and makes the cell not editable, even if groupRowEditable is defined. - **Function**: A custom callback that receives a GroupRowValueSetterParams and pushes edits down to descendants. The column does not need field or valueSetter — the callback handles the edit entirely. - **Options object**: Uses the built-in distribution logic with a GroupRowValueSetterOptions configuration. When distribution resolves to false or null for the column's aggFunc, the cell is treated as not editable (overriding groupRowEditable).
Fires for every setDataValue call when active, regardless of groupRowEditable.
RowGroupingEditModule

property headerCheckboxSelection

headerCheckboxSelection?:
    | boolean
    | HeaderCheckboxSelectionCallback<TData, TValue>;

Deprecated
v32.2 Use the new selection API instead. See GridOptions.rowSelection
If true or the callback returns true, a 'select all' checkbox will be put into the header.

property headerCheckboxSelectionCurrentPageOnly

headerCheckboxSelectionCurrentPageOnly?: boolean;

Deprecated
v32.2 Use the new selection API instead. See GridOptions.rowSelection
If true, the header checkbox selection will only select nodes on the current page. false

property headerCheckboxSelectionFilteredOnly

headerCheckboxSelectionFilteredOnly?: boolean;

Deprecated
v32.2 Use the new selection API instead. See GridOptions.rowSelection
If true, the header checkbox selection will only select filtered items. false

property headerComponent

headerComponent?: any;

The custom header component to be used for rendering the component header. If none specified the default AG Grid header component is used. See [Header Component](https://www.ag-grid.com/javascript-data-grid/component-header/) for framework specific implementation detail.

property headerComponentParams

headerComponentParams?: any;

The parameters to be passed to the headerComponent.

property hide

hide?: boolean | null;

Set to true for this column to be hidden. false

property icons

icons?: Icons;

Icons to use inside the column instead of the grid's default icons. Leave undefined to use defaults.

property initialAggFunc

initialAggFunc?: string | IAggFunc<TData, TValue>;

Same as aggFunc, except only applied when creating a new column. Not applied when updating column definitions. RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property initialFlex

initialFlex?: number;

Same as flex, except only applied when creating a new column. Not applied when updating column definitions.

property initialHide

initialHide?: boolean;

Same as hide, except only applied when creating a new column. Not applied when updating column definitions.

property initialPinned

initialPinned?: boolean | 'left' | 'right';

Same as pinned, except only applied when creating a new column. Not applied when updating column definitions.

property initialPivot

initialPivot?: boolean;

Same as pivot, except only applied when creating a new column. Not applied when updating column definitions. PivotModule

property initialPivotIndex

initialPivotIndex?: number;

Same as pivotIndex, except only applied when creating a new column. Not applied when updating column definitions. PivotModule

property initialRowGroup

initialRowGroup?: boolean;

Same as rowGroup, except only applied when creating a new column. Not applied when updating column definitions. RowGroupingModule

property initialRowGroupIndex

initialRowGroupIndex?: number;

Same as rowGroupIndex, except only applied when creating a new column. Not applied when updating column definitions. RowGroupingModule

property initialSort

initialSort?: SortDirection | SortDef;

Same as sort, except only applied when creating a new column. Not applied when updating column definitions.

property initialSortIndex

initialSortIndex?: number;

Same as sortIndex, except only applied when creating a new column. Not applied when updating column definitions.

property initialWidth

initialWidth?: number;

Same as width, except only applied when creating a new column. Not applied when updating column definitions.

property keyCreator

keyCreator?: KeyCreatorFunc<TData, TValue>;

Function to return a string key for a value. This string is used for grouping, Set filtering, and searching within cell editor dropdowns. When filtering and searching the string is exposed to the user, so make sure to return a human-readable value.

property loadingCellRenderer

loadingCellRenderer?: any;

The renderer to be used while either - using Server Side Row Model and the row is in an unloaded state and if suppressServerSideFullWidthLoadingRow or groupHideOpenParents is enabled. - a cell renderer is marked for deferred loading with cellRendererParams.deferRender:true.

property loadingCellRendererParams

loadingCellRendererParams?: any;

Params to be passed to the loadingCellRenderer component.

property loadingCellRendererSelector

loadingCellRendererSelector?: ILoadingCellRendererSelectorFunc<TData, TValue>;

Callback to select which loading renderer to be used.

property lockPinned

lockPinned?: boolean;

Set to true to block the user pinning the column, the column can only be pinned via definitions or API. false

property lockPosition

lockPosition?: boolean | 'left' | 'right';

Lock a column to position to 'left' or'right' to always have this column displayed in that position. true is treated as 'left'

property lockVisible

lockVisible?: boolean;

Set to true to block making column visible / hidden via the UI (API will still work). false

property mainMenuItems

mainMenuItems?:
    | (DefaultMenuItem | MenuItemDef<TData>)[]
    | GetMainMenuItems<TData>;

Customise the list of menu items available in the column menu. ColumnMenuModule

property maxWidth

maxWidth?: number;

Maximum width in pixels for the cell.

property menuTabs

menuTabs?: ColumnMenuTab[];

Set to an array containing zero, one or many of the following options: 'filterMenuTab' | 'generalMenuTab' | 'columnsMenuTab'. This is used to figure out which menu tabs are present and in which order the tabs are shown.

property minWidth

minWidth?: number;

Minimum width in pixels for the cell.

property onCellContextMenu

onCellContextMenu?: (event: CellContextMenuEvent<TData, TValue>) => void;

Callback called when a cell is right clicked.

property onCellDoubleClicked

onCellDoubleClicked?: (event: CellDoubleClickedEvent<TData, TValue>) => void;

Callback called when a cell is double clicked.

property onCellValueChanged

onCellValueChanged?: (event: NewValueParams<TData, TValue>) => void;

Callback for after the value of a cell has changed, either due to editing or the application calling api.setValue().

property pinned

pinned?: boolean | 'left' | 'right' | null;

Pin a column to one side: right or left. A value of true is converted to 'left'.

property pivot

pivot?: boolean | null;

Set to true to pivot by this column. PivotModule

property pivotComparator

pivotComparator?: PivotComparatorFunc;

Only for CSRM, see [SSRM Pivoting](https://www.ag-grid.com/javascript-data-grid/server-side-model-pivoting/).
Comparator to use when ordering the pivot columns, when this column is used to pivot on. The values will always be strings, as the pivot service uses strings as keys for the pivot groups. PivotModule

property pivotIndex

pivotIndex?: number | null;

Set this in columns you want to pivot by. If only pivoting by one column, set this to any number (e.g. 0). If pivoting by multiple columns, set this to where you want this column to be in the order of pivots (e.g. 0 for first, 1 for second, and so on). PivotModule

property pivotTotalColumnIds

pivotTotalColumnIds?: string[];

Never set this, it is used internally by grid when doing in-grid pivoting

property pivotValueColumn

pivotValueColumn?: Column | null;

Never set this, it is used internally by grid when doing in-grid pivoting

property refData

refData?: RefData;

Provided a reference data map to be used to map column values to their respective value from the map.

property resizable

resizable?: boolean;

Set to false to disable resizing which is enabled by default. true

property rowDrag

rowDrag?: boolean | RowDragCallback<TData, TValue>;

boolean or Function. Set to true (or return true from function) to allow row dragging. false RowDragModule

property rowDragText

rowDragText?: RowDragTextFunc;

A callback that should return a string to be displayed by the rowDragComp while dragging a row. If this callback is not set, the rowDragText callback in the gridOptions will be used and if there is no callback in the gridOptions the current cell value will be used. RowDragModule

property rowGroup

rowGroup?: boolean | null;

Set to true to row group by this column. false RowGroupingModule

property rowGroupIndex

rowGroupIndex?: number | null;

Set this in columns you want to group by. If only grouping by one column, set this to any number (e.g. 0). If grouping by multiple columns, set this to where you want this column to be in the group (e.g. 0 for first, 1 for second, and so on). RowGroupingModule

property rowGroupingHierarchy

rowGroupingHierarchy?: (GroupHierarchyParts | string | ColDef<TData, TValue>)[];

Specify a grouping hierarchy for this column. This generates one or more virtual columns to group or pivot by when this column is grouped or pivoted.
This can be used to group/pivot by values derived from a source column. The grid provides hierarchy types related to date components. Users can provide their own hierarchy types by specifying a ColDef, or referring to the name of a hierarchy type defined in groupHierarchyConfig. RowGroupingModule / PivotModule
Deprecated

property rowSpan

rowSpan?: RowSpanFunc<TData, TValue>;

By default, each cell will take up the height of one row. You can change this behaviour to allow cells to span multiple rows.

property showDisabledCheckboxes

showDisabledCheckboxes?: boolean;

Deprecated
v32.2 Use the new selection API instead. See GridOptions.rowSelection
Set to true to display a disabled checkbox when row is not selectable and checkboxes are enabled. false

property showRowGroup

showRowGroup?: string | boolean;

Set to true to have the grid place the values for the group into the cell, or put the name of a grouped column to just show that group. RowGroupingModule

property singleClickEdit

singleClickEdit?: boolean;

Set to true to have cells under this column enter edit mode after single click. false

property sort

sort?: SortDirection | SortDef;

Set the default sort.

property sortable

sortable?: boolean;

Set to false to disable sorting which is enabled by default. true

property sortIndex

sortIndex?: number | null;

If sorting more than one column by default, specifies order in which the sorting should be applied.

property sortingOrder

sortingOrder?: (SortDirection | SortDef)[];

An array defining the order in which sorting occurs (if sorting is enabled). Defaults:
- ['asc', 'desc', null] if no sort type is specified, - [{ type: 'absolute', direction: 'asc', }, { type: 'absolute', direction: 'desc' }, null] if 'sort' or 'initialSort' have type 'absolute'

property spanRows

spanRows?: boolean | SpanRowsFunc<TData, TValue>;

Set to true to automatically merge cells in this column with equal values. Provide a callback to specify custom merging logic. CellSpanModule

property suppressAutoSize

suppressAutoSize?: boolean;

Set to true if you do not want this column to be auto-resizable during 'size to contents' operations. false

property suppressFillHandle

suppressFillHandle?: boolean;

Set to true to prevent the fillHandle from being rendered in any cell that belongs to this column

property suppressFloatingFilterButton

suppressFloatingFilterButton?: boolean;

If true, the button in the floating filter that opens the parent filter in a popup will not be displayed. Only applies if floatingFilter = true.

property suppressHeaderFilterButton

suppressHeaderFilterButton?: boolean;

Set to true to not display the filter button in the column header. Doesn't apply when columnMenu = 'legacy'. false

property suppressHeaderMenuButton

suppressHeaderMenuButton?: boolean;

Set to true if no menu button should be shown for this column header. false

property suppressKeyboardEvent

suppressKeyboardEvent?: SuppressKeyboardEventFunc<TData, TValue>;

Allows the user to suppress certain keyboard events in the grid cell. false

property suppressMovable

suppressMovable?: boolean;

Set to true if you do not want this column to be movable via dragging. false

property suppressNavigable

suppressNavigable?: boolean | SuppressNavigableCallback<TData, TValue>;

Set to true if this column is not navigable (i.e. cannot be tabbed into), otherwise false. Can also be a callback function to have different rows navigable. false

property suppressNoteActions

suppressNoteActions?: boolean | SuppressNoteActionsCallback<TData, TValue>;

Set to true to suppress built-in note actions for this column. Existing notes remain viewable on hover and through getNote(). Can also be a callback function to suppress notes for specific rows. false NotesModule

property suppressPaste

suppressPaste?: boolean | SuppressPasteCallback<TData, TValue>;

Pasting is on by default as long as cells are editable (non-editable cells cannot be modified, even with a paste operation). Set to true turn paste operations off.

property suppressSizeToFit

suppressSizeToFit?: boolean;

Set to true if you want this column's width to be fixed during 'size to fit' operations. false

property suppressSpanHeaderHeight

suppressSpanHeaderHeight?: boolean;

Set to true if you don't want the column header for this column to span the whole height of the header container. false

property tooltipComponentSelector

tooltipComponentSelector?: CellEditorSelectorFunc | CellRendererSelectorFunc;

Callback to select which tooltip component to be used for a given row within the same column. TooltipModule

property tooltipField

tooltipField?: ColDefField<TData>;

The field of the tooltip to apply to the cell. TooltipModule

property tooltipValueGetter

tooltipValueGetter?: TooltipValueGetterFunc<TData, TValue>;

Callback that should return the string to use for a tooltip, tooltipField takes precedence if set. If using a custom tooltipComponent you may return any custom value to be passed to your tooltip component. TooltipModule

property type

type?: string | string[];

A comma separated string or array of strings containing ColumnType keys which can be used as a template for a column. This helps to reduce duplication of properties when you have a lot of common column properties.

property unSortIcon

unSortIcon?: boolean;

Set to true if you want the unsorted icon to be shown when no sort is applied to this column. false

property useValueFormatterForExport

useValueFormatterForExport?: boolean;

By default, values are formatted using the column's valueFormatter when exporting data from the grid. This applies to CSV and Excel export, as well as clipboard operations and the fill handle. Set to false to prevent values from being formatted for these operations. Regardless of this option, if custom handling is provided for the export operation, the value formatter will not be used. true

property useValueParserForImport

useValueParserForImport?: boolean;

By default, values are parsed using the column's valueParser when importing data to the grid. This applies to clipboard operations and the fill handle. Set to false to prevent values from being parsed for these operations. Regardless of this option, if custom handling is provided for the import operation, the value parser will not be used. true

property valueFormatter

valueFormatter?: string | ValueFormatterFunc<TData, TValue>;

A function or expression to format a value, should return a string.

property valueGetter

valueGetter?: string | ValueGetterFunc<TData, TValue>;

Function or expression. Gets the value from your data for display.

property valueParser

valueParser?: string | ValueParserFunc<TData, TValue>;

Function or expression. Parses the value for saving.

property valueSetter

valueSetter?: string | ValueSetterFunc<TData, TValue>;

Function or expression. Sets the value into your data for saving. Return true if the data changed.

property width

width?: number;

Initial width in pixels for the cell. If no width or flex properties set, cell width will default to 200 pixels.

property wrapText

wrapText?: boolean;

Set to true to have the text wrap inside the cell - typically used with autoHeight. false

interface ColGroupDef

interface ColGroupDef<TData = any> extends AbstractColDef<TData> {}

Configuration options for column groups in AG Grid.

property children

children: (ColDef<TData> | ColGroupDef<TData>)[];

A list containing a mix of columns and column groups.

property groupId

groupId?: string;

The unique ID to give the column. This is optional. If missing, a unique ID will be generated. This ID is used to identify the column group in the API.

property headerGroupComponent

headerGroupComponent?: any;

The custom header group component to be used for rendering the component header. If none specified the default AG Grid is used. See [Header Group Component](https://www.ag-grid.com/javascript-data-grid/component-header/#header-group-components) for framework specific implementation details.

property headerGroupComponentParams

headerGroupComponentParams?: any;

The params used to configure the headerGroupComponent.

property mainMenuItems

mainMenuItems?:
    | (DefaultMenuItem | MenuItemDef<TData>)[]
    | GetMainMenuItems<TData>;

Customise the list of menu items available in the column group header context menu (on right-click). The column menu button is not displayed for column groups. ColumnMenuModule

property marryChildren

marryChildren?: boolean;

Set to true to keep columns in this group beside each other in the grid. Moving the columns outside of the group (and hence breaking the group) is not allowed. false

property openByDefault

openByDefault?: boolean;

Set to true if this group should be opened by default. false

property suppressStickyLabel

suppressStickyLabel?: boolean;

If true the label of the Column Group will not scroll alongside the grid to always remain visible. false

interface ColSpanParams

interface ColSpanParams<TData = any, TValue = any, TContext = any>
    extends BaseColDefOptionalDataParams<TData, TValue, TContext> {}

interface Column

interface Column<TValue = any>
    extends IHeaderColumn<TValue, ColumnEventName>,
        IProvidedColumn,
        IEventEmitter<ColumnEventName> {}

property isColumn

isColumn: true;

isColumn is always true. Used to distinguish between columns and column groups.

method getAggFunc

getAggFunc: () => string | IAggFunc | null | undefined;

If aggregation is set for the column, returns the aggregation function.

method getColDef

getColDef: () => ColDef<any, TValue>;

Returns the column definition for this column. The column definition will be the result of merging the application provided column definition with any provided defaults (e.g. defaultColDef grid option, or column types.
Equivalent: getDefinition

method getColId

getColId: () => string;

Returns the unique ID for the column.
Equivalent: getId, getUniqueId

method getColSpan

getColSpan: (rowNode: IRowNode) => number;

Returns the column span for this column and row node.

method getColumnGroupPaddingInfo

getColumnGroupPaddingInfo: () => {
    numberOfParents: number;
    isSpanningTotal: boolean;
};

Returns column group padding info.

method getFlex

getFlex: () => number | null;

Returns the flex value of the column or null if not set.

method getRight

getRight: () => number;

Deprecated
v32 Use col.getLeft() + col.getActualWidth() instead.

method getRowSpan

getRowSpan: (rowNode: IRowNode) => number;

Returns the row span for this column and row node.

method getSort

getSort: () => SortDirection | undefined;

If sorting is active, returns the sort direction e.g. 'asc' or 'desc'.
- **Prefer getSortDef**

method getSortDef

getSortDef: () => SortDef | null;

If sorting is active, returns the sort definition.

method getUserProvidedColDef

getUserProvidedColDef: () => ColDef<any, TValue> | null;

Returns the column definition provided by the application. This may not be correct, as items can be superseded by default column options. However it's useful for comparison, eg to know which application column definition matches that column.

method isAllowFormula

isAllowFormula: () => boolean;

Returns true if formulas are permitted for this column.

method isAllowPivot

isAllowPivot: () => boolean;

Returns true if pivoting is allowed for this column

method isAllowRowGroup

isAllowRowGroup: () => boolean;

Returns true if this column can be used as a row group column.

method isAllowValue

isAllowValue: () => boolean;

Returns true if this column can be used as a value column.

method isAnyFunctionActive

isAnyFunctionActive: () => boolean;

Deprecated
v32 Internal method no longer to be exposed on Column interface.

method isAnyFunctionAllowed

isAnyFunctionAllowed: () => boolean;

Deprecated
v32 Internal method no longer to be exposed on Column interface.

method isAutoHeaderHeight

isAutoHeaderHeight: () => boolean;

Returns true if the column header has autoHeight enabled.

method isAutoHeight

isAutoHeight: () => boolean;

Returns true if the column has autoHeight enabled.

method isCellCheckboxSelection

isCellCheckboxSelection: (rowNode: IRowNode) => boolean;

Returns true if this column and row node has checkbox selection.

method isCellEditable

isCellEditable: (rowNode: IRowNode) => boolean;

Returns true if the cell for this column is editable for the given rowNode, otherwise false.

method isDndSource

isDndSource: (rowNode: IRowNode) => boolean;

Returns true if this column and row node allows dragging for native drag and drop.

method isFieldContainsDots

isFieldContainsDots: () => boolean;

Deprecated
v32 Internal method no longer to be exposed on Column interface.

method isFilterActive

isFilterActive: () => boolean;

Returns true if filter is active on the column.

method isFilterAllowed

isFilterAllowed: () => boolean;

Returns true if column filtering is allowed.

method isFirstRightPinned

isFirstRightPinned: () => boolean;

Returns true if this column is the first right pinned column.

method isGreaterThanMax

isGreaterThanMax: (width: number) => boolean;

Deprecated
v32 Internal method no longer to be exposed on Column interface.

method isHovered

isHovered: () => boolean;

Deprecated
v33 Use api.isColumnHovered(column) instead.

method isLastLeftPinned

isLastLeftPinned: () => boolean;

Returns true if this column is the last left pinned column.

method isMenuVisible

isMenuVisible: () => boolean;

Returns true if a menu is visible for this column.

method isPinned

isPinned: () => boolean;

Returns true if this column is pinned either left of right.

method isPinnedLeft

isPinnedLeft: () => boolean;

Returns true if this column is pinned left.

method isPinnedRight

isPinnedRight: () => boolean;

Returns true if this column is pinned right.

method isPivotActive

isPivotActive: () => boolean;

Returns true if pivot is currently active for this column.

method isPrimary

isPrimary: () => boolean;

Returns true if column is a primary column, false if secondary. Secondary columns are used for pivoting.

method isRowDrag

isRowDrag: (rowNode: IRowNode) => boolean;

Returns true if this column and row node can be dragged.

method isRowGroupActive

isRowGroupActive: () => boolean;

Returns true if row group is currently active for this column.

method isRowGroupDisplayed

isRowGroupDisplayed: (colId: string) => boolean;

Returns true if this column group is being used to display a row group value.

method isSortable

isSortable: () => boolean;

Returns true if sorting is enabled for this column via the sortable property.

method isSortAscending

isSortAscending: () => boolean;

Deprecated
v32 use col.getSort() === 'asc

method isSortDescending

isSortDescending: () => boolean;

Deprecated
v32 use col.getSort() === 'desc

method isSorting

isSorting: () => boolean;

Deprecated
v32 use col.getSort() !== undefined

method isSortNone

isSortNone: () => boolean;

Deprecated
v32 use col.getSort() === undefined

method isSpanHeaderHeight

isSpanHeaderHeight: () => boolean;

Returns true if this column spans the header height.

method isSuppressFillHandle

isSuppressFillHandle: () => boolean;

Returns true if the fill handle is suppressed.

method isSuppressNavigable

isSuppressNavigable: (rowNode: IRowNode) => boolean;

Returns true if navigation is suppressed for the given column and rowNode.

method isSuppressPaste

isSuppressPaste: (rowNode: IRowNode) => boolean;

Returns true if paste is suppress for this column and row node.

method isTooltipEnabled

isTooltipEnabled: () => boolean;

Returns true if a tooltip is enabled for this column.

method isTooltipFieldContainsDots

isTooltipFieldContainsDots: () => boolean;

Deprecated
v32 Internal method no longer to be exposed on Column interface.

method isValueActive

isValueActive: () => boolean;

Returns true if value (aggregation) is currently active for this column.

interface ColumnChooserParams

interface ColumnChooserParams {}

property contractColumnSelection

contractColumnSelection?: boolean;

By default, column groups start expanded. Pass true to default to contracted groups

property suppressColumnExpandAll

suppressColumnExpandAll?: boolean;

To suppress Expand / Collapse all widget

property suppressColumnSelectAll

suppressColumnSelectAll?: boolean;

To suppress Select / Un-select all widget

property suppressSyncLayoutWithGrid

suppressSyncLayoutWithGrid?: boolean;

To suppress updating the layout of columns as they are rearranged in the grid

interface ColumnContainerWidthChanged

interface ColumnContainerWidthChanged<TData = any, TContext = any>
    extends AgGlobalEvent<'columnContainerWidthChanged', TData, TContext> {}

interface ColumnContainerWidthChangedEvent

interface ColumnContainerWidthChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnContainerWidthChanged', TData, TContext> {}

interface ColumnEvent

interface ColumnEvent<
    T extends AgEventType | ColumnEventName = any,
    TData = any,
    TContext = any
> extends AgGridEvent<TData, TContext, T> {}

property column

column: Column | null;

The impacted column, only set if action was on one column

property columns

columns: Column[] | null;

List of all impacted columns

property source

source: ColumnEventType;

String describing where the event is coming from

interface ColumnEverythingChangedEvent

interface ColumnEverythingChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnEverythingChanged', TData, TContext> {}

Deprecated
v32.2 Either use displayedColumnsChanged which is fired at the same time, or use one of the more specific column events.

property source

source: string;

interface ColumnFilter

interface ColumnFilter<
    TData = any,
    TValue = any,
    TContext = any,
    TModel = any,
    TCustomParams = any
> {}

property component

component: any;

Filter component to use for this column. - Set to the name of a provided filter: agNumberColumnFilter, agBigIntColumnFilter, agTextColumnFilter, agDateColumnFilter. - Set to a custom filter FilterDisplay

property doesFilterPass

doesFilterPass?: (
    params: DoesFilterPassParams<TData, TContext, TModel, TCustomParams>
) => boolean;

Contains the logic for executing the filter. If the filter is active, will be called for each row in the grid to see if it passes. If any filter fails, then the row will be excluded from the final set.
Not required if providing a handler, or if not using Client-Side Row Model.

property handler

handler?:
    | string
    | CreateFilterHandlerFunc<TData, TValue, TContext, TModel, TCustomParams>;

Returns a handler which contains the logic for executing the filter. Allows for more complex filter cases than doesFilterPass.
Not required if providing doesFilterPass (but will take precedence), or if not using Client-Side Row Model.

interface ColumnFilterState

interface ColumnFilterState {}

ColumnFilterState represents the filter state for all columns in the grid keyed by the column id. This excludes the filter model.

index signature

[colId: string]: any;

Filter state keyed by the column id. The values will be passed into each of the filter component params as state.state.

interface ColumnFunctionCallbackParams

interface ColumnFunctionCallbackParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef: ColDef<TData, TValue>;

ColDef provided for this column

property column

column: Column<TValue>;

Column for this callback

property data

data: TData | undefined;

Data associated with the node. Will be undefined for group rows.

property node

node: IRowNode<TData>;

Row node for the given row

interface ColumnGroup

interface ColumnGroup<TValue = any>
    extends IHeaderColumn<TValue, AgColumnGroupEvent> {}

property isColumn

isColumn: false;

isColumn is always false. Used to distinguish between columns and column groups.

method getChildren

getChildren: () => (Column | ColumnGroup)[] | null;

Returns the children of this group if they exist or null

method getColGroupDef

getColGroupDef: () => ColGroupDef | null;

Returns the column group definition for this column. The column group definition will be the result of merging the application provided column group definition with any provided defaults (e.g. defaultColGroupDef grid option.

method getDisplayedChildren

getDisplayedChildren: () => (Column | ColumnGroup)[] | null;

Returns the displayed children of this group.

method getDisplayedLeafColumns

getDisplayedLeafColumns: () => Column[];

Returns the displayed leaf columns of this group.

method getPaddingLevel

getPaddingLevel: { (): number; (): number };

Returns the padding level of this padding group.

method getPartId

getPartId: () => number;

Deprecated
v32 Internal method no longer to be exposed on Column interface.

method isExpandable

isExpandable: () => boolean;

Returns true if this column group is expandable.

method isExpanded

isExpanded: () => boolean;

Returns true if this column group is expanded.

method isPadding

isPadding: () => boolean;

Returns true if this column group is a padding group that is used to correctly align column groups / children.

method isResizable

isResizable: () => boolean;

Returns true if this group is resizable.

interface ColumnGroupHeaderHeightChangedEvent

interface ColumnGroupHeaderHeightChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnGroupHeaderHeightChanged', TData, TContext> {}

property columnGroup

columnGroup: ColumnGroup | null;

property source

source: 'autosizeColumnGroupHeaderHeight';

interface ColumnGroupOpenedEvent

interface ColumnGroupOpenedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnGroupOpened', TData, TContext> {}

property columnGroup

columnGroup?: ProvidedColumnGroup;

property columnGroups

columnGroups: ProvidedColumnGroup[];

interface ColumnGroupState

interface ColumnGroupState {}

property openColumnGroupIds

openColumnGroupIds: string[];

interface ColumnHeaderClickedEvent

interface ColumnHeaderClickedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnHeaderClicked', TData, TContext> {}

property column

column: Column | ProvidedColumnGroup;

Column or column-group related to the header that triggered the event

interface ColumnHeaderContextMenuEvent

interface ColumnHeaderContextMenuEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnHeaderContextMenu', TData, TContext> {}

property column

column: Column | ProvidedColumnGroup;

Column or column-group related to the header that triggered the event

interface ColumnHeaderHeightChangedEvent

interface ColumnHeaderHeightChangedEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnHeaderHeightChanged', TData, TContext> {}

interface ColumnHeaderMouseLeaveEvent

interface ColumnHeaderMouseLeaveEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnHeaderMouseLeave', TData, TContext> {}

property column

column: Column | ProvidedColumnGroup;

Column or column-group related to the header that triggered the event

interface ColumnHeaderMouseOverEvent

interface ColumnHeaderMouseOverEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnHeaderMouseOver', TData, TContext> {}

property column

column: Column | ProvidedColumnGroup;

Column or column-group related to the header that triggered the event

interface ColumnHoverChangedEvent

interface ColumnHoverChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnHoverChanged', TData, TContext> {}

interface ColumnMenuVisibleChangedEvent

interface ColumnMenuVisibleChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnMenuVisibleChanged', TData, TContext> {}

property column

column: Column | null;

Column the menu is opened for. Will be null if not launched from a column (e.g. column chooser from the API, or column menu via right-click on a column group or empty header).

property columnGroup

columnGroup?: ProvidedColumnGroup | null;

Column group the menu is opened for if launched from right-click on a column group

property key

key:
    | 'generalMenuTab'
    | 'filterMenuTab'
    | 'columnsMenuTab'
    | 'columnMenu'
    | 'columnFilter'
    | 'floatingFilter'
    | 'columnChooser';

Currently displayed menu/tab. If filter launched from floating filter, will be 'floatingFilter'. If using columnMenu = 'new' (default behaviour), will be 'columnMenu' for the column menu, 'columnFilter' for the column filter, and 'columnChooser' for the column chooser. If using AG Grid Enterprise and columnMenu = 'legacy', will be the tab 'generalMenuTab', 'filterMenuTab' or 'columnsMenuTab'. If using AG Grid Community and columnMenu = 'legacy', will be 'columnMenu'.

property switchingTab

switchingTab: boolean;

True if switching between tabs. False if showing/hiding. Only applies to legacy tabbed menu.

property visible

visible: boolean;

True if now visible; false if now hidden.

interface ColumnMovedEvent

interface ColumnMovedEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnMoved', TData, TContext> {}

property finished

finished: boolean;

True when the column has finished moving.

property toIndex

toIndex?: number;

The position the column was moved to

interface ColumnOrderState

interface ColumnOrderState {}

interface ColumnPanelItemDragEndEvent

interface ColumnPanelItemDragEndEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnPanelItemDragEnd', TData, TContext> {}

interface ColumnPanelItemDragStartEvent

interface ColumnPanelItemDragStartEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnPanelItemDragStart', TData, TContext> {}

property column

column: Column | ProvidedColumnGroup;

interface ColumnPinnedEvent

interface ColumnPinnedEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnPinned', TData, TContext> {}

property pinned

pinned: ColumnPinnedType;

Either 'left', 'right', or null (it not pinned)

interface ColumnPinningState

interface ColumnPinningState {}

property leftColIds

leftColIds: string[];

property rightColIds

rightColIds: string[];

interface ColumnPivotChangedEvent

interface ColumnPivotChangedEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnPivotChanged', TData, TContext> {}

interface ColumnPivotModeChangedEvent

interface ColumnPivotModeChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnPivotModeChanged', TData, TContext> {}

interface ColumnResizedEvent

interface ColumnResizedEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnResized', TData, TContext> {}

property finished

finished: boolean;

Set to true for last event in a sequence of move events

interface ColumnRowGroupChangedEvent

interface ColumnRowGroupChangedEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnRowGroupChanged', TData, TContext> {}

interface ColumnSizeState

interface ColumnSizeState {}

property colId

colId: string;

property flex

flex?: number;

property width

width?: number;

interface ColumnSizingState

interface ColumnSizingState {}

property columnSizingModel

columnSizingModel: ColumnSizeState[];

interface ColumnsResetEvent

interface ColumnsResetEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'columnsReset', TData, TContext> {}

property source

source: ColumnEventType;

interface ColumnState

interface ColumnState extends ColumnStateParams {}

property colId

colId: string;

ID of the column

interface ColumnStateParams

interface ColumnStateParams {}

property aggFunc

aggFunc?: string | IAggFunc | null;

The aggregation function applied

property flex

flex?: number | null;

Column's flex if flex is set

property hide

hide?: boolean | null;

True if the column is hidden

property pinned

pinned?: ColumnPinnedType;

Set if column is pinned

property pivot

pivot?: boolean | null;

True if pivot active

property pivotIndex

pivotIndex?: number | null;

The order of the pivot, if pivoting by many columns

property rowGroup

rowGroup?: boolean | null;

True if row group active

property rowGroupIndex

rowGroupIndex?: number | null;

The order of the row group, if grouping by many columns

property sort

sort?: SortDirection;

The sort direction of the column

property sortIndex

sortIndex?: number | null;

The order of the sort, if sorting by many columns

property sortType

sortType?: SortType;

The type of sort applied to the column

property width

width?: number | null;

Width of the column in pixels

interface ColumnToolPanelState

interface ColumnToolPanelState {}

property expandedGroupIds

expandedGroupIds: string[];

interface ColumnValueChangedEvent

interface ColumnValueChangedEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnValueChanged', TData, TContext> {}

interface ColumnVisibilityState

interface ColumnVisibilityState {}

property hiddenColIds

hiddenColIds: string[];

interface ColumnVisibleEvent

interface ColumnVisibleEvent<TData = any, TContext = any>
    extends ColumnEvent<'columnVisible', TData, TContext> {}

property visible

visible?: boolean;

True if column was set to visible, false if set to hide, undefined if in a single call some columns were shown while others hidden

interface ColumnVO

interface ColumnVO {}

Column Value Object

property aggFunc

aggFunc?: string;

property displayName

displayName: string;

property field

field?: string;

property id

id: string;

interface ColumnWidthCallbackParams

interface ColumnWidthCallbackParams {}

property column

column: Column | null;

property index

index: number;

interface CommonCellFocusParams

interface CommonCellFocusParams {}

property column

column: Column | string | null;

Column of the focused cell

property isFullWidthCell

isFullWidthCell?: boolean;

Whether the cell a full width cell or a regular cell

property rowIndex

rowIndex: number | null;

Row index of the focused cell

property rowPinned

rowPinned: RowPinnedType;

either 'top', 'bottom' or null / undefined (if not pinned)

interface ComponentStateChangedEvent

interface ComponentStateChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'componentStateChanged', TData, TContext> {}

interface ContextMenuVisibleChangedEvent

interface ContextMenuVisibleChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'contextMenuVisibleChanged', TData, TContext> {}

-------------------

property source

source: 'api' | 'ui';

Source of the visibility status change.

property visible

visible: boolean;

True if now visible; false if now hidden.

interface CoreParams

interface CoreParams extends SharedThemeParams {}

All possible theme param types - the actual params available will be a subset of this type depending on the parts in use by the theme.

property advancedFilterBuilderButtonBarBorder

advancedFilterBuilderButtonBarBorder: BorderValue;

Color of the dividing line above the buttons in the advanced filter builder

property advancedFilterBuilderColumnPillColor

advancedFilterBuilderColumnPillColor: ColorValue;

Color of the column pills in the Advanced Filter Builder

property advancedFilterBuilderIndentSize

advancedFilterBuilderIndentSize: LengthValue;

Amount that each level of the nesting in the advanced filter builder is indented by

property advancedFilterBuilderJoinPillColor

advancedFilterBuilderJoinPillColor: ColorValue;

Color of the join operator pills in the Advanced Filter Builder

property advancedFilterBuilderOptionPillColor

advancedFilterBuilderOptionPillColor: ColorValue;

Color of the filter option pills in the Advanced Filter Builder

property advancedFilterBuilderValuePillColor

advancedFilterBuilderValuePillColor: ColorValue;

Color of the value pills in the Advanced Filter Builder

property cellHorizontalPadding

cellHorizontalPadding: LengthValue;

Padding at the start and end of grid cells and header cells.

property cellHorizontalPaddingScale

cellHorizontalPaddingScale: ScaleValue;

Multiply the cell horizontal padding by a number, e.g. 1.5 to increase by 50%

property cellTextColor

cellTextColor: ColorValue;

Color of text in cells in the grid data area

property cellWidgetSpacing

cellWidgetSpacing: LengthValue;

Horizontal spacing between widgets inside cells (e.g. row group expand buttons and row selection checkboxes).

property chartMenuLabelColor

chartMenuLabelColor: ColorValue;

Color of form field labels within the chart editing panel for integrated charts

property chartMenuPanelWidth

chartMenuPanelWidth: LengthValue;

Width of the chart editing panel for integrated charts

property columnBorder

columnBorder: BorderValue;

Vertical borders between columns within the grid only, excluding headers.

property columnDragIndicatorColor

columnDragIndicatorColor: ColorValue;

Color of the indicator line used to show where a row will be inserted when dragging to reorder columns

property columnDragIndicatorWidth

columnDragIndicatorWidth: LengthValue;

Width of the indicator line used to show where a row will be inserted when dragging to reorder columns

property columnDropCellBackgroundColor

columnDropCellBackgroundColor: ColorValue;

Background color of the pill shape representing columns in the column drop component

property columnDropCellBorder

columnDropCellBorder: BorderValue;

Border for the pill shape representing columns in the column drop component

property columnDropCellDragHandleColor

columnDropCellDragHandleColor: ColorValue;

Color of the drag grip icon in the pill shape representing columns in the column drop component

property columnDropCellTextColor

columnDropCellTextColor: ColorValue;

Text color for the pill shape representing columns in the column drop component

property columnHoverColor

columnHoverColor: ColorValue;

Background color when hovering over columns in the grid. This is not visible unless enabled in the grid options.

property columnPanelApplyButtonBackgroundColor

columnPanelApplyButtonBackgroundColor: ColorValue;

Background color of Columns Tool Panel apply button

property columnPanelApplyButtonColor

columnPanelApplyButtonColor: ColorValue;

Color of Columns Tool Panel apply button

property columnSelectIndentSize

columnSelectIndentSize: LengthValue;

Amount of indentation for each level of children when selecting grouped columns in the column select widget.

property dataBackgroundColor

dataBackgroundColor: ColorValue;

Background color applied to grid rows. Should be a solid color, semi-transparent colors will cause issues.

property dragHandleColor

dragHandleColor: ColorValue;

Color of the drag handle on draggable rows and column markers

property filterPanelApplyButtonBackgroundColor

filterPanelApplyButtonBackgroundColor: ColorValue;

Background color of new Filters Tool Panel apply button

property filterPanelApplyButtonColor

filterPanelApplyButtonColor: ColorValue;

Color of new Filters Tool Panel apply button

property filterPanelCardSubtleColor

filterPanelCardSubtleColor: ColorValue;

Color of text and UI elements that should stand out less than the default in new Filters Tool Panel

property filterPanelCardSubtleHoverColor

filterPanelCardSubtleHoverColor: ColorValue;

Color of text and UI elements that should stand out less than the default in new Filters Tool Panel when hovered

property filterToolPanelGroupIndent

filterToolPanelGroupIndent: LengthValue;

How much to indent child columns in the filters tool panel relative to their parent

property findActiveMatchBackgroundColor

findActiveMatchBackgroundColor: ColorValue;

Background color of the active match used in Find

property findMatchBackgroundColor

findMatchBackgroundColor: ColorValue;

Background color of matches used in Find

property footerRowBorder

footerRowBorder: BorderValue;

Horizontal borders above footer components like the pagination and status bars

property fullRowEditInvalidBackgroundColor

fullRowEditInvalidBackgroundColor: ColorValue;

Background color for a row with invalid editor status

property headerCellBackgroundTransitionDuration

headerCellBackgroundTransitionDuration: DurationValue;

Duration in seconds of the background color transition if headerCellHoverBackgroundColor or headerCellMovingBackgroundColor is set

property headerCellHoverBackgroundColor

headerCellHoverBackgroundColor: ColorValue;

Background color of a header cell when hovering over it, or transparent for no change.

property headerCellMovingBackgroundColor

headerCellMovingBackgroundColor: ColorValue;

Background color of a header cell when dragging to reposition it, or transparent for no change.

property headerColumnBorder

headerColumnBorder: BorderValue;

Vertical borders between columns within headers.

property headerColumnBorderHeight

headerColumnBorderHeight: LengthValue;

Height of the vertical border between column headers. Percentage values are relative to the header height.

property headerColumnResizeHandleColor

headerColumnResizeHandleColor: ColorValue;

Color of the drag handle on resizable header columns. Set this to transparent to hide the resize handle.

property headerColumnResizeHandleHeight

headerColumnResizeHandleHeight: LengthValue;

Height of the drag handle on resizable header columns. Percentage values are relative to the header height.

property headerColumnResizeHandleWidth

headerColumnResizeHandleWidth: LengthValue;

Width of the drag handle on resizable header columns.

property iconButtonActiveBackgroundColor

iconButtonActiveBackgroundColor: ColorValue;

Background color of clickable icon buttons when styled as active. This is used for the column filter button when a filter is applied to the column.

property iconButtonActiveColor

iconButtonActiveColor: ColorValue;

Color of clickable icon buttons when styled as active. This is used for the column filter button when a filter is applied to the column.

property iconButtonActiveIndicatorColor

iconButtonActiveIndicatorColor: ColorValue;

Color of the marker dot shown on icon buttons when styled as active. This is used for the column filter button when a filter is applied to the column.

property iconButtonBackgroundColor

iconButtonBackgroundColor: ColorValue;

Default background color for clickable icons

property iconButtonBackgroundSpread

iconButtonBackgroundSpread: LengthValue;

The distance beyond the border of the clickable icons that the background extends to

property iconButtonBorderRadius

iconButtonBorderRadius: LengthValue;

Corner radius of clickable icon background

property iconButtonHoverBackgroundColor

iconButtonHoverBackgroundColor: ColorValue;

Background color for clickable icons when hovered

property modalOverlayBackgroundColor

modalOverlayBackgroundColor: ColorValue;

Background color of the overlay shown over the grid e.g. a data loading indicator.

property oddRowBackgroundColor

oddRowBackgroundColor: ColorValue;

Alternative background colour applied to every other row to create a striped effect

property paginationPanelHeight

paginationPanelHeight: LengthValue;

Height of the pagination panel at the bottom of the grid. Defaults to the higher of rowHeight or 22px.

property pinnedColumnBorder

pinnedColumnBorder: BorderValue;

Vertical borders between columns that are pinned to the left or right and the rest of the grid

property pinnedRowBackgroundColor

pinnedRowBackgroundColor: ColorValue;

Background color for the rows that have been pinned to the top or bottom

property pinnedRowBorder

pinnedRowBorder: BorderValue;

Horizontal borders between the grid and rows that are pinned to the top or bottom and the rest of the grid

property pinnedRowFontWeight

pinnedRowFontWeight: FontWeightValue;

Font-weight for the rows that have been pinned to the top or bottom

property pinnedRowTextColor

pinnedRowTextColor: ColorValue;

Text color for rows that have been pinned to the top or bottom

property pinnedSourceRowBackgroundColor

pinnedSourceRowBackgroundColor: ColorValue;

Background color for the row in the main viewport that has been pinned to the top or bottom

property pinnedSourceRowFontWeight

pinnedSourceRowFontWeight: FontWeightValue;

Font-weight for the row in the main viewport that has been pinned to the top or bottom

property pinnedSourceRowTextColor

pinnedSourceRowTextColor: ColorValue;

Text color for row in the main viewport that has been pinned to the top or bottom

property rangeHeaderHighlightColor

rangeHeaderHighlightColor: ColorValue;

Background color of the grid header when any cell of that header is part of a range. This is not visible unless enabled in the cell selection options.

property rangeSelectionBackgroundColor

rangeSelectionBackgroundColor: ColorValue;

Background color of selected cell ranges. Choosing a semi-transparent color ensure that multiple overlapping ranges look correct.

property rangeSelectionBorderColor

rangeSelectionBorderColor: ColorValue;

The color used for borders around range selections. The selection background defaults to a semi-transparent version of this color.

property rangeSelectionBorderStyle

rangeSelectionBorderStyle: BorderStyleValue;

Border style around range selections.

property rangeSelectionChartBackgroundColor

rangeSelectionChartBackgroundColor: ColorValue;

Background color for cells that provide data to the current range chart

property rangeSelectionChartCategoryBackgroundColor

rangeSelectionChartCategoryBackgroundColor: ColorValue;

Background color for cells that provide categories to the current range chart

property rangeSelectionHighlightColor

rangeSelectionHighlightColor: ColorValue;

Background color to briefly apply to a cell range when the user copies from or pastes into it.

property rowDragIndicatorColor

rowDragIndicatorColor: ColorValue;

Color of the indicator line used to show where a row will be inserted when dragging to reorder rows

property rowDragIndicatorWidth

rowDragIndicatorWidth: LengthValue;

Width of the indicator line used to show where a row will be inserted when dragging to reorder rows

property rowGroupIndentSize

rowGroupIndentSize: LengthValue;

The size of indentation applied to each level of row grouping - deep rows are indented by a multiple of this value.

property rowHeight

rowHeight: LengthValue;

Height of grid rows. NOTE: by default this value is calculated to leave enough room for text, icons and padding. Most applications should leave it as is and use rowVerticalPaddingScale to change padding.

property rowHoverColor

rowHoverColor: ColorValue;

Background color when hovering over rows in the grid and in dropdown menus. Set to transparent to disable the hover effect. Note: if you want a hover effect on one but not the other, use CSS selectors instead of this property.

property rowLoadingSkeletonEffectColor

rowLoadingSkeletonEffectColor: ColorValue;

Color of the skeleton loading effect used when loading row data with the Server-side Row Model

property rowNumbersSelectedColor

rowNumbersSelectedColor: ColorValue;

Background color of the Row Numbers cells when the range selects all cells for that row.

property rowVerticalPaddingScale

rowVerticalPaddingScale: ScaleValue;

Multiply the row vertical padding by a number, e.g. 1.5 to increase by 50%. Has no effect if rowHeight is set.

property selectCellBackgroundColor

selectCellBackgroundColor: ColorValue;

Background color for selected items within the multiple select widget

property selectCellBorder

selectCellBorder: BorderValue;

Border for selected items within the multiple select widget

property selectedRowBackgroundColor

selectedRowBackgroundColor: ColorValue;

Background color of selected rows in the grid and in dropdown menus.

property setFilterIndentSize

setFilterIndentSize: LengthValue;

Amount of indentation for each level of child items in the Set Filter list when filtering tree data.

property sideBarBackgroundColor

sideBarBackgroundColor: ColorValue;

Background color of the sidebar that contains the columns and filters tool panels

property sideBarPanelAnimationDuration

sideBarPanelAnimationDuration: DurationValue;

Duration of the animation when a sidebar panel opens or closes. Set to 0 to disable animations. Automatically disabled if the user has requested reduced motion in their OS accessibility settings.

property sideBarPanelWidth

sideBarPanelWidth: LengthValue;

Default width of the sidebar that contains the columns and filters tool panels

property sideButtonBackgroundColor

sideButtonBackgroundColor: ColorValue;

Background color of the tab buttons in the sidebar

property sideButtonBarBackgroundColor

sideButtonBarBackgroundColor: ColorValue;

Background color of the row of tab buttons at the edge of the sidebar

property sideButtonBarTopPadding

sideButtonBarTopPadding: LengthValue;

Spacing between the topmost side button and the top of the sidebar

property sideButtonBorder

sideButtonBorder: BorderValue;

Border drawn above and below tab buttons in the sidebar

property sideButtonHoverBackgroundColor

sideButtonHoverBackgroundColor: ColorValue;

Background color of the tab buttons in the sidebar when hovered

property sideButtonHoverTextColor

sideButtonHoverTextColor: ColorValue;

Text color of the tab buttons in the sidebar when hovered

property sideButtonLeftPadding

sideButtonLeftPadding: LengthValue;

Padding to the left of the text in tab buttons in the sidebar (this is always the padding on the inward facing side of the button, so in right-to-left layout it will be on the right)

property sideButtonRightPadding

sideButtonRightPadding: LengthValue;

Padding to the right of the text in tab buttons in the sidebar (this is always the padding on the outward facing side of the button, so in right-to-left layout it will be on the left)

property sideButtonSelectedBackgroundColor

sideButtonSelectedBackgroundColor: ColorValue;

Background color of the selected tab button in the sidebar

property sideButtonSelectedBorder

sideButtonSelectedBorder: BorderValue;

Border drawn above and below the selected tab button in the sidebar

property sideButtonSelectedTextColor

sideButtonSelectedTextColor: ColorValue;

Text color of the selected tab button in the sidebar

property sideButtonSelectedUnderlineColor

sideButtonSelectedUnderlineColor: ColorValue;

Color of the underline below the selected tab in the sidebar, or 'transparent' to disable the underline effect

property sideButtonSelectedUnderlineTransitionDuration

sideButtonSelectedUnderlineTransitionDuration: DurationValue;

Duration of the transition effect for the underline below the selected tab in the sidebar

property sideButtonSelectedUnderlineWidth

sideButtonSelectedUnderlineWidth: LengthValue;

Width of the underline below the selected tab in the sidebar

property sideButtonTextColor

sideButtonTextColor: ColorValue;

Text color of the tab buttons in the sidebar

property sideButtonVerticalPadding

sideButtonVerticalPadding: LengthValue;

Padding above and below the text in tab buttons in the sidebar

property sidePanelBorder

sidePanelBorder: BorderValue;

Borders between the grid and side panels including the column and filter tool bars, and chart settings

property statusBarLabelColor

statusBarLabelColor: ColorValue;

Text color for labels in the status bar component

property statusBarLabelFontWeight

statusBarLabelFontWeight: FontWeightValue;

Font weight for labels in the status bar component

property statusBarValueColor

statusBarValueColor: ColorValue;

Text color for values in the status bar component

property statusBarValueFontWeight

statusBarValueFontWeight: FontWeightValue;

Font weight for values in the status bar component

property toolbarBackgroundColor

toolbarBackgroundColor: ColorValue;

Background color of the toolbar. Defaults to the header background color.

property toolbarSeparatorBorder

toolbarSeparatorBorder: BorderValue;

Border style for the vertical separator between toolbar items.

property toolbarTextColor

toolbarTextColor: ColorValue;

Text color in the toolbar. Defaults to the header text color.

property toolPanelSeparatorBorder

toolPanelSeparatorBorder: BorderValue;

The dividing line between sections of menus e.g. column menu and right-click context menu

property valueChangeDeltaDownColor

valueChangeDeltaDownColor: ColorValue;

Color to temporarily apply to cell data when its value decreases in an agAnimateShowChangeCellRenderer cell

property valueChangeDeltaUpColor

valueChangeDeltaUpColor: ColorValue;

Color to temporarily apply to cell data when its value increases in an agAnimateShowChangeCellRenderer cell

property valueChangeValueHighlightBackgroundColor

valueChangeValueHighlightBackgroundColor: ColorValue;

Background color to apply when a cell value changes and enableCellChangeFlash is enabled

property wrapperBackgroundColor

wrapperBackgroundColor: ColorValue;

Background color of the outermost container around the grid.

property wrapperBorderRadius

wrapperBorderRadius: LengthValue;

Corner radius of the outermost container around the grid.

interface CreateCrossFilterChartParams

interface CreateCrossFilterChartParams extends BaseCreateChartParams {}

property aggFunc

aggFunc?: string | IAggFunc;

The aggregation function that should be applied to all series data.

property cellRange

cellRange: ChartParamsCellRange;

The range of cells to be charted. If no rows / rowIndexes are specified all rows will be included.

property chartType

chartType: CrossFilterChartType;

The type of cross-filter chart to create.

property sort

sort?: SortModelItem[] | boolean;

By default (or when true), the order in cross filter charts will match grid sorting. Set to false to disable sorting for this chart. Set to a SortModelItem[] to provide a custom sorting for this chart. true

property suppressChartRanges

suppressChartRanges?: boolean;

Suppress highlighting the selected range in the grid.

interface CreateFilterHandlerFuncParams

interface CreateFilterHandlerFuncParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef: ColDef<TData, TValue>;

property column

column: Column<TValue>;

interface CreatePivotChartParams

interface CreatePivotChartParams extends BaseCreateChartParams {}

interface CreateRangeChartParams

interface CreateRangeChartParams extends BaseCreateChartParams {}

property aggFunc

aggFunc?: string | IAggFunc;

The aggregation function that should be applied to all series data.

property cellRange

cellRange: ChartParamsCellRange;

The range of cells to be charted. If no rows / rowIndexes are specified all rows will be included.

property seriesChartTypes

seriesChartTypes?: SeriesChartType[];

The series chart type configurations used in combination charts.

property seriesGroupType

seriesGroupType?: SeriesGroupType;

Group type for chart types that support grouped series.

property suppressChartRanges

suppressChartRanges?: boolean;

Suppress highlighting the selected range in the grid.

property useGroupColumnAsCategory

useGroupColumnAsCategory?: boolean;

Prefer using the auto group column as the category when grouping is active.

interface CsvCell

interface CsvCell {}

property data

data: CsvCellData;

The data that will be added to the cell.

property mergeAcross

mergeAcross?: number;

The number of cells to span across (1 means span 2 columns). 0

interface CsvCellData

interface CsvCellData {}

property value

value: string | null;

The value of the cell.

interface CsvExportParams

interface CsvExportParams extends ExportParams<CsvCustomContent> {}

property columnSeparator

columnSeparator?: string;

Delimiter to insert between cell values. ,

property suppressQuotes

suppressQuotes?: boolean;

By default cell values are encoded according to CSV format rules: values are wrapped in double quotes, and any double quotes within the values are escaped, so my value becomes "my""value". Pass true to insert the value into the CSV file without escaping. In this case it is your responsibility to ensure that no cells contain the columnSeparator character. false

interface CutEndEvent

interface CutEndEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'cutEnd', TData, TContext> {}

property source

source: 'api' | 'ui' | 'contextMenu';

interface CutStartEvent

interface CutStartEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'cutStart', TData, TContext> {}

property source

source: 'api' | 'ui' | 'contextMenu';

interface DataChangedEvent

interface DataChangedEvent<TData = any> extends RowNodeEvent<'dataChanged', TData> {}

property newData

newData: TData | undefined;

property oldData

oldData: TData | undefined;

property update

update: boolean;

interface DataTypesInferredEvent

interface DataTypesInferredEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'dataTypesInferred', TData, TContext> {}

interface DateAdvancedFilterModel

interface DateAdvancedFilterModel {}

Represents a single filter condition for a date column

property colId

colId: string;

The ID of the column being filtered.

property filter

filter?: string;

The value to filter on. This is in format YYYY-MM-DD.

property filterType

filterType: 'date';

property type

type: ScalarAdvancedFilterModelType;

The filter option that is being applied.

interface DateDataTypeDefinition

interface DateDataTypeDefinition<TData = any, TContext = any>
    extends BaseDataTypeDefinition<'date', TData, Date, TContext> {}

Represents a 'date' data type (type Date).

interface DateFilterModel

interface DateFilterModel extends ISimpleFilterModel {}

property dateFrom

dateFrom: string | null | undefined;

The date value(s) associated with the filter. The type is string and the format is YYYY-MM-DD hh:mm:ss, e.g. 2019-05-24 00:00:00. If useIsoSeparator = true, the format is instead YYYY-MM-DDThh:mm:ss. Custom filters can have no values (hence both are optional). Range filter has two values (from and to).

property dateTo

dateTo: string | null | undefined;

Range filter to date value.

interface DateStringAdvancedFilterModel

interface DateStringAdvancedFilterModel {}

Represents a single filter condition for a date string column

property colId

colId: string;

The ID of the column being filtered.

property filter

filter?: string;

The value to filter on. This is in format YYYY-MM-DD.

property filterType

filterType: 'dateString';

property type

type: ScalarAdvancedFilterModelType;

The filter option that is being applied.

interface DateStringDataTypeDefinition

interface DateStringDataTypeDefinition<TData = any, TContext = any>
    extends BaseDataTypeDefinition<'dateString', TData, string, TContext> {}

Represents a 'dateString' data type (type string that represents a date).

property dateFormatter

dateFormatter?: (value: Date | undefined) => string | undefined;

Converts a date in Date format to a string.

property dateParser

dateParser?: (value: string | undefined) => Date | undefined;

Converts a date in string format to a Date.

interface DateTimeAdvancedFilterModel

interface DateTimeAdvancedFilterModel {}

property colId

colId: string;

The ID of the column being filtered.

property filter

filter?: string;

The value to filter on. This is in format YYYY-MM-DDTHH:mm:ss.

property filterType

filterType: 'dateTime';

property type

type: ScalarAdvancedFilterModelType;

The filter option that is being applied.

interface DateTimeDataTypeDefinition

interface DateTimeDataTypeDefinition<TData = any, TContext = any>
    extends BaseDataTypeDefinition<'dateTime', TData, Date, TContext> {}

Represents a 'dateTime' data type (type Date).

interface DateTimeStringAdvancedFilterModel

interface DateTimeStringAdvancedFilterModel {}

property colId

colId: string;

The ID of the column being filtered.

property filter

filter?: string;

The value to filter on. This is in format YYYY-MM-DD HH:mm:ss.

property filterType

filterType: 'dateTimeString';

property type

type: ScalarAdvancedFilterModelType;

The filter option that is being applied.

interface DateTimeStringDataTypeDefinition

interface DateTimeStringDataTypeDefinition<TData = any, TContext = any>
    extends BaseDataTypeDefinition<'dateTimeString', TData, string, TContext> {}

Represents a 'dateTimeString' data type (type string that represents a dateTime).

property dateFormatter

dateFormatter?: (value: Date | undefined) => string | undefined;

Converts a date in Date format to a string.

property dateParser

dateParser?: (value: string | undefined) => Date | undefined;

Converts a date in string format to a Date.

interface DetailGridInfo

interface DetailGridInfo {}

property api

api?: GridApi;

Grid api of the detail grid.

property id

id: string;

Id of the detail grid, the format is detail_{ROW-ID}, where ROW-ID is the id of the parent row.

interface DisplayedChangedEvent

interface DisplayedChangedEvent<TData = any>
    extends RowNodeEvent<'displayedChanged', TData> {}

interface DisplayedColumnsChangedEvent

interface DisplayedColumnsChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'displayedColumnsChanged', TData, TContext> {}

property source

source: ColumnEventType;

interface DisplayedColumnsWidthChangedEvent

interface DisplayedColumnsWidthChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'displayedColumnsWidthChanged', TData, TContext> {}

interface DisplayedRowsChangedEvent

interface DisplayedRowsChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'displayedRowsChanged', TData, TContext> {}

property afterScroll

afterScroll: boolean;

interface DistributionGetValueParams

interface DistributionGetValueParams<TData = any, TValue = any, TContext = any>
    extends BaseColDefOptionalDataParams<TData, TValue, TContext> {}

Parameters passed to the getValue callback. Extends the same base as ValueGetterParams — node is the child row being read, data is node.data. Access the group edit context via groupParams.
Example 1
getValue: (params) => params.data?.weight ?? 0,

property groupParams

groupParams: GroupRowValueSetterParams<TData, TValue, TContext>;

The group row edit parameters that triggered this distribution.

property node

node: IRowNode<TData>;

The child RowNode whose value is being read.

interface DistributionSetValueParams

interface DistributionSetValueParams<TData = any, TValue = any, TContext = any>
    extends DistributionGetValueParams<TData, TValue, TContext> {}

Parameters passed to the setValue callback. Same as DistributionGetValueParams plus the value to write.

Example 1

setValue: (params) =>
    params.node.setDataValue(params.column, Math.max(0, Number(params.value)), 'data'),

property value

value: unknown;

The distributed value to write to this child.

interface DndSourceCallbackParams

interface DndSourceCallbackParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

interface DndSourceOnRowDragParams

interface DndSourceOnRowDragParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property dragEvent

dragEvent: DragEvent;

The DOM event that represents a drag and drop interaction

property rowNode

rowNode: IRowNode<TData>;

Row node for the given row

interface DoesFilterPassParams

interface DoesFilterPassParams<
    TData = any,
    TContext = any,
    TModel = any,
    TCustomParams = any
> extends IDoesFilterPassParams<TData> {}

property handlerParams

handlerParams: FilterHandlerBaseParams<TData, TContext, TModel, TCustomParams>;

Utility params that would be passed to the handler, including getValue which provides access to the cell values.

property model

model: TModel;

interface DoubleTapEvent

interface DoubleTapEvent extends AgEvent<'doubleTap'> {}

property touchStart

touchStart: Touch;

interface DragCancelledEvent

interface DragCancelledEvent<TData = any, TContext = any>
    extends AgDragEvent<'dragCancelled', TData, TContext> {}

interface DraggingChangedEvent

interface DraggingChangedEvent<TData = any>
    extends RowNodeEvent<'draggingChanged', TData> {}

interface DraggingEvent

interface DraggingEvent<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property dragItem

dragItem: DragItem;

The drag item that is being dragged

property dropZoneTarget

dropZoneTarget: HTMLElement;

The target element where the drop is happening

property event

event: MouseEvent;

The mouse event that triggered the dragging event

property fromNudge

fromNudge: boolean;

property hDirection

hDirection: HorizontalDirection | null;

The horizontal direction of the drag, can be 'left', 'right' or null

property vDirection

vDirection: VerticalDirection | null;

The vertical direction of the drag, can be 'up', 'down' or null

property x

x: number;

The X position in pixel relative to the drop target

property y

y: number;

The Y position in pixel relative to the drop target

interface DragItem

interface DragItem<TValue = any> {}

property columns

columns?: Column[];

When dragging columns, this contains the columns being dragged

property columnsInSplit

columnsInSplit?: Column[];

When dragging column groups, this contains the columns in the current group split.

property containerType

containerType?: ColumnPinnedType;

The pinned type of the container that created the Drag Item

property pivotState

pivotState?: {
    [key: string]: {
        pivot?: boolean;
        rowGroup?: boolean;
        aggFunc?: string | IAggFunc | null;
    };
};

When dragging columns, this contains the pivot state of the columns. This is only populated/used in column tool panel

property rowNode

rowNode?: IRowNode;

When dragging a row, this contains the row node being dragged When dragging multiple rows, this contains the row that started the drag.

property rowNodes

rowNodes?: IRowNode[];

When dragging multiple rows, this contains all rows being dragged

property value

value?: TValue;

Additional state

property visibleState

visibleState?: {
    [key: string]: boolean;
};

When dragging columns, this contains the visible state of the columns

interface DragListenerParams

interface DragListenerParams {}

property capturePointer

capturePointer?: boolean;

If true, the pointer will be captured, see https://developer.mozilla.org/en-US/docs/Web/API/Pointer_events

property dragStartPixels

dragStartPixels?: number;

After how many pixels of dragging should the drag operation start. Default is 4px.

property eElement

eElement: Element;

Dom element to add the drag handling to

property includeTouch

includeTouch?: boolean;

Include touch events for this Drag Listener

property stopPropagationForTouch

stopPropagationForTouch?: boolean;

If true, it will stop the propagation of Touch Events

interface DragSource

interface DragSource {}

property dragItemName

dragItemName:
    | ((draggingEvent?: DraggingEvent | null) => string | null | undefined)
    | string
    | null;

This name appears in the drag and drop image component when dragging.

property dragSourceDomDataKey

dragSourceDomDataKey?: string;

The drag source DOM Data Key, this is useful to detect if the origin grid is the same as the target grid.

property dragStartPixels

dragStartPixels?: number;

After how many pixels of dragging should the drag operation start. Default is 4.

property eElement

eElement: Element;

Element which, when dragged, will kick off the DnD process

property getDragItem

getDragItem: () => DragItem;

If eElement is dragged, then the dragItem is the object that gets passed around.

property sourceId

sourceId?: string;

Can be used to identify a specific component as the source

property type

type: DragSourceType;

The type of the drag source, used by the drop target to know where the drag originated from.

interface DragStartedEvent

interface DragStartedEvent<TData = any, TContext = any>
    extends AgDragEvent<'dragStarted', TData, TContext> {}

interface DragStoppedEvent

interface DragStoppedEvent<TData = any, TContext = any>
    extends AgDragEvent<'dragStopped', TData, TContext> {}

interface DropTarget

interface DropTarget
    extends AgDropTarget<
        DragSourceType,
        DragItem,
        DragAndDropIcon,
        GridDraggingEvent
    > {}

interface EditableCallbackParams

interface EditableCallbackParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

interface EditingCellPosition

interface EditingCellPosition extends RowPosition {}

property colId

colId: string;

Column id

property colKey

colKey?: string | Column;

Column instance.
Deprecated
Use colId instead.

property column

column?: Column;

Column instance.
Deprecated
Use colId instead.

property newValue

newValue?: any;

New pending value, use null to delete cell content

property oldValue

oldValue?: any;

Existing value, used only when retrieving current editing state, ignored when setting new editing state.

property state

state?: EditState;

Current editing state

interface EventCellRendererParams

interface EventCellRendererParams<TData = any, TValue = any, TContext = any> {}

property suppressMouseEventHandling

suppressMouseEventHandling?: (
    params: SuppressMouseEventHandlingParams<TData, TValue, TContext>
) => boolean;

Return true to prevent the grid from handling the following mouse events: 'click', 'dblclick', 'mousedown', 'touchstart'.
This will prevent actions performed via the mouse, such as focusing a cell, selecting a row, starting a cell selection, or starting an edit.
This will not prevent the grid from firing events for these mouse events (e.g. onCellClicked), but the events will have the isEventHandlingSuppressed property set to match the return value.

interface ExcelAlignment

interface ExcelAlignment {}

property horizontal

horizontal?:
    | 'Automatic'
    | 'Left'
    | 'Center'
    | 'Right'
    | 'Fill'
    | 'Justify'
    | 'CenterAcrossSelection'
    | 'Distributed'
    | 'JustifyDistributed';

Use this property to change the cell horizontal alignment. 'Automatic'

property indent

indent?: number;

Use this property to change the level of indentation in the cell. 0

property readingOrder

readingOrder?: 'RightToLeft' | 'LeftToRight' | 'Context';

Use this property to change the cell reading order. 'LeftToRight'

property rotate

rotate?: number;

The number of degrees between 0 and 359 to rotate the text. 0

property shrinkToFit

shrinkToFit?: boolean;

If set to true, the font size of the cell will automatically change to force the text to fit within the cell. false

property vertical

vertical?:
    | 'Automatic'
    | 'Top'
    | 'Bottom'
    | 'Center'
    | 'Justify'
    | 'Distributed'
    | 'JustifyDistributed';

Use this property to change the cell vertical alignment. 'Automatic'

property wrapText

wrapText?: boolean;

If set to true, multiline text will be displayed as multiline by Excel. false

interface ExcelBorder

interface ExcelBorder {}

property color

color?: string;

The color or the border. 'black'

property weight

weight?: 0 | 1 | 2 | 3;

The thickness of the border from 0 (thin) to 3 (thick). 0

interface ExcelBorders

interface ExcelBorders {}

interface ExcelCell

interface ExcelCell {}

property data

data?: ExcelData;

The data that will be added to the cell.

property mergeAcross

mergeAcross?: number;

The number of cells to span across (1 means span 2 columns). 0

property note

note?: ExcelNote;

Optional note/comment to export for this cell.

property ref

ref?: string;

Cell reference.

property styleId

styleId?: string | string[];

The ExcelStyle id to be associated with the cell.

interface ExcelColumn

interface ExcelColumn {}

property bestFit

bestFit?: boolean;

property displayName

displayName?: string;

property filterAllowed

filterAllowed?: boolean;

property hidden

hidden?: boolean;

property max

max?: number;

property min

min?: number;

property outlineLevel

outlineLevel?: number;

property s

s?: number;

property width

width?: number;

interface ExcelContentType

interface ExcelContentType {}

property ContentType

ContentType: string;

property Extension

Extension?: string;

property name

name: 'Default' | 'Override';

property PartName

PartName?: string;

interface ExcelData

interface ExcelData {}

property type

type: ExcelDataType | ExcelOOXMLDataType;

The type of data being in the cell.

property value

value: string | null;

The value of the cell.

interface ExcelExportMultipleSheetParams

interface ExcelExportMultipleSheetParams extends ExcelFileParams {}

property activeSheetIndex

activeSheetIndex?: number;

The index of the sheet to be marked as active by default. 0

property data

data: string[];

Array of strings containing the raw data for Excel workbook sheets. This property is only used when exporting to multiple sheets using api.exportMultipleSheetsAsExcel() and the data for each sheet is obtained by calling api.getSheetDataForExcel().

interface ExcelExportParams

interface ExcelExportParams
    extends ExcelFileParams,
        ExcelWorksheetConfigParams,
        ExportParams<ExcelRow[]> {}

interface ExcelFont

interface ExcelFont {}

property bold

bold?: boolean;

Set to true to set the cell text to bold. false

property color

color?: string;

The color of the cell font. '#000000'

property family

family?: string;

The family of the font to used in the cell. Options: Automatic,Roman,Swiss,Modern,Script,Decorative, 'Automatic'

property fontName

fontName?: string;

The name of the font to be used in the cell. 'Calibri'

property italic

italic?: boolean;

Set to true to display the cell font as italic. false

property outline

outline?: boolean;

Set to true to add a text outline. false

property shadow

shadow?: boolean;

Set to true to add text shadow. false

property size

size?: number;

Set this property to used a different font size other than the default.

property strikeThrough

strikeThrough?: boolean;

Set to true to add a strikeThrough line. false

property underline

underline?: 'Single' | 'Double';

Use this property to underline the cell text.

property verticalAlign

verticalAlign?: 'Superscript' | 'Subscript';

Use this property to change the default font alignment. Note: This is different than setting cell vertical alignment.

interface ExcelFreezeColumnsGetterParams

interface ExcelFreezeColumnsGetterParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column: Column;

interface ExcelFreezeRowsGetterParams

interface ExcelFreezeRowsGetterParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property node

node?: IRowNode<TData>;

Row node.

interface ExcelHeaderFooterConfig

interface ExcelHeaderFooterConfig {}

property all

all?: ExcelHeaderFooter;

The configuration for header and footer on every page.

property even

even?: ExcelHeaderFooter;

The configuration for header and footer on even numbered pages only.

property first

first?: ExcelHeaderFooter;

The configuration for header and footer on the first page only.

interface ExcelHeaderFooterContent

interface ExcelHeaderFooterContent {}

property font

font?: ExcelFont;

The font style of the header/footer value.

property image

image?: ExcelHeaderFooterImage;

When value is &[Picture], this should be used as the referenced image.

property position

position?: 'Left' | 'Center' | 'Right';

Configures where the text should be added: Left, Center or Right. 'Left'

property value

value: string;

The value of the text to be included in the header.

interface ExcelHeaderFooterImage

interface ExcelHeaderFooterImage extends BaseImage {}

property brightness

brightness: number;

The brightness of the image between 0 and 100 (if recolor is used, this value will only be applied for Grayscale). Default 50

property contrast

contrast: number;

The contrast of the image between 0 and 100. (If recolor is used, this value will only be applied for Grayscale.). Default 50

property height

height: number;

The height of the image in pixels.

property recolor

recolor?: 'Grayscale' | 'Black & White' | 'Washout';

Set this property to select a preset that changes the appearance of the image.

property width

width: number;

The width of the image in pixels.

interface ExcelImage

interface ExcelImage extends BaseImage {}

property fitCell

fitCell?: boolean;

If set to true, the image will cover the whole cell that is being imported to. This property does not apply to images in the Header/Footer false

property height

height?: number;

The height of the image in pixels. If this value is not selected, fitCell will be automatically set to true.

property position

position?: ExcelImagePosition;

Position of the image.

property recolor

recolor?: 'Grayscale' | 'Sepia' | 'Washout';

Set this property to select a preset that changes the appearance of the image.

property rotation

rotation?: number;

Set a value between 0 - 359 that will indicate the number of degrees to rotate the image clockwise. 0

property transparency

transparency?: number;

Set a value between 0 - 100 that will indicate the percentage of transparency of the image. 0

property width

width?: number;

The width of the image in pixels. If this value is not selected, fitCell will be automatically set to true.

interface ExcelImagePosition

interface ExcelImagePosition {}

property colSpan

colSpan?: number;

The amount of columns this image will cover. 1

property column

column?: number;

The column containing this image. This property is set automatically, don't change it unless you know what you are doing.

property offsetX

offsetX?: number;

The amount in pixels the image should be offset horizontally. 0

property offsetY

offsetY?: number;

The amount in pixels the image should be offset vertically. 0

property row

row?: number;

The row containing this image. This property is set automatically, don't change it unless you know what you are doing.

property rowSpan

rowSpan?: number;

The amount of rows this image will cover. 1

interface ExcelInterior

interface ExcelInterior {}

property color

color?: string;

The colour to be used as a secondary colour combined with patterns.

property pattern

pattern:
    | 'None'
    | 'Solid'
    | 'Gray75'
    | 'Gray50'
    | 'Gray25'
    | 'Gray125'
    | 'Gray0625'
    | 'HorzStripe'
    | 'VertStripe'
    | 'ReverseDiagStripe'
    | 'DiagStripe'
    | 'DiagCross'
    | 'ThickDiagCross'
    | 'ThinHorzStripe'
    | 'ThinVertStripe'
    | 'ThinReverseDiagStripe'
    | 'ThinDiagStripe'
    | 'ThinHorzCross'
    | 'ThinDiagCross';

Use this property to set background color patterns.

interface ExcelNote

interface ExcelNote {}

property author

author?: string;

Optional author name shown in Excel.

property text

text: string;

The body text to export in the Excel note/comment.

interface ExcelNumberFormat

interface ExcelNumberFormat {}

property format

format: string;

Use this property to provide a pattern to format a number. (eg. 10000 could become $10,000.00).

interface ExcelOOXMLTemplate

interface ExcelOOXMLTemplate {}

method convertType

convertType: (type: string) => string;

method getTemplate

getTemplate: (config?: any, idx?: number, currentSheet?: number) => XmlElement;

interface ExcelProtection

interface ExcelProtection {}

property hideFormula

hideFormula: boolean;

Set to true to hide formulas within protected cells. false

property protected

protected: boolean;

Set to false to disable cell protection (locking) true

interface ExcelRelationship

interface ExcelRelationship {}

property Id

Id: string;

property Target

Target: string;

property Type

Type: string;

interface ExcelRow

interface ExcelRow {}

property cells

cells: ExcelCell[];

An array of ExcelCells.

property height

height?: number;

The height of the row.

property hidden

hidden?: boolean;

Hidden state.

property outlineLevel

outlineLevel?: number;

The indentation level if the current row is part of a row group.

interface ExcelSheetMargin

interface ExcelSheetMargin {}

property bottom

bottom?: number;

The sheet bottom margin. 0.75

footer?: number;

The sheet footer margin. 0.3

header?: number;

The sheet header margin. 0.3

property left

left?: number;

The sheet left margin. 0.7

property right

right?: number;

The sheet right margin. 0.7

property top

top?: number;

The sheet top margin. 0.75

interface ExcelSheetNameGetterParams

interface ExcelSheetNameGetterParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

interface ExcelSheetPageSetup

interface ExcelSheetPageSetup {}

property orientation

orientation?: 'Portrait' | 'Landscape';

Use this property to change the print orientation. 'Portrait'

property pageSize

pageSize?:
    | 'Letter'
    | 'Letter Small'
    | 'Tabloid'
    | 'Ledger'
    | 'Legal'
    | 'Statement'
    | 'Executive'
    | 'A3'
    | 'A4'
    | 'A4 Small'
    | 'A5'
    | 'A6'
    | 'B4'
    | 'B5'
    | 'Folio'
    | 'Envelope'
    | 'Envelope DL'
    | 'Envelope C5'
    | 'Envelope B5'
    | 'Envelope C3'
    | 'Envelope C4'
    | 'Envelope C6'
    | 'Envelope Monarch'
    | 'Japanese Postcard'
    | 'Japanese Double Postcard';

Use this property to set the sheet size. 'Letter'

interface ExcelSheetProtection

interface ExcelSheetProtection {}

property autoFilter

autoFilter?: boolean;

Allow using AutoFilter when worksheet protection is enabled. false

property deleteColumns

deleteColumns?: boolean;

Allow deleting columns when worksheet protection is enabled. false

property deleteRows

deleteRows?: boolean;

Allow deleting rows when worksheet protection is enabled. false

property formatCells

formatCells?: boolean;

Allow formatting cells when worksheet protection is enabled. false

property formatColumns

formatColumns?: boolean;

Allow formatting columns when worksheet protection is enabled. false

property formatRows

formatRows?: boolean;

Allow formatting rows when worksheet protection is enabled. false

property insertColumns

insertColumns?: boolean;

Allow inserting columns when worksheet protection is enabled. false

property insertHyperlinks

insertHyperlinks?: boolean;

Allow inserting hyperlinks when worksheet protection is enabled. false

property insertRows

insertRows?: boolean;

Allow inserting rows when worksheet protection is enabled. false

property password

password?: string;

Optional password required to unprotect the worksheet.

property pivotTables

pivotTables?: boolean;

Allow using PivotTables when worksheet protection is enabled. false

property selectLockedCells

selectLockedCells?: boolean;

Allow selecting locked cells when worksheet protection is enabled. true

property selectUnlockedCells

selectUnlockedCells?: boolean;

Allow selecting unlocked cells when worksheet protection is enabled. true

interface ExcelStyle

interface ExcelStyle {}

property alignment

alignment?: ExcelAlignment;

Use this property to customise cell alignment properties.

property borders

borders?: ExcelBorders;

Use this property to customise cell borders.

property dataType

dataType?: ExcelDataType;

Use this property to specify the type of data being exported.

property font

font?: ExcelFont;

Use this property to customise the font used in the cell.

property id

id: string;

The id of the Excel Style, this should match a CSS cell class.

property interior

interior?: ExcelInterior;

Use this property to customise the cell background.

property numberFormat

numberFormat?: ExcelNumberFormat;

Use this property to customise the cell value as a formatted number.

property protection

protection?: ExcelProtection;

Use this property to configure cell locking and formula visibility for the exported worksheet. This must be used together with ExcelExportParams.protectSheet.

interface ExcelTable

interface ExcelTable {}

property columns

columns: ExcelColumn[];

property rows

rows: ExcelRow[];

interface ExcelTableConfig

interface ExcelTableConfig {}

property highlightFirstColumn

highlightFirstColumn?: boolean;

Set this property to true to show the first column in bold/highlighted style.
false

property highlightLastColumn

highlightLastColumn?: boolean;

Set this property to true to show the last column in bold/highlighted style.
false

property name

name?: string;

This property is used to set the table name. It should be an alphanumeric string with no special characters. 'AG-GRID-TABLE'

property showColumnStripes

showColumnStripes?: boolean;

Set this property to true to show column stripes.
false

property showFilterButton

showFilterButton?: boolean | 'match';

Set this property to false to disable the filter button at the exported Excel table header. Set it to true to show the filter button on all columns. Set it to match to show the filter button only if the column has a filter allowed.
match

property showRowStripes

showRowStripes?: boolean;

Set this property to false to hide the row stripes.
true

interface ExcelWorksheet

interface ExcelWorksheet {}

property name

name: string;

property table

table: ExcelTable;

interface ExcelWorksheetConfigParams

interface ExcelWorksheetConfigParams {}

property addImageToCell

addImageToCell?: (
    rowIndex: number,
    column: Column,
    value: string
) =>
    | {
          image: ExcelImage;
          value?: string;
      }
    | undefined;

Use to export an image for the gridCell in question.

property autoConvertFormulas

autoConvertFormulas?: boolean;

If set to true, this will try to convert any cell that starts with = to a formula, instead of setting the cell value as regular string that starts with =. false

property columnWidth

columnWidth?: number | ((params: ColumnWidthCallbackParams) => number);

Defines the default column width. If no value is present, each column will have value currently set in the application with a min value of 75px. This property can also be supplied a callback function that returns a number.

property exportAsExcelTable

exportAsExcelTable?: boolean | ExcelTableConfig;

Used to add an Excel table to the spreadsheet. Set to true to use default export table config, or provide a config object.
false

property freezeColumns

freezeColumns?: 'pinned' | ExcelFreezeColumnsGetter;

Use this property to select to freeze columns at the start of the grid (this will be the columns at the right for RTL). - pinned - Freeze all pinned left (right for RTL grids) columns. - A callback function that will freeze columns until a value other than true is returned. After that, this callback will no longer be executed.

property freezeRows

freezeRows?: 'headers' | 'headersAndPinnedRows' | ExcelFreezeRowsGetter;

Use this property to select to freeze rows at the top of the exported sheet. - headers - Freeze all grid headers at the top. - headersAndPinnedRows - Freeze all headers and pinned top rows. - A callback function that will freeze rows until a value other than true is returned, after that, this callback will no longer be executed. Note that using a callback will automatically freeze all header rows.

property headerFooterConfig

headerFooterConfig?: ExcelHeaderFooterConfig;

The configuration for header and footers.

property headerRowHeight

headerRowHeight?: number | ((params: RowHeightCallbackParams) => number);

The height in pixels of header rows. Defaults to Excel default value. This property can also be supplied a callback function that returns a number.

property margins

margins?: ExcelSheetMargin;

The Excel document page margins. Relevant for printing.

property pageSetup

pageSetup?: ExcelSheetPageSetup;

Allows you to setup the page orientation and size.

property processNoteCallback

processNoteCallback?: (
    params: ProcessNoteForExportParams
) => ExcelNote | null | undefined;

Allows customising, suppressing, or injecting Excel notes/comments for exported cells.
Return undefined to keep the default behaviour, null to suppress the note for the current cell, or an ExcelNote to export a custom note.

property protectSheet

protectSheet?: boolean | ExcelSheetProtection;

If true, protects the worksheet to enforce ExcelStyle.protection settings. Provide an ExcelSheetProtection config object to allow specific actions on the protected sheet. false

property rightToLeft

rightToLeft?: boolean;

Use to set the direction for the worksheet. - true: Sets the direction to right-to-left (RTL). - false: Sets the direction to left-to-right (LTR). - undefined: Exports the worksheet according to the current direction of the grid as set by gridOptions.enableRtl. undefined

property rowGroupExpandState

rowGroupExpandState?: 'expanded' | 'collapsed' | 'match';

The expand/collapse state of each row group in the Excel Document. - expanded: All row groups will be expanded by default. - collapsed: All row groups will be collapsed by default. - match: The row groups will match their current state in the Grid. 'expanded'

property rowHeight

rowHeight?: number | ((params: RowHeightCallbackParams) => number);

The height in pixels of all rows. Defaults to Excel default value. This property can also be supplied a callback function that returns a number.

property sheetName

sheetName?: string | ExcelSheetNameGetter;

The name of the sheet in Excel where the grid will be exported. Either a string or a function that returns a string can be used. If a function is used, it will be called once before the export starts. There is a max limit of 31 characters per sheet name. 'ag-grid'

property suppressColumnOutline

suppressColumnOutline?: boolean;

If true, the outline (controls to expand and collapse) for Group Columns will not be added automatically to the Excel Document. false.

property suppressGridNotesExport

suppressGridNotesExport?: boolean;

Set to true to suppress exporting cell notes from the grid notesDataSource. Callback-based note injection via processNoteCallback still works when this is set. false

property suppressRowOutline

suppressRowOutline?: boolean;

If true, the outline (controls to expand and collapse) for Row Groups will not be added automatically to the Excel Document. false.

interface ExpandCollapseAllEvent

interface ExpandCollapseAllEvent<TData = any, TContext = any>
    extends ExpandOrCollapseAllEvent<TData, TContext> {}

Deprecated
v32 Please use ExpandOrCollapseAllEvent instead.

interface ExpandedChangedEvent

interface ExpandedChangedEvent<TData = any>
    extends RowNodeEvent<'expandedChanged', TData> {}

interface ExpandOrCollapseAllEvent

interface ExpandOrCollapseAllEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'expandOrCollapseAll', TData, TContext> {}

property source

source: string;

interface ExportFileNameGetterParams

interface ExportFileNameGetterParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

interface ExportingOverlayUserParams

interface ExportingOverlayUserParams extends ProvidedOverlayUserParams {}

interface ExportParams

interface ExportParams<T> extends BaseExportParams {}

property appendContent

appendContent?: T;

Content to put at the bottom of the exported sheet.

property exportRowNumbers

exportRowNumbers?: boolean;

Set to true to allow the contents of the Header Row Column to be exported.

property getCustomContentBelowRow

getCustomContentBelowRow?: (
    params: ProcessRowGroupForExportParams
) => T | undefined;

A callback function to return content to be inserted below a row in the export.

property prependContent

prependContent?: T;

Content to put at the top of the exported sheet.

interface FieldPickerValueSelectedEvent

interface FieldPickerValueSelectedEvent<TData = any, TContext = any>
    extends FieldValueEvent<'fieldPickerValueSelected', TData, TContext> {}

property fromEnterKey

fromEnterKey: boolean;

interface FieldPickerValueSelectedEvent

interface FieldPickerValueSelectedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'fieldPickerValueSelected', TData, TContext> {}

interface FieldValueChangedEvent

interface FieldValueChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'fieldValueChanged', TData, TContext> {}

interface FieldValueEvent

interface FieldValueEvent<
    T extends AgEventType = 'fieldValueChanged',
    TData = any,
    TContext = any
> extends AgGlobalEvent<T, TData, TContext> {}

property value

value: any;

interface FillEndEvent

interface FillEndEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'fillEnd', TData, TContext> {}

property finalRange

finalRange: CellRange;

property initialRange

initialRange: CellRange;

interface FillHandleOptions

interface FillHandleOptions<TData = any> {}

Configuration options for the fill handle

property direction

direction?: 'x' | 'y' | 'xy';

Set to 'x' to force the fill handle direction to horizontal, or set to 'y' to force the fill handle direction to vertical. 'xy'

property mode

mode: 'fill';

property setFillValue

setFillValue?: <TContext = any>(
    params: FillOperationParams<TData, TContext>
) => any;

Callback to fill values instead of simply copying values or increasing number values using linear progression.

property suppressClearOnFillReduction

suppressClearOnFillReduction?: boolean;

Set this to true to prevent cell values from being cleared when the Range Selection is reduced by the Fill Handle. false

interface FillOperationParams

interface FillOperationParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column: Column;

The Column of the current cell being changed.

property currentCellValue

currentCellValue: any;

The value of the cell being currently processed by the Fill Operation.

property currentIndex

currentIndex: number;

The index of the current processed value.

property event

event: MouseEvent;

The mouse event for the fill operation.

property initialFormattedValues

initialFormattedValues: any[];

The values that were present before processing, after being formatted by their value formatter

property initialNonAggregatedValues

initialNonAggregatedValues: any[];

The values that were present before processing, without the aggregation function.

property initialValues

initialValues: any[];

The values that were present before processing started.

property rowNode

rowNode: IRowNode<TData>;

The RowNode of the current cell being changed.

property values

values: any[];

The values that have been processed by the fill operation.

interface FillStartEvent

interface FillStartEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'fillStart', TData, TContext> {}

interface FilterActionParams

interface FilterActionParams {}

property action

action: FilterAction;

Action to perform

property colId

colId?: string;

Column ID to perform action on. If undefined, will run for all columns.

interface FilterChangedEvent

interface FilterChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'filterChanged', TData, TContext> {}

property afterDataChange

afterDataChange?: boolean;

True if the filter was changed as a result of data changing

property afterFloatingFilter

afterFloatingFilter?: boolean;

True if filter was changed via floating filter

property columns

columns: Column[];

Columns affected by the filter change. Array contents depend on the source of the event.
- Expect 1 element for UI-driven column filter changes. - Expect 0-N elements (all affected columns) for calls to api.setFilterModel(). - Expect 0-N elements (removed columns) for calls to api.setColumnDefs(). - Expect 0 elements for quick-filters and calls to api.onFilterChanged().

property source

source?: FilterChangedEventSourceType;

The source that triggered the filter change event. Can be one of the following: - api - triggered by an API call - quickFilter - triggered by user filtering from Quick Filter - columnFilter - triggered by user filtering from Column Menu - advancedFilter - triggered by user filtering from Advanced Filter

interface FilterClosedEvent

interface FilterClosedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'filterClosed', TData, TContext> {}

property column

column: Column;

interface FilterDestroyedEvent

interface FilterDestroyedEvent<TData = any, TContext = any>
    extends BaseFilterDestroyedEvent<'filterDestroyed', TData, TContext> {}

interface FilterDisplay

interface FilterDisplay<TData = any, TContext = any, TModel = any, TState = any>
    extends SharedFilterUi {}

method refresh

refresh: (
    newParams: FilterDisplayParams<TData, TContext, TModel, TState>
) => boolean;

Called when the column definition, state or model is updated.

interface FilterDisplayComp

interface FilterDisplayComp<TData = any, TContext = any, TModel = any>
    extends IComponent<FilterDisplayParams<TData, TContext, TModel>>,
        FilterDisplay<TData, TContext, TModel> {}

interface FilterDisplayParams

interface FilterDisplayParams<
    TData = any,
    TContext = any,
    TModel = any,
    TState = any
> extends SharedFilterParams<TData, TContext> {}

property additionalEventAttributes

additionalEventAttributes?: any;

If this refresh was as a result of the filter triggering an update with additional event attributes, these will be set here

property getHandler

getHandler: () => FilterHandler<TData, TContext, TModel>;

Get the filter handler instance. If using a SimpleColumnFilter, the handler is is a wrapper object containing the provided doesFilterPass callback.

property model

model: TModel | null;

The current applied filter model for the component.

property onAction

onAction: (
    action: FilterAction,
    additionalEventAttributes?: any,
    event?: KeyboardEvent
) => void;

Can be called to manually apply any of the filter actions that would be done via buttons.
Parameter additionalEventAttributes
If provided, will be passed to the filter changed event
Parameter event
If the action was via the keyboard, provide the event here for correct focus handling.

property onModelChange

onModelChange: (model: TModel | null, additionalEventAttributes?: any) => void;

Callback that should be called every time the model in the component changes.
Parameter additionalEventAttributes
If provided, will be passed to the filter changed event

property onStateChange

onStateChange: (componentState: FilterDisplayState<TModel, TState>) => void;

If using the filter with apply buttons, callback that should be called every time the unapplied model in the component changes.

property onUiChange

onUiChange: (additionalEventAttributes?: any) => void;

Callback that can be optionally called every time the filter UI changes. The grid will respond with emitting a FilterUiChangedEvent. Apart from emitting the event, the grid takes no further action. The callback takes one optional parameter which, if included, will get merged to the FilterUiChangedEvent object.

property source

source: FilterDisplaySource;

property state

state: FilterDisplayState<TModel, TState>;

The current state to display in the component.

interface FilterDisplayState

interface FilterDisplayState<TModel = any, TState = any> {}

property model

model: TModel | null;

The current filter model to be displayed in the UI.

property state

state?: TState;

If there is additional UI state not represented in the filter model, this will be stored here.

property valid

valid?: boolean;

If false and apply button is present, apply button will be disabled.

interface FilterHandler

interface FilterHandler<
    TData = any,
    TContext = any,
    TModel = any,
    TCustomParams = any
> extends SharedFilter,
        ReadOnlyFloatingFilterParent<TModel> {}

method destroy

destroy: () => void;

Optional: Gets called once by grid when the component is being removed; if your component needs to do any cleanup, do it here

method doesFilterPass

doesFilterPass: (
    params: DoesFilterPassParams<TData, TContext, TModel, TCustomParams>
) => boolean;

The grid will ask each active filter, in turn, whether each row in the grid passes. If any filter fails, then the row will be excluded from the final set.

method getModelAsString

getModelAsString: (
    model: TModel | null,
    source?: 'floating' | 'filterToolPanel'
) => string;

Optional: Used by AG Grid when rendering floating filters and there isn't a floating filter associated for this filter. This will happen if you create a custom filter and NOT a custom floating filter. This is also used by the new filters tool panel to display the summary.

method init

init: (
    params: FilterHandlerParams<TData, TContext, TModel, TCustomParams>
) => void;

Optional: Called once when the handler is created.

method processModelToApply

processModelToApply: (model: TModel | null) => TModel | null;

Optional: When using an apply button with the filter, this method will be called before the apply happens, The returned model will be applied, allowing for any validation or updates to be performed.

method refresh

refresh: (
    params: FilterHandlerParams<TData, TContext, TModel, TCustomParams>
) => void;

Optional: Called every time the handler is updated, e.g. when the model changes.

interface FilterHandlerBaseParams

interface FilterHandlerBaseParams<
    TData = any,
    TContext = any,
    TModel = any,
    TCustomParams = any
> extends SharedFilterParams<TData, TContext> {}

property filterParams

filterParams: TCustomParams;

property onModelAsStringChange

onModelAsStringChange: () => void;

When using the read-only floating filter or the new filters tool panel, the display value is retrieved from the handler via getModelAsString(). This will automatically be called again when the filter model changes. If the display value needs to be updated without the filter model changing, this function can be called to trigger a refresh.

property onModelChange

onModelChange: (model: TModel | null, additionalEventAttributes?: any) => void;

interface FilterHandlerDestroyedEvent

interface FilterHandlerDestroyedEvent<TData = any, TContext = any>
    extends BaseFilterDestroyedEvent<'filterHandlerDestroyed', TData, TContext> {}

This is a special version of FilterDestroyedEvent, that only fires if the UI was never created (but the handler existed)

interface FilterHandlerParams

interface FilterHandlerParams<
    TData = any,
    TContext = any,
    TModel = any,
    TCustomParams = any
> extends FilterHandlerBaseParams<TData, TContext, TModel, TCustomParams> {}

property additionalEventAttributes

additionalEventAttributes?: any;

If this refresh was as a result of the filter triggering an update with additional event attributes, these will be set here

property model

model: TModel | null;

property source

source: FilterHandlerSource;

interface FilterModel

interface FilterModel {}

FilterModel represents the applied filter model for all columns in the grid keyed by the column id. If using inbuilt AG Grid filters then the type of the column filter model could be one of: TextFilterModel, NumberFilterModel, DateFilterModel, SetFilterModel, IMultiFilterModel, AdvancedFilterModel

index signature

[colId: string]: any;

interface FilterModifiedEvent

interface FilterModifiedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'filterModified', TData, TContext> {}

property column

column: Column;

property filterInstance

filterInstance: IFilterComp;

interface FilterOpenedEvent

interface FilterOpenedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'filterOpened', TData, TContext> {}

property column

column: Column | ProvidedColumnGroup;

Column / ProvidedColumnGroup that contains the filter

property eGui

eGui: HTMLElement;

Parent element of the filter

property source

source: FilterRequestSource;

Source of the open request

interface FilterPanelDetailState

interface FilterPanelDetailState extends FilterPanelBaseState {}

property activeFilterDef

activeFilterDef?: SelectableFilterDef;

property afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

property afterGuiDetached

afterGuiDetached: () => void;

property detail

detail: HTMLElement;

property expanded

expanded: true;

property filterDefs

filterDefs?: SelectableFilterDef[];

interface FilterPanelSummaryState

interface FilterPanelSummaryState extends FilterPanelBaseState {}

property expanded

expanded: false;

property summary

summary: string;

interface FilterState

interface FilterState {}

property selectableFilters

selectableFilters?: {
    [colId: string]: number;
};

Currently selected filter when using new filter tool panel with agSelectableColumnFilter

interface FiltersToolPanelState

interface FiltersToolPanelState {}

property expandedColIds

expandedColIds: string[];

property expandedGroupIds

expandedGroupIds: string[];

interface FilterSwitchedEvent

interface FilterSwitchedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'filterSwitched', TData, TContext> {}

property column

column: Column;

interface FilterUiChangedEvent

interface FilterUiChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'filterUiChanged', TData, TContext> {}

property column

column: Column;

interface FilterWrapperParams

interface FilterWrapperParams {}

Common filter params for all column filters (when using enableFilterHandlers = true)

property buttons

buttons?: FilterAction[];

Specifies the buttons to be shown in the filter, in the order they should be displayed in. The options are:
- 'apply': If the Apply button is present, the filter is only applied after the user hits the Apply button. - 'clear': The Clear button will clear the (form) details of the filter without removing any active filters on the column. - 'reset': The Reset button will clear the details of the filter and any active filters on that column. - 'cancel': The Cancel button will discard any changes that have been made to the filter in the UI, restoring the applied model.

property closeOnApply

closeOnApply?: boolean;

When this is set to true, the following will happen after clicking a filter button: - Apply closes popup. - Reset closes popup if Apply button is present. - Cancel closes popup.
false

property readOnly

readOnly?: boolean;

If set to true, will disable and hide any buttons.
false

property useForm

useForm?: boolean;

If true, the filter will be wrapped in a form element that applies on submit.

interface FindCellParams

interface FindCellParams<TData = any, TValue = any> {}

property column

column: Column<TValue> | null;

null if the cell is a full width row or detail row.

property node

node: IRowNode<TData>;

interface FindCellValueParams

interface FindCellValueParams<TData = any, TValue = any>
    extends FindCellParams<TData, TValue> {}

property precedingNumMatches

precedingNumMatches?: number;

Useful when trying to convert multiple values within a cell separately. The value supplied here will be treated as the number of matches that appear before value in the cell, and the active match will then be offset correctly.

property value

value: string;

Display value to search within.

interface FindChangedEvent

interface FindChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'findChanged', TData, TContext> {}

property activeMatch

activeMatch: FindMatch<TData> | undefined;

The active match, or undefined if no active match.

interface FindDetailCellRendererParams

interface FindDetailCellRendererParams<TData = any> {}

property getFindMatches

getFindMatches?: GetFindMatches<TData>;

If using Find across Master / Detail, this will be called to work out the number of matches that would be within the custom detail cell.

interface FindDetailGridCellRendererParams

interface FindDetailGridCellRendererParams<TData = any> {}

property getFindMatches

getFindMatches?: GetFindMatches<TData>;

If using Find across Master / Detail and the Detail Grid is not open, this will be called to work out the number of matches that would be within the Detail Grid.

interface FindFullWidthCellRendererParams

interface FindFullWidthCellRendererParams<TData = any> {}

property getFindMatches

getFindMatches?: GetFindMatches<TData>;

If using Find with full width rows, this will be called to work out the number of matches that would be within the full width row.

interface FindGroupRowRendererParams

interface FindGroupRowRendererParams<TData = any, TValue = any> {}

property getFindText

getFindText?: GetFindTextFunc<TData, TValue>;

When using Find with a custom group row renderer, this allows providing a custom value to search within. E.g. if the group row renderer is displaying text that is different from the formatted value. Returning null means Find will not search within the group row.

interface FindMatch

interface FindMatch<TData = any, TValue = any> {}

property column

column: Column<TValue> | null;

Will be null if the match is within a full width row or detail row.

property node

node: IRowNode<TData>;

property numInMatch

numInMatch: number;

The number of the match within the cell (starting from 1).

property numOverall

numOverall: number;

The number of the match within all the matches in the grid (starting from 1).

interface FindOptions

interface FindOptions {}

property currentPageOnly

currentPageOnly?: boolean;

Match values in the current page only (when pagination enabled).

property searchDetail

searchDetail?: boolean;

Perform searches across Detail Grids or Custom Detail Cells when using Master/Detail.

interface FindPart

interface FindPart {}

property match

match?: boolean;

true if a match.

property value

value: string;

Partial display value.

interface FirstChildChangedEvent

interface FirstChildChangedEvent<TData = any>
    extends RowNodeEvent<'firstChildChanged', TData> {}

Deprecated
v33 Use the modelUpdated event instead and calculate whether the first child has changed.

interface FirstDataRenderedEvent

interface FirstDataRenderedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'firstDataRendered', TData, TContext> {}

property firstRow

firstRow: number;

Index of the first rendered row

property lastRow

lastRow: number;

Index of the last rendered row

property cells

cells: any;

interface FlashCellsParams

interface FlashCellsParams<TData = any> extends GetCellsParams<TData> {}

property fadeDuration

fadeDuration?: number;

The duration in milliseconds of how long the "flashed" state animation takes to fade away after the timer set by flashDuration has completed.

property flashDuration

flashDuration?: number;

The duration in milliseconds of how long a cell should remain in its "flashed" state.

interface FloatingFilterDisplay

interface FloatingFilterDisplay<
    TData = any,
    TContext = any,
    TModel = any,
    TCustomParams = object
> extends BaseFloatingFilter {}

method refresh

refresh: (
    params: FloatingFilterDisplayParams<TData, TContext, TModel, TCustomParams>
) => void;

Called when the column definition or model is updated.

interface FloatingFilterDisplayComp

interface FloatingFilterDisplayComp<
    TData = any,
    TContext = any,
    TModel = any,
    TCustomParams = object
> extends FloatingFilterDisplay<TData, TContext, TModel, TCustomParams>,
        IComponent<
            FloatingFilterDisplayParams<TData, TContext, TModel, TCustomParams>
        > {}

interface FloatingFilterDisplayParams

interface FloatingFilterDisplayParams<
    TData = any,
    TContext = any,
    TModel = any,
    TCustomParams = object
> extends SharedFloatingFilterParams<TData, TContext> {}

property filterParams

filterParams: TCustomParams;

The params object passed to the filter. This is to allow the floating filter access to the configuration of the parent filter. For example, the provided filters use debounceMs from the parent filter params.

property getHandler

getHandler: () => FilterHandler<TData, TContext, TModel, TCustomParams>;

Get the filter handler instance. If using a SimpleColumnFilter, the handler is is a wrapper object containing the provided doesFilterPass callback.

property model

model: TModel | null;

The current applied filter model for the column.

property onModelChange

onModelChange: (model: TModel | null, additionalEventAttributes?: any) => void;

Callback that should be called every time the model in the component changes.
Parameter additionalEventAttributes
If provided, will be passed to the filter changed event

property onUiChange

onUiChange: (additionalEventAttributes?: any) => void;

Callback that can be optionally called every time the floating filter UI changes. The grid will respond with emitting a FloatingFilterUiChangedEvent. Apart from emitting the event, the grid takes no further action. The callback takes one optional parameter which, if included, will get merged to the FloatingFilterUiChangedEvent object.

property source

source: 'init' | 'ui' | 'filter' | 'api' | 'colDef' | 'dataChanged';

interface FloatingFilterUiChangedEvent

interface FloatingFilterUiChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'floatingFilterUiChanged', TData, TContext> {}

property column

column: Column;

interface FocusedCellState

interface FocusedCellState extends RowPosition {}

property colId

colId: string;

interface FocusGridInnerElementParams

interface FocusGridInnerElementParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property fromBottom

fromBottom: boolean;

This will be true if the focus is coming from and element below the grid in the DOM structure.

interface FormulaDataSource

interface FormulaDataSource {}

Control where formula data is stored/retrieved from. Idea for implementation could be to store the formula back into the row data Idea for implementation could be to have a separate map store for formulas

method destroy

destroy: () => void;

Called by the grid when the data source is being disposed.

method getFormula

getFormula: (params: GetFormulaParams) => string | undefined;

Return the formula string for the given cell.

method init

init: (params: FormulaDataSourceParams) => void;

Initialise the data source so that the user can take a reference to the gridApi if they are going to need it.

method setFormula

setFormula: (params: SetFormulaParams) => void;

Set the formula string for the given cell.

interface FormulaDataSourceParams

interface FormulaDataSourceParams extends AgGridCommon<any, any> {}

interface FullRowEditValidationParams

interface FullRowEditValidationParams {}

property editorsState

editorsState: EditingCellPosition[];

interface FullWidthCellKeyDownEvent

interface FullWidthCellKeyDownEvent<TData = any, TContext = any>
    extends RowEvent<'cellKeyDown', TData, TContext> {}

interface FullWidthNotesDataSource

interface FullWidthNotesDataSource<TMetadata = any> extends BaseNotesDataSource {}

Control where notes are stored/retrieved from for both cells and full width rows.

property supportsFullWidthRows

supportsFullWidthRows: true;

Enables full width row notes for this datasource.

method getNote

getNote: (
    params: FullWidthNotesDataSourceGetNoteParams
) => Note<TMetadata> | undefined;

Return the note for the given cell or full width row.

method setNote

setNote: (params: FullWidthNotesDataSourceSetNoteParams<TMetadata>) => void;

Set or clear the note for the given cell or full width row.

interface FullWidthRowFocusedEvent

interface FullWidthRowFocusedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'fullWidthRowFocused', TData, TContext>,
        CellFocusedParams {}

property fromBelow

fromBelow: boolean;

interface FullWidthRowNoteParams

interface FullWidthRowNoteParams {}

property location

location: 'fullWidthRow';

Location is fullWidthRow for full width row notes.

property pinned

pinned?: 'left' | 'right';

If embedFullWidthRows=true identifies the pinned section the note has been applied to.

property rowNode

rowNode: IRowNode;

Full width row

interface GetCellEditorInstancesParams

interface GetCellEditorInstancesParams<TData = any> extends GetCellsParams<TData> {}

interface GetCellRendererInstancesParams

interface GetCellRendererInstancesParams<TData = any>
    extends GetCellsParams<TData> {}

interface GetCellValueParams

interface GetCellValueParams<TValue = any> {}

property colKey

colKey: string | Column<TValue>;

The column to read (field name, colId, or Column object)

property from

from?: CellValueResolveFrom;

Controls how pending edits affect the returned value. - 'edit' (default): Returns the live editor value if the cell is being edited, then any pending batch value, then committed data. - 'batch': Returns pending batch values but excludes live editor typing. Useful for dependent calculations in valueGetter. - 'data': Returns committed data only, ignoring all edit state.

property rowNode

rowNode: IRowNode;

The row to read from

property useFormatter

useFormatter?: boolean;

If true, returns the formatted string (via the column's valueFormatter) instead of the raw value.

interface GetChartImageDataUrlParams

interface GetChartImageDataUrlParams {}

property chartId

chartId: string;

The id of the created chart.

property fileFormat

fileFormat?: string;

A string indicating the image format. The default format type is image/png. Options: image/png, image/jpeg

interface GetChartMenuItemsParams

interface GetChartMenuItemsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property chartId

chartId: string;

Chart ID that the menu is displayed for

property defaultItems

defaultItems: DefaultChartMenuItem[];

List of the items that would be displayed by default

interface GetChartToolbarItemsParams

interface GetChartToolbarItemsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property defaultItems

defaultItems?: ChartToolbarMenuItemOptions[];

interface GetContextMenuItemsParams

interface GetContextMenuItemsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column: Column | null;

The column, if a cell was clicked, otherwise null.

property defaultItems

defaultItems: DefaultMenuItem[] | undefined;

Names of the items that would be provided by default.

property event

event: MouseEvent | Touch;

The ContextMenu event that triggered the creation of the Context Menu

property node

node: IRowNode<TData> | null;

The row node, if a cell was clicked, otherwise null.

property value

value: any;

The value, if a cell was clicked, otherwise null.

interface GetDetailRowDataParams

interface GetDetailRowDataParams<TData = any, TDetail = any> {}

property data

data: TData;

Data for the current row.

property node

node: IRowNode<TData>;

Row node for the details request.

method successCallback

successCallback: (rowData: TDetail[]) => void;

Success callback: pass the rows back for the grid request.

interface GetFindMatchesParams

interface GetFindMatchesParams<TData = any> {}

property data

data: TData;

property getMatchesForValue

getMatchesForValue: (value: string) => number;

Helper function to get the number of matches within the provided string value.

property node

node: IRowNode<TData>;

property updateMatches

updateMatches: () => void;

Should be called if the number of matches has updated.

interface GetFindTextParams

interface GetFindTextParams<TData = any, TValue = any, TContext = any>
    extends GetTextParams<TData, TValue, TContext> {}

property colDef

colDef: ColDef<TData, TValue> | null;

ColDef provided for this column. null for groupRows.

property column

column: Column<TValue> | null;

Column for this callback. null for groupRows.

property getValueFormatted

getValueFormatted: () => string | null;

Get formatted value for the cell (or null if no valueFormatter)

interface GetFormulaParams

interface GetFormulaParams {}

property column

column: AgColumn;

property rowNode

rowNode: IRowNode;

interface GetGroupAggFilteringParams

interface GetGroupAggFilteringParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property node

node: IRowNode<TData>;

interface GetGroupIncludeFooterParams

interface GetGroupIncludeFooterParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property node

node: IRowNode<TData>;

interface GetGroupIncludeTotalRowParams

interface GetGroupIncludeTotalRowParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property node

node: IRowNode<TData>;

interface GetGroupRowAggParams

interface GetGroupRowAggParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property nodes

nodes: IRowNode<TData>[];

interface GetLocaleTextParams

interface GetLocaleTextParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property defaultValue

defaultValue: string;

property key

key: string;

property variableValues

variableValues?: string[];

interface GetMainMenuItemsParams

interface GetMainMenuItemsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column: Column | null;

The column that was clicked. Will be null if clicking on a column group or empty header space.

property columnGroup

columnGroup: ProvidedColumnGroup | null;

The column group that was clicked. Will be null if clicking on a column or empty header space.

property defaultItems

defaultItems: DefaultMenuItem[];

List of the items that would be displayed by default

interface GetQuickFilterTextParams

interface GetQuickFilterTextParams<TData = any, TValue = any, TContext = any>
    extends GetTextParams<TData, TValue, TContext> {}

property colDef

colDef: ColDef<TData, TValue>;

ColDef provided for this column.

property column

column: Column<TValue>;

Column for this callback.

interface GetRowIdParams

interface GetRowIdParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property data

data: TData;

The data item provided to the grid for the row in question

property level

level: number;

If grouping, the level, ie how many levels from the top. Used by ServerSide Row Model only

property parentKeys

parentKeys?: string[];

If grouping, provides the keys of the parent groups. Used by ServerSide Row Model only

interface GetServerSideGroupLevelParamsParams

interface GetServerSideGroupLevelParamsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property level

level: number;

The level of the store. Top level is 0.

property parentRowNode

parentRowNode?: IRowNode;

The Row Node for the group that got expanded, or undefined if top level (ie no parent)

interface GridApi

interface GridApi<TData = any>
    extends _CoreGridApi<TData>,
        _StateGridApi,
        _RowSelectionGridApi<TData>,
        _RowGridApi<TData>,
        _ScrollGridApi<TData>,
        _KeyboardNavigationGridApi,
        _EventGridApi<TData>,
        _ValueCacheApi,
        _ValueApi<TData>,
        _CommunityMenuGridApi,
        _SortGridApi,
        _OverlayGridApi,
        _PinnedRowGridApi,
        _RenderGridApi<TData>,
        _HighlightChangesGridApi<TData>,
        _DragGridApi<TData>,
        _ColumnAutosizeApi,
        _ColumnResizeApi,
        _ColumnMoveApi,
        _ColumnHoverApi,
        _ColumnGridApi<TData>,
        _ColumnGroupGridApi,
        _EditGridApi<TData>,
        _UndoRedoGridApi,
        _FilterGridApi,
        _ColumnFilterGridApi,
        _QuickFilterGridApi,
        _FindApi<TData>,
        _NotesGridApi,
        _PaginationGridApi,
        _RowModelSharedApi,
        _CsrmSsrmSharedGridApi,
        _SsrmInfiniteSharedGridApi,
        _ClientSideRowModelGridApi<TData>,
        _SideBarGridApi<TData>,
        _ToolbarGridApi<TData>,
        _StatusBarGridApi<TData>,
        _InfiniteRowModelGridApi,
        _CsvExportGridApi,
        _RowGroupingGridApi,
        _AggregationGridApi<TData>,
        _PivotGridApi<TData>,
        _CellSelectionGridApi,
        _ServerSideRowModelGridApi<TData>,
        _ContextMenuGridApi,
        _ColumnChooserGridApi,
        _MasterDetailGridApi,
        _FormulaGridApi<TData>,
        _ExcelExportGridApi,
        _ClipboardGridApi,
        _GridChartsGridApi,
        _AdvancedFilterGridApi,
        _BatchEditApi,
        _AiToolkitGridApi {}

method dispatchEvent

dispatchEvent: (event: AgEvent) => void;

interface GridChartContext

interface GridChartContext<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

interface GridColumnsChangedEvent

interface GridColumnsChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'gridColumnsChanged', TData, TContext> {}

interface GridDraggingEvent

interface GridDraggingEvent<TData = any, TContext = any>
    extends AgDraggingEvent<
            DragSourceType,
            DragItem,
            DragAndDropIcon,
            GridDraggingEvent
        >,
        AgGridCommon<TData, TContext> {}

This is used internally. DraggingEvent is used for external-facing things

interface GridDragSource

interface GridDragSource<
    TDraggingEvent extends AgDraggingEvent<
        DragSourceType,
        DragItem,
        DragAndDropIcon,
        TDraggingEvent
    > = GridDraggingEvent
> extends AgDragSource<DragSourceType, DragItem, DragAndDropIcon, TDraggingEvent> {}

This is used internally. DragSource is used for external-facing things

interface GridOptions

interface GridOptions<TData = any> {}

property accentedSort

accentedSort?: boolean;

Set to true to specify that the sort should take accented characters into account. If this feature is turned on the sort will be slower. false

property activeOverlay

activeOverlay?: any;

Display an overlay on demand. If provided takes precedence over the grid provided overlays. - name of a provided overlay, i.e agLoadingOverlay, agNoRowsOverlay, agNoMatchingRowsOverlay, agExportingOverlay - component class/function. - key of a custom component registered in the components map. - undefined to clear.

property activeOverlayParams

activeOverlayParams?: any;

Custom parameters to be supplied to the activeOverlay component in addition to IOverlayParams. Updating the params will trigger a refresh of the active overlay.

property advancedFilterBuilderParams

advancedFilterBuilderParams?: IAdvancedFilterBuilderParams;

Customise the parameters passed to the Advanced Filter Builder. AdvancedFilterModule

property advancedFilterParams

advancedFilterParams?: IAdvancedFilterParams;

Customise the parameters passed to the Advanced Filter AdvancedFilterModule

property advancedFilterParent

advancedFilterParent?: HTMLElement | null;

DOM element to use as the parent for the Advanced Filter to allow it to appear outside of the grid. Set to null or undefined to appear inside the grid. AdvancedFilterModule

property aggFuncs

aggFuncs?: IAggFuncs<TData>;

A map of 'function name' to 'function' for custom aggregation functions. RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property aggregateOnlyChangedColumns

aggregateOnlyChangedColumns?: boolean;

When using change detection, only the updated column will be re-aggregated. false RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property alignedGrids

alignedGrids?: AlignedGrid[] | (() => AlignedGrid[]);

A list of grids to treat as Aligned Grids. Provide a list if the grids / apis already exist or return via a callback to allow the aligned grids to be retrieved asynchronously. If grids are aligned then the columns and horizontal scrolling will be kept in sync. AlignedGridsModule

property allowContextMenuWithControlKey

allowContextMenuWithControlKey?: boolean;

Allows context menu to show, even when Ctrl key is held down. false ContextMenuModule

property allowDragFromColumnsToolPanel

allowDragFromColumnsToolPanel?: boolean;

Allow reordering and pinning columns by dragging columns from the Columns Tool Panel to the grid. false ColumnsToolPanelModule

property allowShowChangeAfterFilter

allowShowChangeAfterFilter?: boolean;

Set to true to have cells flash after data changes even when the change is due to filtering. false

property alwaysAggregateAtRootLevel

alwaysAggregateAtRootLevel?: boolean;

When using aggregations, the grid will always calculate the root level aggregation value. false RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property alwaysMultiSort

alwaysMultiSort?: boolean;

Set to true to always multi-sort when the user clicks a column header, regardless of key presses. false

property alwaysPassFilter

alwaysPassFilter?: AlwaysPassFilter<TData>;

Allows rows to always be displayed, even if they don't match the applied filtering. Return true for the provided row to always be displayed. Only works with the Client-Side Row Model. TextFilterModule / NumberFilterModule / DateFilterModule / SetFilterModule / MultiFilterModule / CustomFilterModule / QuickFilterModule / ExternalFilterModule / AdvancedFilterModule

property alwaysShowHorizontalScroll

alwaysShowHorizontalScroll?: boolean;

Set to true to always show the horizontal scrollbar. false

property alwaysShowVerticalScroll

alwaysShowVerticalScroll?: boolean;

Set to true to always show the vertical scrollbar. false

property animateColumnResizing

animateColumnResizing?: boolean;

Set to true to animate changes to column width when auto-sizing the columns. false

property animateRows

animateRows?: boolean;

Set to false to disable Row Animation which is enabled by default. true

property applyQuickFilterBeforePivotOrAgg

applyQuickFilterBeforePivotOrAgg?: boolean;

When pivoting, Quick Filter is only applied on the pivoted data (or aggregated data if groupAggFiltering = true). Set to true to apply Quick Filter before pivoting (/aggregating) instead. false QuickFilterModule

property asyncTransactionWaitMillis

asyncTransactionWaitMillis?: number;

How many milliseconds to wait before executing a batch of async transactions.

property autoGroupColumnDef

autoGroupColumnDef?: AutoGroupColumnDef<TData>;

Allows specifying the group 'auto column' if you are not happy with the default. If grouping, this column definition is included as the first column in the grid. If not grouping, this column is not included. RowGroupingModule / TreeDataModule

property autoSizePadding

autoSizePadding?: number;

Number of pixels to add to a column width after the [auto-sizing](./column-sizing/#auto-size-columns-to-fit-cell-contents) calculation. Set this if you want to add extra room to accommodate (for example) sort icons, or some other dynamic nature of the header. 20

property autoSizeStrategy

autoSizeStrategy?: AutoSizeStrategy;

Auto-size the columns when the grid is loaded. Can size to fit the grid width, fit a provided width, or fit the cell contents. ColumnAutoSizeModule

property blockLoadDebounceMillis

blockLoadDebounceMillis?: number;

How many milliseconds to wait before loading a block. Useful when scrolling over many blocks, as it prevents blocks loading until scrolling has settled. ServerSideRowModelModule / InfiniteRowModelModule

property cacheBlockSize

cacheBlockSize?: number;

How many rows for each block in the store, i.e. how many rows returned from the server at a time. 100 ServerSideRowModelModule / InfiniteRowModelModule

property cacheOverflowSize

cacheOverflowSize?: number;

How many extra blank rows to display to the user at the end of the dataset, which sets the vertical scroll and then allows the grid to request viewing more rows of data. 1 InfiniteRowModelModule

property cacheQuickFilter

cacheQuickFilter?: boolean;

Set to true to turn on the Quick Filter cache, used to improve performance when using the Quick Filter. false QuickFilterModule

property cellFadeDuration

cellFadeDuration?: number;

Sets the duration in milliseconds of how long the "flashed" state animation takes to fade away after the timer set by cellFlashDuration has completed. 1000

property cellFlashDuration

cellFlashDuration?: number;

Sets the duration in milliseconds of how long a cell should remain in its "flashed" state. If 0, the cell will not flash. 500

property cellSelection

cellSelection?: boolean | CellSelectionOptions<TData>;

Configure cell selection. CellSelectionModule

property chartMenuItems

chartMenuItems?:
    | (DefaultChartMenuItem | MenuItemDef<TData>)[]
    | GetChartMenuItems<TData>;

Get chart menu items. Only applies when using AG Charts Enterprise. IntegratedChartsModule

property chartThemeOverrides

chartThemeOverrides?: AgChartThemeOverrides;

Chart theme overrides applied to all themes. IntegratedChartsModule

property chartThemes

chartThemes?: string[];

The list of chart themes that a user can choose from in the chart panel. ['ag-default', 'ag-material', 'ag-sheets', 'ag-polychroma', 'ag-vivid']; IntegratedChartsModule

property chartToolPanelsDef

chartToolPanelsDef?: ChartToolPanelsDef;

Allows customisation of the Chart Tool Panels, such as changing the tool panels visibility and order, as well as choosing which charts should be displayed in the chart panel. IntegratedChartsModule

property clipboardDelimiter

clipboardDelimiter?: string;

Specify the delimiter to use when copying to clipboard. '\t' ClipboardModule

property colResizeDefault

colResizeDefault?: 'shift';

Set to 'shift' to have shift-resize as the default resize operation (same as user holding down Shift while resizing).

property columnDefs

columnDefs?: (ColDef<TData> | ColGroupDef<TData>)[] | null;

Array of Column / Column Group definitions.

property columnHoverHighlight

columnHoverHighlight?: boolean;

Set to true to highlight columns by adding the ag-column-hover CSS class. false ColumnHoverModule

property columnMenu

columnMenu?: 'legacy' | 'new';

Changes the display type of the column menu. 'new' just displays the main list of menu items. 'legacy' displays a tabbed menu. 'new'

property columnTypes

columnTypes?: ColTypeDefs<TData>;

An object map of custom column types which contain groups of properties that column definitions can reuse by referencing in their type property.

property context

context?: any;

Provides a context object that is provided to different callbacks the grid uses. Used for passing additional information to the callbacks used by your application.

property copyGroupHeadersToClipboard

copyGroupHeadersToClipboard?: boolean;

Set to true to also include group headers when copying to clipboard using Ctrl + C clipboard. false ClipboardModule

property copyHeadersToClipboard

copyHeadersToClipboard?: boolean;

Set to true to also include headers when copying to clipboard using Ctrl + C clipboard. false ClipboardModule

property createChartContainer

createChartContainer?: CreateChartContainer<TData>;

Callback to enable displaying the chart in an alternative chart container. IntegratedChartsModule

property customChartThemes

customChartThemes?: CustomChartThemes;

A map containing custom chart themes. IntegratedChartsModule

property datasource

datasource?: IDatasource;

Provide the datasource for infinite scrolling. InfiniteRowModelModule

property dataTypeDefinitions

dataTypeDefinitions?: DataTypeDefinitions<TData>;

An object map of cell data types to their definitions. Cell data types can either override/update the pre-defined data types ('text', 'number', 'boolean', 'date', 'dateString', 'dateTime', 'dateTimeString' or 'object'), or can be custom data types.

property debounceVerticalScrollbar

debounceVerticalScrollbar?: boolean;

Set to true to debounce the vertical scrollbar. Can provide smoother scrolling on slow machines. false

property debug

debug?: boolean;

Set this to true to enable debug information from the grid and related components. Will result in additional logging being output, but very useful when investigating problems. It is also recommended to register the ValidationModule to identify any misconfigurations. false

property defaultColDef

defaultColDef?: ColDef<TData>;

A default column definition. Items defined in the actual column definitions get precedence.

property defaultColGroupDef

defaultColGroupDef?: Partial<ColGroupDef<TData>>;

A default column group definition. All column group definitions will use these properties. Items defined in the actual column group definition get precedence.

property defaultCsvExportParams

defaultCsvExportParams?: CsvExportParams;

A default configuration object used to export to CSV. CsvExportModule

property defaultExcelExportParams

defaultExcelExportParams?: ExcelExportParams;

A default configuration object used to export to Excel. ExcelExportModule

property deltaSort

deltaSort?: boolean;

When enabled, sorts only the rows added/updated by a transaction.
Ignored when postSortRows is configured (falls back to full sort). false

property detailCellRenderer

detailCellRenderer?: any;

Provide a custom detailCellRenderer to use when a master row is expanded. See [Detail Cell Renderer](https://www.ag-grid.com/javascript-data-grid/master-detail-custom-detail/) for framework specific implementation details. MasterDetailModule

property detailCellRendererParams

detailCellRendererParams?: any;

Specifies the params to be used by the Detail Cell Renderer. Can also be a function that provides the params to enable dynamic definitions of the params. MasterDetailModule

property detailRowAutoHeight

detailRowAutoHeight?: boolean;

Set to true to have the detail grid dynamically change it's height to fit it's rows. MasterDetailModule

property detailRowHeight

detailRowHeight?: number;

Set fixed height in pixels for each detail row. MasterDetailModule

property doesExternalFilterPass

doesExternalFilterPass?: DoesExternalFilterPass<TData>;

Should return true if external filter passes, otherwise false. ExternalFilterModule

property domLayout

domLayout?: DomLayoutType;

Switch between layout options: normal, autoHeight, print. 'normal'

property dragAndDropImageComponent

dragAndDropImageComponent?: any;

Provide a custom drag and drop image component. RowDragModule

property dragAndDropImageComponentParams

dragAndDropImageComponentParams?: any;

Customise the parameters provided to the Drag and Drop Image Component. RowDragModule

property editType

editType?: EditStrategyType;

Set to 'fullRow' to enable Full Row Editing. Otherwise leave blank to edit one cell at a time. TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property embedFullWidthRows

embedFullWidthRows?: boolean;

Set to true to have the Full Width Rows embedded in grid's main container so they can be scrolled horizontally.

property enableAdvancedFilter

enableAdvancedFilter?: boolean;

Set to true to enable the Advanced Filter. false AdvancedFilterModule

property enableBrowserTooltips

enableBrowserTooltips?: boolean;

Set to true to use the browser's default tooltip instead of using the grid's Tooltip Component. false TooltipModule

property enableCellEditingOnBackspace

enableCellEditingOnBackspace?: boolean;

Forces Cell Editing to start when backspace is pressed. This is only relevant for MacOS users. TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property enableCellExpressions

enableCellExpressions?: boolean;

Set to true to allow cell expressions. false

property enableCellSpan

enableCellSpan?: boolean;

When true, enables the cell span feature allowing for the use of the colDef.spanRows property. false CellSpanModule

property enableCellTextSelection

enableCellTextSelection?: boolean;

Set to true to be able to select the text within cells.
**Note:** When this is set to true, the clipboard service is disabled and only selected text is copied. false

property enableCharts

enableCharts?: boolean;

Set to true to Enable Charts. false IntegratedChartsModule

property enableFillHandle

enableFillHandle?: boolean;

Set to true to enable the Fill Handle. false
Deprecated
v32.2 Use cellSelection.handle instead

property enableFilterHandlers

enableFilterHandlers?: boolean;

Enable filter handlers for custom filter components. Requires all custom filters to be implemented using handlers.
Note that grid-provided filters (except for the Multi Filter) always use filter handlers. The Multi Filter will also use a filter handler if this is enabled.

property enableGroupEdit

enableGroupEdit?: boolean;

property enableRangeHandle

enableRangeHandle?: boolean;

Set to true to enable the Range Handle. false
Deprecated
v32.2 Use cellSelection.handle instead

property enableRangeSelection

enableRangeSelection?: boolean;

Set to true to enable Range Selection. false
Deprecated
v32.2 Use cellSelection = true instead CellSelectionModule

property enableRowPinning

enableRowPinning?: boolean | 'top' | 'bottom';

Determines whether manual row pinning is enabled via the row context menu.
Set to true to allow pinning rows to top or bottom. Set to 'top' to allow pinning rows to the top only. Set to 'bottom' to allow pinning rows to the bottom only. PinnedRowModule

property enableRtl

enableRtl?: boolean;

Set to true to operate the grid in RTL (Right to Left) mode. false

property enableStrictPivotColumnOrder

enableStrictPivotColumnOrder?: boolean;

Resets pivot column order when impacted by filters, data or configuration changes
false PivotModule

property ensureDomOrder

ensureDomOrder?: boolean;

When true, the order of rows and columns in the DOM are consistent with what is on screen. Disables row animations. false

property enterNavigatesVertically

enterNavigatesVertically?: boolean;

Set to true along with enterNavigatesVerticallyAfterEdit to have Excel-style behaviour for the Enter key. i.e. pressing the Enter key will move down to the cell beneath and Shift+Enter will move up to the cell above. false TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property enterNavigatesVerticallyAfterEdit

enterNavigatesVerticallyAfterEdit?: boolean;

Set to true along with enterNavigatesVertically to have Excel-style behaviour for the 'Enter' key. i.e. pressing the Enter key will move down to the cell beneath and Shift+Enter key will move up to the cell above. false TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property excelStyles

excelStyles?: ExcelStyle[];

A list (array) of Excel styles to be used when exporting to Excel with styles. ExcelExportModule

property excludeChildrenWhenTreeDataFiltering

excludeChildrenWhenTreeDataFiltering?: boolean;

Set to true to override the default tree data filtering behaviour to instead exclude child nodes from filter results. false TreeDataModule

property fillHandleDirection

fillHandleDirection?: 'x' | 'y' | 'xy';

Set to 'x' to force the fill handle direction to horizontal, or set to 'y' to force the fill handle direction to vertical. 'xy'
Deprecated
v32.2 Use cellSelection.handle.direction instead

property fillOperation

fillOperation?: FillOperation<TData>;

Callback to fill values instead of simply copying values or increasing number values using linear progression.
Deprecated
v32.2 Use cellSelection.handle.setFillValue instead

property filterHandlers

filterHandlers?: FilterHandlers<TData>;

A map of filter handler key to filter handler function. Allows for filter handler keys to be used in colDef.filter.handler.

property findOptions

findOptions?: FindOptions;

Options for the Find feature. FindModule

property findSearchValue

findSearchValue?: string;

Text to find within the grid. FindModule

property floatingFiltersHeight

floatingFiltersHeight?: number;

The height in pixels for the row containing the floating filters. If not specified, it uses the theme value of header-height.

property focusGridInnerElement

focusGridInnerElement?: FocusGridInnerElement<TData>;

Allows overriding the element that will be focused when the grid receives focus from outside elements (tabbing into the grid).
Returns
True if this function should override the grid's default behavior, False to allow the grid's default behavior.

property formulaDataSource

formulaDataSource?: FormulaDataSource;

Provide a data source to control where formulas are stored and retrieved. If not supplied, formulas are read from and written to the row data. FormulaModule

property formulaFuncs

formulaFuncs?: FormulaFuncs;

A map of 'function name' to 'function' for custom functions that are used for formulas. FormulaModule

property fullWidthCellRenderer

fullWidthCellRenderer?: any;

Provide your own cell renderer component to use for full width rows. See [Full Width Rows](https://www.ag-grid.com/javascript-data-grid/full-width-rows/) for framework specific implementation details.

property fullWidthCellRendererParams

fullWidthCellRendererParams?: any;

Customise the parameters provided to the fullWidthCellRenderer component.

property functionsReadOnly

functionsReadOnly?: boolean;

If true, then row group, pivot and value aggregation will be read-only from the GUI. The grid will display what values are used for each, but will not allow the user to change the selection. false RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property getBusinessKeyForNode

getBusinessKeyForNode?: GetBusinessKeyForNode<TData>;

Return a business key for the node. If implemented, each row in the DOM will have an attribute row-business-key='abc' where abc is what you return as the business key. This is useful for automated testing, as it provides a way for your tool to identify rows based on unique business keys.

property getChartToolbarItems

getChartToolbarItems?: GetChartToolbarItems<TData>;

Callback to be used to customise the chart toolbar items. IntegratedChartsModule

property getChildCount

getChildCount?: GetChildCount;

Allows setting the child count for a group row. ServerSideRowModelModule

property getContextMenuItems

getContextMenuItems?: GetContextMenuItems<TData>;

For customising the context menu. ContextMenuModule

property getDataPath

getDataPath?: GetDataPath<TData>;

Callback to be used when working with Tree Data when treeData = true. TreeDataModule

property getDocument

getDocument?: GetDocument;

Allows overriding what document is used. Currently used by Drag and Drop (may extend to other places in the future). Use this when you want the grid to use a different document than the one available on the global scope. This can happen if docking out components (something which Electron supports)

property getFullRowEditValidationErrors

getFullRowEditValidationErrors?: GetFullRowEditValidationErrors;

Validates the Full Row Edit. Only relevant when editType="fullRow". TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property getGroupRowAgg

getGroupRowAgg?: GetGroupRowAgg<TData>;

Callback to use when you need access to more then the current column for aggregation. RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property getLocaleText

getLocaleText?: GetLocaleText<TData>;

A callback for localising text within the grid. LocaleModule

property getMainMenuItems

getMainMenuItems?: GetMainMenuItems<TData>;

For customising the main 'column header' menu. ColumnMenuModule

property getRowClass

getRowClass?: GetRowClass<TData>;

Callback version of property rowClass to set class(es) for each row individually. Function should return either a string (class name), array of strings (array of class names) or undefined for no class. RowStyleModule

property getRowHeight

getRowHeight?: GetRowHeight<TData>;

Callback version of property rowHeight to set height for each row individually. Function should return a positive number of pixels, or return null/undefined to use the default row height.

property getRowId

getRowId?: GetRowIdFunc<TData>;

Provide a pure function that returns a string ID to uniquely identify a given row. This enables the grid to work optimally with data changes and updates.

property getRowStyle

getRowStyle?: GetRowStyle<TData>;

Callback version of property rowStyle to set style for each row individually. Function should return an object of CSS values or undefined for no styles. RowStyleModule

property getServerSideGroupKey

getServerSideGroupKey?: GetServerSideGroupKey;

SSRM Tree Data: Allows specifying group keys. ServerSideRowModelModule

property getServerSideGroupLevelParams

getServerSideGroupLevelParams?: GetServerSideGroupLevelParams<TData>;

Allows providing different params for different levels of grouping. ServerSideRowModelModule

property grandTotalRow

grandTotalRow?: 'top' | 'bottom' | 'pinnedTop' | 'pinnedBottom';

When provided, an extra grand total row will be inserted into the grid at the specified position. This row displays the aggregate totals of all rows in the grid. RowGroupingModule / ServerSideRowModelModule

property gridId

gridId?: string;

Provide a custom gridId for this instance of the grid. Value will be set on the root DOM node using the attribute grid-id as well as being accessible via the gridApi.getGridId() method.

property groupAggFiltering

groupAggFiltering?: boolean | IsRowFilterable<TData>;

Set to determine whether filters should be applied on aggregated group values. false RowGroupingModule

property groupAllowUnbalanced

groupAllowUnbalanced?: boolean;

Set to true to prevent the grid from creating a '(Blanks)' group for nodes which do not belong to a group, and display the unbalanced nodes alongside group nodes. false RowGroupingModule

property groupDefaultExpanded

groupDefaultExpanded?: number;

If grouping, set to the number of levels to expand by default, e.g. 0 for none, 1 for first level only, etc. Set to -1 to expand everything. 0 RowGroupingModule / TreeDataModule

property groupDisplayType

groupDisplayType?: RowGroupingDisplayType;

Specifies how the results of row grouping should be displayed.
The options are:
- 'singleColumn': single group column automatically added by the grid. - 'multipleColumns': a group column per row group is added automatically. - 'groupRows': group rows are automatically added instead of group columns. - 'custom': informs the grid that group columns will be provided. RowGroupingModule

property groupHeaderHeight

groupHeaderHeight?: number;

The height in pixels for the rows containing header column groups. If not specified, it uses headerHeight.

property groupHideColumnsUntilExpanded

groupHideColumnsUntilExpanded?: boolean;

When using groupDisplayType='multipleColumns' or groupHideOpenParents=true, hides group columns for levels that have not yet been expanded. Only the top-level group column is initially visible; each subsequent level becomes visible when at least one group at the preceding level is expanded. (Client Side Row Model only) false RowGroupingModule

property groupHideOpenParents

groupHideOpenParents?: boolean;

Set to true to hide parents that are open. When used with multiple columns for showing groups, it can give a more pleasing user experience. false RowGroupingModule

property groupHideParentOfSingleChild

groupHideParentOfSingleChild?: boolean | 'leafGroupsOnly';

Enable to display the child row in place of the group row when the group only has a single child. false RowGroupingModule

property groupHierarchyConfig

groupHierarchyConfig?: GroupHierarchyConfig;

Custom group hierarchy components can be defined here for later use in colDef.groupHierarchy RowGroupingModule

property groupLockGroupColumns

groupLockGroupColumns?: number;

If grouping, locks the group settings of a number of columns, e.g. 0 for no group locking. 1 for first group column locked, -1 for all group columns locked. 0 RowGroupingModule

property groupMaintainOrder

groupMaintainOrder?: boolean;

When true, sorting on non-group columns does not reorder groups; only the rows within each group are sorted. Group order remains the structural order set at grouping time (data-insertion order, or initialGroupOrderComparator if configured) and is preserved across filter changes and transactions. If a group column was sorted via colDef.sort and the user later explicitly clears that sort, the structural order is restored.
With multi-level row grouping, the order is maintained per level: a sort on a group column at one level only re-orders that level's groups; sibling levels keep their structural order.
Applies to row grouping only. Has no effect on tree data, where row order is determined by the tree structure. false RowGroupingModule

property groupRemoveLowestSingleChildren

groupRemoveLowestSingleChildren?: boolean;

Set to true to collapse lowest level groups that only have one child. false
Deprecated
v33.0.0 - use groupHideParentOfSingleChild: 'leafGroupsOnly' instead.

property groupRemoveSingleChildren

groupRemoveSingleChildren?: boolean;

Set to true to collapse groups that only have one child. false
Deprecated
v33.0.0 - use groupHideParentOfSingleChild instead.

property groupRowRenderer

groupRowRenderer?: any;

Provide the Cell Renderer to use when groupDisplayType = 'groupRows'. See [Group Row Cell Renderer](https://www.ag-grid.com/javascript-data-grid/grouping-group-rows/#providing-cell-renderer) for framework specific implementation details. RowGroupingModule

property groupRowRendererParams

groupRowRendererParams?: any;

Customise the parameters provided to the groupRowRenderer component. RowGroupingModule

property groupSelectsChildren

groupSelectsChildren?: boolean;

When true, if you select a group, the children of the group will also be selected. false
Deprecated
v32.2 Use rowSelection.groupSelects instead

property groupSelectsFiltered

groupSelectsFiltered?: boolean;

If using groupSelectsChildren, then only the children that pass the current filter will get selected. false
Deprecated
v32.2 Use rowSelection.groupSelects instead

property groupSuppressBlankHeader

groupSuppressBlankHeader?: boolean;

If true, and showing footer, aggregate data will always be displayed at both the header and footer levels. This stops the possibly undesirable behaviour of the header details 'jumping' to the footer on expand. false RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property groupTotalRow

groupTotalRow?: 'top' | 'bottom' | UseGroupTotalRow<TData>;

When provided, an extra row group total row will be inserted into row groups at the specified position, to display when the group is expanded. This row will contain the aggregate values for the group. If a callback function is provided, it can be used to selectively determine which groups will have a total row added. RowGroupingModule / ServerSideRowModelModule

property headerHeight

headerHeight?: number;

The height in pixels for the row containing the column label header. If not specified, it uses the theme value of header-height.

property hidePaddedHeaderRows

hidePaddedHeaderRows?: boolean;

Hide any column header rows that would only contain padded groups.

property icons

icons?: Icons;

Icons to use inside the grid instead of the grid's default icons.

property includeHiddenColumnsInAdvancedFilter

includeHiddenColumnsInAdvancedFilter?: boolean;

Hidden columns are excluded from the Advanced Filter by default. To include hidden columns, set to true. false AdvancedFilterModule

property includeHiddenColumnsInQuickFilter

includeHiddenColumnsInQuickFilter?: boolean;

Hidden columns are excluded from the Quick Filter by default. To include hidden columns, set to true. false QuickFilterModule

property infiniteInitialRowCount

infiniteInitialRowCount?: number;

How many extra blank rows to display to the user at the end of the dataset, which sets the vertical scroll and then allows the grid to request viewing more rows of data. 1 InfiniteRowModelModule

property initialGroupOrderComparator

initialGroupOrderComparator?: InitialGroupOrderComparator<TData>;

Allows default sorting of groups. RowGroupingModule

property initialState

initialState?: GridState;

Initial state for the grid. Only read once on initialization. Can be used in conjunction with api.getState() to save and restore grid state. GridStateModule

property invalidEditValueMode

invalidEditValueMode?: EditValidationCommitType;

Set to block to block the commit of invalid cell edits, keeping editors open.

property isApplyServerSideTransaction

isApplyServerSideTransaction?: IsApplyServerSideTransaction<TData>;

Allows cancelling transactions. ServerSideRowModelModule

property isExternalFilterPresent

isExternalFilterPresent?: IsExternalFilterPresent<TData>;

Grid calls this method to know if an external filter is present. ExternalFilterModule

property isFullWidthRow

isFullWidthRow?: IsFullWidthRow<TData>;

Tells the grid if this row should be rendered as full width.

property isGroupOpenByDefault

isGroupOpenByDefault?: IsGroupOpenByDefault<TData>;

(Client-side Row Model only) Allows groups to be open by default. RowGroupingModule / TreeDataModule

property isRowMaster

isRowMaster?: IsRowMaster<TData>;

Callback to be used with Master Detail to determine if a row should be a master row. If false is returned no detail row will exist for this row. MasterDetailModule

property isRowPinnable

isRowPinnable?: IsRowPinnable<TData>;

Return true if the grid should allow the row to be manually pinned. Return false if the grid should prevent the row from being pinned
When not defined, all rows default to pinnable. PinnedRowModule

property isRowPinned

isRowPinned?: IsRowPinned<TData>;

Called for every row in the grid.
Return "top", "bottom" if the row should be initially pinned to the top or bottom respectively. Return null or undefined otherwise. User interactions can subsequently still change the pinned state of a row. PinnedRowModule

property isRowSelectable

isRowSelectable?: IsRowSelectable<TData>;

Callback to be used to determine which rows are selectable. By default rows are selectable, so return false to make a row un-selectable.
Deprecated
v32.2 Use rowSelection.isRowSelectable instead

property isRowValidDropPosition

isRowValidDropPosition?: IsRowValidDropPositionCallback<TData>;

Called by drag and drop when rows are dragged over another row to conditionally prevent dropping the dragged row on the hovered row. The user can cancel the drop by returning false or customize the operation by returning a IsRowValidDropPositionResult. RowDragModule

property isServerSideGroup

isServerSideGroup?: IsServerSideGroup;

SSRM Tree Data: Allows specifying which rows are expandable. ServerSideRowModelModule

property isServerSideGroupOpenByDefault

isServerSideGroupOpenByDefault?: IsServerSideGroupOpenByDefault<TData>;

Allows groups to be open by default. ServerSideRowModelModule

property keepDetailRows

keepDetailRows?: boolean;

Set to true to keep detail rows for when they are displayed again. false MasterDetailModule

property keepDetailRowsCount

keepDetailRowsCount?: number;

Sets the number of details rows to keep. 10 MasterDetailModule

property loading

loading?: boolean;

Show or hide the loading overlay. - true: the loading overlay is shown. - false: the loading overlay is hidden. - undefined: the grid will automatically show the loading overlay until rowData and columnDefs are provided. (Client Side Row Model only) undefined

property loadingCellRenderer

loadingCellRenderer?: any;

Provide your own loading cell renderer to use when data is loading via a DataSource or when a cell renderer is deferred. See [Loading Cell Renderer](https://www.ag-grid.com/javascript-data-grid/component-loading-cell-renderer/) for framework specific implementation details.

property loadingCellRendererParams

loadingCellRendererParams?: any;

Params to be passed to the loadingCellRenderer component.

property loadingCellRendererSelector

loadingCellRendererSelector?: LoadingCellRendererSelectorFunc<TData>;

Callback to select which loading cell renderer to be used when data is loading via a DataSource or when a cell renderer is deferred.

property loadingOverlayComponent

loadingOverlayComponent?: any;

Provide a custom loading overlay component.
- **Prefer overlayComponent / overlayComponentSelector**

property loadingOverlayComponentParams

loadingOverlayComponentParams?: any;

Customise the parameters provided to the loading overlay component.
- **Prefer using overlayComponentParams**

property loadThemeGoogleFonts

loadThemeGoogleFonts?: boolean;

If your theme uses a font that is available on Google Fonts, pass true to load it from Google's CDN.

property localeText

localeText?: LocaleText;

A map of key->value pairs for localising text within the grid. LocaleModule

property maintainColumnOrder

maintainColumnOrder?: boolean;

Keeps the order of Columns maintained after new Column Definitions are updated.
false

property masterDetail

masterDetail?: boolean;

Set to true to enable Master Detail. false MasterDetailModule

property maxBlocksInCache

maxBlocksInCache?: number;

How many blocks to keep in the store. Default is no limit, so every requested block is kept. Use this if you have memory concerns, and blocks that were least recently viewed will be purged when the limit is hit. The grid will additionally make sure it has all the blocks needed to display what is currently visible, in case this property is set to a low value. ServerSideRowModelModule / InfiniteRowModelModule

property maxConcurrentDatasourceRequests

maxConcurrentDatasourceRequests?: number;

How many requests to hit the server with concurrently. If the max is reached, requests are queued. Set to -1 for no maximum restriction on requests. 2 ServerSideRowModelModule / InfiniteRowModelModule

property multiSortKey

multiSortKey?: 'ctrl';

Set to 'ctrl' to have multi sorting by clicking work using the Ctrl (or Command ⌘ for Mac) key.

property navigateToNextCell

navigateToNextCell?: NavigateToNextCell<TData>;

Allows overriding the default behaviour for when user hits navigation (arrow) key when a cell is focused. Return the next Cell position to navigate to or null to stay on current cell.

property navigateToNextHeader

navigateToNextHeader?: NavigateToNextHeader<TData>;

Allows overriding the default behaviour for when user hits navigation (arrow) key when a header is focused. Return the next Header position to navigate to or null to stay on current header.

property noRowsOverlayComponent

noRowsOverlayComponent?: any;

Provide a custom no-rows overlay component.
- **Prefer overlayComponent / overlayComponentSelector**

property noRowsOverlayComponentParams

noRowsOverlayComponentParams?: any;

Customise the parameters provided to the no-rows overlay component.
- **Prefer using overlayComponentParams**

property noteHideDelay

noteHideDelay?: number;

The delay in milliseconds before a note is hidden after the pointer leaves a noted cell or note popup. 220 NotesModule

property notesDataSource

notesDataSource?: NotesDataSource | FullWidthNotesDataSource;

Provide a data source to control where notes are stored and retrieved. Can be updated to enable, disable, or replace Notes at runtime. NotesModule

property noteShowDelay

noteShowDelay?: number;

The delay in milliseconds before a note is shown when hovering a noted cell. Only applies when noteTrigger = 'hover'. 180 NotesModule

property noteTrigger

noteTrigger?: 'hover' | 'click';

Changes how existing notes are opened. - 'hover' - Existing notes open when hovering a noted cell or full width row. - 'click' - Existing notes open when clicking a noted cell or full width row. 'hover' NotesModule

property overlayComponent

overlayComponent?: any;

Provide a custom overlay component to be used for all grid provided overlays (loading, no rows, no matching rows, exporting etc).

property overlayComponentParams

overlayComponentParams?: any;

Customise the parameters provided to the overlayComponent. Provided overlays accept parameters specified on the OverlayComponentUserParams interface. Any custom parameters can also be provided for custom overlay components.

property overlayComponentSelector

overlayComponentSelector?: OverlaySelectorFunc<TData>;

Callback to dynamically provide a custom overlay component complete with custom params based on the selector params.

property overlayLoadingTemplate

overlayLoadingTemplate?: string;

Provide a HTML string to override the default loading overlay. Supports non-empty plain text or HTML with a single root element.
- **Prefer overlayComponent / overlayComponentSelector**

property overlayNoRowsTemplate

overlayNoRowsTemplate?: string;

Provide a HTML string to override the default no-rows overlay. Supports non-empty plain text or HTML with a single root element.
- **Prefer overlayComponent / overlayComponentSelector**

property paginateChildRows

paginateChildRows?: boolean;

Set to true to have pages split children of groups when using Row Grouping or detail rows with Master Detail. false PaginationModule

property pagination

pagination?: boolean;

Set whether pagination is enabled. false PaginationModule

property paginationAutoPageSize

paginationAutoPageSize?: boolean;

Set to true so that the number of rows to load per page is automatically adjusted by the grid so each page shows enough rows to just fill the area designated for the grid. If false, paginationPageSize is used. false PaginationModule

property paginationNumberFormatter

paginationNumberFormatter?: PaginationNumberFormatter<TData>;

Allows user to format the numbers in the pagination panel, i.e. 'row count' and 'page number' labels. This is for pagination panel only, to format numbers inside the grid's cells (i.e. your data), then use valueFormatter in the column definitions. PaginationModule

property paginationPageSize

paginationPageSize?: number;

How many rows to load per page. If paginationAutoPageSize is specified, this property is ignored. 100 PaginationModule

property paginationPageSizeSelector

paginationPageSizeSelector?: number[] | boolean;

Determines if the page size selector is shown in the pagination panel or not. Set to an array of values to show the page size selector with custom list of possible page sizes. Set to true to show the page size selector with the default page sizes [20, 50, 100]. Set to false to hide the page size selector. true PaginationModule

property paginationPanels

paginationPanels?: PaginationPanel[];

Controls which built-in components appear in the pagination panel and in what order. Accepts an array of names: 'pageSize', 'rowSummary', 'pageSummary'. Components render in the order they appear in the array. Omitted components are hidden. An empty array hides the pagination panel entirely. When not set, all three components render in the default order: [pageSize, rowSummary, pageSummary]. PaginationModule

property pinnedBottomRowData

pinnedBottomRowData?: any[];

Data to be displayed as pinned bottom rows in the grid. PinnedRowModule

property pinnedTopRowData

pinnedTopRowData?: any[];

Data to be displayed as pinned top rows in the grid. PinnedRowModule

property pivotColumnGroupTotals

pivotColumnGroupTotals?: PivotColumnGroupTotals;

When set and the grid is in pivot mode, automatically calculated totals will appear within the Pivot Column Groups, in the position specified. PivotModule

property pivotDefaultExpanded

pivotDefaultExpanded?: number;

If pivoting, set to the number of column group levels to expand by default, e.g. 0 for none, 1 for first level only, etc. Set to -1 to expand everything. 0 PivotModule

property pivotGroupHeaderHeight

pivotGroupHeaderHeight?: number;

The height in pixels for the row containing header column groups when in pivot mode. If not specified, it uses groupHeaderHeight.

property pivotHeaderHeight

pivotHeaderHeight?: number;

The height in pixels for the row containing the columns when in pivot mode. If not specified, it uses headerHeight.

property pivotMaxGeneratedColumns

pivotMaxGeneratedColumns?: number;

The maximum number of generated columns before the grid halts execution. Upon reaching this number, the grid halts generation of columns and triggers a pivotMaxColumnsExceeded event. -1 for no limit. -1 PivotModule

property pivotMode

pivotMode?: boolean;

Set to true to enable pivot mode. false PivotModule

property pivotPanelShow

pivotPanelShow?: 'always' | 'onlyWhenPivoting' | 'never';

When to show the 'pivot panel' (where you drag rows to pivot) at the top. Note that the pivot panel will never show if pivotMode is off. 'never' RowGroupingPanelModule

property pivotRowTotals

pivotRowTotals?: PivotRowTotals;

When set and the grid is in pivot mode, automatically calculated totals will appear for each value column in the position specified. PivotModule

property pivotSuppressAutoColumn

pivotSuppressAutoColumn?: boolean;

If true, the grid will not swap in the grouping column when pivoting. Useful if pivoting using Server Side Row Model or Viewport Row Model and you want full control of all columns including the group column. false PivotModule

property popupParent

popupParent?: HTMLElement | null;

DOM element to use as the popup parent for grid popups (context menu, column menu etc).

property postProcessPopup

postProcessPopup?: PostProcessPopup<TData>;

Allows user to process popups after they are created. Applications can use this if they want to, for example, reposition the popup.

property postSortRows

postSortRows?: PostSortRows<TData>;

Callback to perform additional sorting after the grid has sorted the rows.
When configured, deltaSort is ignored.

property preventDefaultOnContextMenu

preventDefaultOnContextMenu?: boolean;

When using suppressContextMenu, you can use the onCellContextMenu function to provide your own code to handle cell contextmenu events. This flag is useful to prevent the browser from showing its default context menu. false

property processCellForClipboard

processCellForClipboard?: ProcessCellForClipboard<TData>;

Allows you to process cells for the clipboard. Handy if for example you have Date objects that need to have a particular format if importing into Excel. ClipboardModule

property processCellFromClipboard

processCellFromClipboard?: ProcessCellFromClipboard<TData>;

Allows you to process cells from the clipboard. Handy if for example you have number fields and want to block non-numbers from getting into the grid. ClipboardModule

property processDataFromClipboard

processDataFromClipboard?: ProcessDataFromClipboard<TData>;

Allows complete control of the paste operation, including cancelling the operation (so nothing happens) or replacing the data with other data. ClipboardModule

property processGroupHeaderForClipboard

processGroupHeaderForClipboard?: ProcessGroupHeaderForClipboard<TData>;

Allows you to process group header values for the clipboard. ClipboardModule

property processHeaderForClipboard

processHeaderForClipboard?: ProcessHeaderForClipboard<TData>;

Allows you to process header values for the clipboard. ClipboardModule

property processPivotResultColDef

processPivotResultColDef?: ProcessPivotResultColDef<TData>;

Callback for the mutation of the generated pivot result column definitions PivotModule

property processPivotResultColGroupDef

processPivotResultColGroupDef?: ProcessPivotResultColGroupDef<TData>;

Callback for the mutation of the generated pivot result column group definitions PivotModule

property processRowPostCreate

processRowPostCreate?: ProcessRowPostCreate<TData>;

Callback fired after the row is rendered into the DOM. Should not be used to initiate side effects.

property processUnpinnedColumns

processUnpinnedColumns?: ProcessUnpinnedColumns<TData>;

Allows the user to process the columns being removed from the pinned section because the viewport is too small to accommodate them. Returns an array of columns to be removed from the pinned areas.

property purgeClosedRowNodes

purgeClosedRowNodes?: boolean;

When enabled, closing group rows will remove children of that row. Next time the row is opened, child rows will be read from the datasource again. This property only applies when there is Row Grouping or Tree Data. false ServerSideRowModelModule

property quickFilterMatcher

quickFilterMatcher?: QuickFilterMatcher;

Changes the matching logic for whether a row passes the Quick Filter. QuickFilterModule

property quickFilterParser

quickFilterParser?: QuickFilterParser;

Changes how the Quick Filter splits the Quick Filter text into search terms. QuickFilterModule

property quickFilterText

quickFilterText?: string;

Rows are filtered using this text as a Quick Filter. Only supported for Client-Side Row Model. QuickFilterModule

property reactiveCustomComponents

reactiveCustomComponents?: boolean;

**React only**.
Deprecated
As of v32 custom components are created reactively by default. Set this property to false to switch to the legacy way of declaring custom components imperatively. true

property readOnlyEdit

readOnlyEdit?: boolean;

Set to true to stop the grid updating data after Edit, Clipboard and Fill Handle operations. When this is set, it is intended the application will update the data, eg in an external immutable store, and then pass the new dataset to the grid. **Note:** rowNode.setDataValue() does not update the value of the cell when this is True, it fires onCellEditRequest instead. false TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property refreshAfterGroupEdit

refreshAfterGroupEdit?: boolean;

When true, the grid re-evaluates the grouping hierarchy after editing a grouped column value, moving the row to the correct group instantly. Also enables managed row dragging to update grouped column values so rows can move between groups. false RowGroupingModule / TreeDataModule

property removePivotHeaderRowWhenSingleValueColumn

removePivotHeaderRowWhenSingleValueColumn?: boolean;

Set to true to omit the value Column header when there is only a single value column. false PivotModule

property renderingMode

renderingMode?: 'default' | 'legacy';

** React only**.
Enables fine grained control over the row rendering mechanism. - default - recommended rendering approach. - legacy - provided for backwards compatibility with previous versions of AG Grid (<= v33). Is susceptible to "Maximum Update Depth Exceeded" errors and so may be removed in a future version. 'default'

property resetRowDataOnUpdate

resetRowDataOnUpdate?: boolean;

When enabled, getRowId() callback is implemented and new Row Data is set, the grid will disregard all previous rows and treat the new Row Data as new data. As a consequence, all Row State (eg selection, rendered rows) will be reset. false ClientSideRowModelModule

property rowBuffer

rowBuffer?: number;

The number of rows rendered outside the viewable area the grid renders. Having a buffer means the grid will have rows ready to show as the user slowly scrolls vertically. 10

property rowClass

rowClass?: string | string[];

CSS class(es) for all rows. Provide either a string (class name) or array of strings (array of class names). RowStyleModule

property rowClassRules

rowClassRules?: RowClassRules<TData>;

Rules which can be applied to include certain CSS classes. RowStyleModule

property rowData

rowData?: TData[] | null;

Set the data to be displayed as rows in the grid. ClientSideRowModelModule

property rowDragEntireRow

rowDragEntireRow?: boolean;

Set to true to enable clicking and dragging anywhere on the row without the need for a drag handle. false RowDragModule

property rowDragInsertDelay

rowDragInsertDelay?: number;

Used if rowDragManaged is enabled and treeData is enabled, - If the row is already a group, but is not expanded, it will be expanded after rowDragInsertDelay milliseconds of dragging over it. - If the row is a leaf (no children), it will be converted to a group and the row inserted into it after rowDragInsertDelay milliseconds of dragging over it. 500 RowDragModule

property rowDragManaged

rowDragManaged?: boolean;

Set to true to enable Managed Row Dragging. false RowDragModule

property rowDragMultiRow

rowDragMultiRow?: boolean;

Set to true to enable dragging multiple rows at the same time. false RowDragModule

property rowDragText

rowDragText?: RowDragTextFunc;

A callback that should return a string to be displayed by the rowDragComp while dragging a row. If this callback is not set, the current cell value will be used. If the rowDragText callback is set in the ColDef it will take precedence over this, except when rowDragEntireRow=true. RowDragModule

property rowGroupPanelShow

rowGroupPanelShow?: 'always' | 'onlyWhenGrouping' | 'never';

When to show the 'row group panel' (where you drag rows to group) at the top. 'never' RowGroupingPanelModule

property rowGroupPanelSuppressSort

rowGroupPanelSuppressSort?: boolean;

Set to true to suppress sort indicators and actions from the row group panel. false RowGroupingPanelModule

property rowModelType

rowModelType?: RowModelType;

Sets the row model type. 'clientSide' ClientSideRowModelModule / InfiniteRowModelModule / ServerSideRowModelModule / ViewportRowModelModule

property rowMultiSelectWithClick

rowMultiSelectWithClick?: boolean;

Set to true to allow multiple rows to be selected using single click. false
Deprecated
v32.2 Use rowSelection.enableSelectionWithoutKeys instead

property rowNumbers

rowNumbers?: boolean | RowNumbersOptions;

Configure the Row Numbers Feature. false RowNumbersModule

property rowSelection

rowSelection?: RowSelectionOptions<TData> | 'single' | 'multiple';

Use the RowSelectionOptions object to configure row selection. The string values 'single' and 'multiple' are deprecated. RowSelectionModule

property rowStyle

rowStyle?: RowStyle;

The style properties to apply to all rows. Set to an object of key (style names) and values (style values). RowStyleModule

property scrollbarWidth

scrollbarWidth?: number;

Tell the grid how wide in pixels the scrollbar is, which is used in grid width calculations. Set only if using non-standard browser-provided scrollbars, so the grid can use the non-standard size in its calculations.

property selectionColumnDef

selectionColumnDef?: SelectionColumnDef;

Configure the selection column, used for displaying checkboxes.
Note that due to the nature of this column, this type is a subset of ColDef, which does not support several normal column features such as editing, pivoting and grouping.

property sendToClipboard

sendToClipboard?: SendToClipboard<TData>;

Allows you to get the data that would otherwise go to the clipboard. To be used when you want to control the 'copy to clipboard' operation yourself. ClipboardModule

property serverSideDatasource

serverSideDatasource?: IServerSideDatasource;

Provide the serverSideDatasource for server side row model. ServerSideRowModelModule

property serverSideEnableClientSideSort

serverSideEnableClientSideSort?: boolean;

When enabled, sorts fully loaded groups in the browser instead of requesting from the server. false ServerSideRowModelModule

property serverSideInitialRowCount

serverSideInitialRowCount?: number;

Set how many loading rows to display to the user for the root level group. 1 ServerSideRowModelModule

property serverSideOnlyRefreshFilteredGroups

serverSideOnlyRefreshFilteredGroups?: boolean;

When enabled, only refresh groups directly impacted by a filter. This property only applies when there is Row Grouping & filtering is handled on the server. false ServerSideRowModelModule

property serverSidePivotResultFieldSeparator

serverSidePivotResultFieldSeparator?: string;

Used to split pivot field strings for generating pivot result columns when pivotResultFields is provided as part of a getRows success. '_' ServerSideRowModelModule

property serverSideSortAllLevels

serverSideSortAllLevels?: boolean;

When enabled, always refreshes top level groups regardless of which column was sorted. This property only applies when there is Row Grouping & sorting is handled on the server. false ServerSideRowModelModule

property showOpenedGroup

showOpenedGroup?: boolean;

Shows the open group in the group column for non-group rows. false RowGroupingModule

sideBar?: SideBarDef | string | string[] | boolean | null;

Specifies the side bar components. SideBarModule

property singleClickEdit

singleClickEdit?: boolean;

Set to true to enable Single Click Editing for cells, to start editing with a single click. false TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property skipHeaderOnAutoSize

skipHeaderOnAutoSize?: boolean;

Set this to true to skip the headerName when autoSize is called by default. false ColumnAutoSizeModule

property sortingOrder

sortingOrder?: SortDirection[];

Array defining the order in which sorting occurs (if sorting is enabled). Values can be 'asc', 'desc' or null. For example: sortingOrder: ['asc', 'desc']. [null, 'asc', 'desc']
Deprecated
v33 Use defaultColDef.sortingOrder instead

property ssrmExpandAllAffectsAllRows

ssrmExpandAllAffectsAllRows?: boolean;

Controls how expand/collapse operations affect all rows and group interactions. If true, expandAll / collapseAll applies to all rows (not just loaded ones), and interacting with the group overrides the default expansion state set by isServerSideGroupOpenByDefault. RowGroupingModule / TreeDataModule

property statusBar

statusBar?: StatusBar;

Specifies the status bar components to use in the status bar. StatusBarModule

property stopEditingWhenCellsLoseFocus

stopEditingWhenCellsLoseFocus?: boolean;

Set this to true to stop cell editing when grid loses focus. The default is that the grid stays editing until focus goes onto another cell. false TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property styleNonce

styleNonce?: string;

The nonce attribute to set on style elements added to the document by themes. If "foo" is passed to this property, the grid can use the Content Security Policy style-src 'nonce-foo', instead of the less secure style-src 'unsafe-inline'.
Note: CSP nonces are global to a page, where a page has multiple grids, every one must have the same styleNonce set.

property suppressAdvancedFilterEval

suppressAdvancedFilterEval?: boolean;

Deprecated
As of v34, advanced filter no longer uses function evaluation, so this option has no effect. true AdvancedFilterModule

property suppressAggFilteredOnly

suppressAggFilteredOnly?: boolean;

Set to true so that aggregations are not impacted by filtering. false RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property suppressAggFuncInHeader

suppressAggFuncInHeader?: boolean;

When true, column headers won't include the aggFunc name, e.g. 'sum(Bank Balance)' will just be 'Bank Balance'. false RowGroupingModule / PivotModule / TreeDataModule / ServerSideRowModelModule

property suppressAnimationFrame

suppressAnimationFrame?: boolean;

When true, the grid will not use animation frames when drawing rows while scrolling. Use this if and only if the grid is working fast enough on all users machines and you want to avoid the temporarily empty rows. **Note:** It is not recommended to set suppressAnimationFrame to true in most use cases as this can seriously degrade the user experience as all cells are rendered synchronously blocking the UI thread from scrolling. false

property suppressAutoSize

suppressAutoSize?: boolean;

Suppresses auto-sizing columns for columns. In other words, double clicking a column's header's edge will not auto-size. false

property suppressBrowserResizeObserver

suppressBrowserResizeObserver?: boolean;

Deprecated
As of v32.2 the grid always uses the browser's ResizeObserver, this grid option has no effect false

property suppressCellFocus

suppressCellFocus?: boolean;

If true, cells won't be focusable. This means keyboard navigation will be disabled for grid cells, but remain enabled in other elements of the grid such as column headers, floating filters, tool panels. false

property suppressChangeDetection

suppressChangeDetection?: boolean;

Disables change detection. false

property suppressClearOnFillReduction

suppressClearOnFillReduction?: boolean;

Set this to true to prevent cell values from being cleared when the Range Selection is reduced by the Fill Handle. false
Deprecated
v32.2 Use cellSelection.suppressClearOnFillReduction instead

property suppressClickEdit

suppressClickEdit?: boolean;

Set to true so that neither single nor double click starts editing. false TextEditorModule / LargeTextEditorModule / NumberEditorModule / DateEditorModule / CheckboxEditorModule / CustomEditorModule / SelectEditorModule / RichSelectModule

property suppressClipboardApi

suppressClipboardApi?: boolean;

Set to true to stop the grid trying to use the Clipboard API, if it is blocked, and immediately fallback to the workaround. false ClipboardModule

property suppressClipboardPaste

suppressClipboardPaste?: boolean;

Set to true to turn off paste operations within the grid. false ClipboardModule

property suppressColumnMoveAnimation

suppressColumnMoveAnimation?: boolean;

If true, the ag-column-moving class is not added to the grid while columns are moving. In the default themes, this results in no animation when moving columns. false

property suppressColumnVirtualisation

suppressColumnVirtualisation?: boolean;

Set to true so that the grid doesn't virtualise the columns. For example, if you have 100 columns, but only 10 visible due to scrolling, all 100 will always be rendered. **It is not recommended to set this to true as it may cause performance issues.** false

property suppressContentVisibilityAuto

suppressContentVisibilityAuto?: boolean;

Set to true to suppress content-visibility: auto on the grid wrapper element. This degrades performance by causing the browser to render grids even when they are off screen, but may be necessary if your application depends on receiving resize events from hidden grids. false

property suppressContextMenu

suppressContextMenu?: boolean;

Set to true to not show the context menu. Use if you don't want to use the default 'right click' context menu. false

property suppressCopyRowsToClipboard

suppressCopyRowsToClipboard?: boolean;

Set to true to copy the cell range or focused cell to the clipboard and never the selected rows. false
Deprecated
v32.2 Use rowSelection.copySelectedRows instead.

property suppressCopySingleCellRanges

suppressCopySingleCellRanges?: boolean;

Set to true to copy rows instead of ranges when a range with only a single cell is selected. false
Deprecated
v32.2 Use rowSelection.copySelectedRows instead.

property suppressCsvExport

suppressCsvExport?: boolean;

Prevents the user from exporting the grid to CSV. false

property suppressCutToClipboard

suppressCutToClipboard?: boolean;

Set to true to block **cut** operations within the grid. false ClipboardModule

property suppressDragLeaveHidesColumns

suppressDragLeaveHidesColumns?: boolean;

If true, when you drag a column out of the grid (e.g. to the group zone) the column is not hidden. false

property suppressExcelExport

suppressExcelExport?: boolean;

Prevents the user from exporting the grid to Excel. false

property suppressExpandablePivotGroups

suppressExpandablePivotGroups?: boolean;

When enabled, pivot column groups will appear 'fixed', without the ability to expand and collapse the column groups. false PivotModule

property suppressFieldDotNotation

suppressFieldDotNotation?: boolean;

If true, then dots in field names (e.g. 'address.firstLine') are not treated as deep references. Allows you to use dots in your field name if you prefer. false

property suppressFocusAfterRefresh

suppressFocusAfterRefresh?: boolean;

Set to true to not set focus back on the grid after a refresh. This can avoid issues where you want to keep the focus on another part of the browser. false

property suppressGroupChangesColumnVisibility

suppressGroupChangesColumnVisibility?:
    | boolean
    | 'suppressHideOnGroup'
    | 'suppressShowOnUngroup';

Enable to prevent column visibility changing when grouped columns are changed. false

property suppressGroupRowsSticky

suppressGroupRowsSticky?: boolean;

Set to true prevent Group Rows from sticking to the top of the grid. false RowGroupingModule / TreeDataModule

property suppressHeaderFocus

suppressHeaderFocus?: boolean;

If true, header cells won't be focusable. This means keyboard navigation will be disabled for grid header cells, but remain enabled in other elements of the grid such as grid cells and tool panels. false

property suppressHorizontalScroll

suppressHorizontalScroll?: boolean;

Set to true to never show the horizontal scroll. This is useful if the grid is aligned with another grid and will scroll when the other grid scrolls. (Should not be used in combination with alwaysShowHorizontalScroll.) false

property suppressLastEmptyLineOnPaste

suppressLastEmptyLineOnPaste?: boolean;

Set to true to work around a bug with Excel (Windows) that adds an extra empty line at the end of ranges copied to the clipboard. false ClipboardModule

property suppressLoadingOverlay

suppressLoadingOverlay?: boolean;

Disables the 'loading' overlay.
Deprecated
v32 - Deprecated. Use suppressOverlays=['loading'] or loading=false instead. false

property suppressMaintainUnsortedOrder

suppressMaintainUnsortedOrder?: boolean;

Set to true to suppress sorting of un-sorted data to match original row data. false

property suppressMakeColumnVisibleAfterUnGroup

suppressMakeColumnVisibleAfterUnGroup?: boolean;

By default, when a column is un-grouped, i.e. using the Row Group Panel, it is made visible in the grid. This property stops the column becoming visible again when un-grouping. false
Deprecated
v33.0.0 - Use suppressGroupChangesColumnVisibility: 'suppressShowOnUngroup' instead.

property suppressMaxRenderedRowRestriction

suppressMaxRenderedRowRestriction?: boolean;

By default the grid has a limit of rendering a maximum of 500 rows at once (remember the grid only renders rows you can see, so unless your display shows more than 500 rows without vertically scrolling this will never be an issue). **This is only relevant if you are manually setting rowBuffer to a high value (rendering more rows than can be seen), or suppressRowVirtualisation is true, or if your grid height is able to display more than 500 rows at once.** false

property suppressMenuHide

suppressMenuHide?: boolean;

Only recommended for use if columnMenu = 'legacy'. When true, the column menu button will always be shown. When false, the column menu button will only show when the mouse is over the column header. When using columnMenu = 'legacy', this will default to false instead of true. true

property suppressMiddleClickScrolls

suppressMiddleClickScrolls?: boolean;

If true, middle clicks will result in click events for cells and rows. Otherwise the browser will use middle click to scroll the grid.**Note:** Not all browsers fire click events with the middle button. Most will fire only mousedown and mouseup events, which can be used to focus a cell, but will not work to call the onCellClicked function. false

property suppressModelUpdateAfterUpdateTransaction

suppressModelUpdateAfterUpdateTransaction?: boolean;

Prevents Transactions changing sort, filter, group or pivot state when transaction only contains updates. false

property suppressMovableColumns

suppressMovableColumns?: boolean;

Set to true to suppress column moving, i.e. to make the columns fixed position. false

property suppressMoveWhenColumnDragging

suppressMoveWhenColumnDragging?: boolean;

Set to true to suppress moving columns while dragging the Column Header. This option highlights the position where the column will be placed and it will only move it on mouse up. false

property suppressMoveWhenRowDragging

suppressMoveWhenRowDragging?: boolean;

Set to true to suppress moving rows while dragging the rowDrag waffle. This option highlights the position where the row will be placed and it will only move the row on mouse up. false RowDragModule

property suppressMultiRangeSelection

suppressMultiRangeSelection?: boolean;

If true, only a single range can be selected. false
Deprecated
v32.2 Use cellSelection.suppressMultiRanges instead

property suppressMultiSort

suppressMultiSort?: boolean;

Set to true to suppress multi-sort when the user shift-clicks a column header. false

property suppressNoRowsOverlay

suppressNoRowsOverlay?: boolean;

Set to true to prevent the no-rows overlay being shown when there is no row data.
- **Prefer suppressOverlays=['noRows']**
false

property suppressOverlays

suppressOverlays?: OverlayType[];

List of provided overlay names to suppress. One of loading, noRows, noMatchingRows, exporting.

property suppressPaginationPanel

suppressPaginationPanel?: boolean;

If true, the default grid controls for navigation are hidden. This is useful if pagination=true and you want to provide your own pagination controls. Otherwise, when pagination=true the grid automatically shows the necessary controls at the bottom so that the user can navigate through the different pages. false PaginationModule

property suppressPreventDefaultOnMouseWheel

suppressPreventDefaultOnMouseWheel?: boolean;

If true, mouse wheel events will be passed to the browser. Useful if your grid has no vertical scrolls and you want the mouse to scroll the browser page. false

property suppressPropertyNamesCheck

suppressPropertyNamesCheck?: boolean;

Deprecated
As of v33 gridOptions and columnDefs both have a context property that should be used for arbitrary user data. This means that column definitions and gridOptions should only contain valid properties making this property redundant. false

property suppressRowClickSelection

suppressRowClickSelection?: boolean;

If true, row selection won't happen when rows are clicked. Use when you only want checkbox selection. false
Deprecated
v32.2 Use rowSelection.enableClickSelection instead

property suppressRowDeselection

suppressRowDeselection?: boolean;

If true, rows will not be deselected if you hold down Ctrl and click the row or press Space. false
Deprecated
v32.2 Use rowSelection.enableClickSelection instead

property suppressRowDrag

suppressRowDrag?: boolean;

Set to true to suppress row dragging. false

property suppressRowGroupHidesColumns

suppressRowGroupHidesColumns?: boolean;

If true, when you drag a column into a row group panel the column is not hidden. false
Deprecated
v33.0.0 - Use suppressGroupChangesColumnVisibility: 'suppressHideOnGroup' instead.

property suppressRowHoverHighlight

suppressRowHoverHighlight?: boolean;

Set to true to not highlight rows by adding the ag-row-hover CSS class. false

property suppressRowTransform

suppressRowTransform?: boolean;

Uses CSS top instead of CSS transform for positioning rows. Useful if the transform function is causing issues such as used in row spanning. false

property suppressRowVirtualisation

suppressRowVirtualisation?: boolean;

Set to true so that the grid doesn't virtualise the rows. For example, if you have 100 rows, but only 10 visible due to scrolling, all 100 will always be rendered. **It is not recommended to set this to true as it may cause performance issues.** false

property suppressScrollOnNewData

suppressScrollOnNewData?: boolean;

When true, the grid will not scroll to the top when new row data is provided. Use this if you don't want the default behaviour of scrolling to the top every time you load new data. false

property suppressScrollWhenPopupsAreOpen

suppressScrollWhenPopupsAreOpen?: boolean;

When true, the grid will not allow mousewheel / touchpad scroll when popup elements are present. false

property suppressServerSideFullWidthLoadingRow

suppressServerSideFullWidthLoadingRow?: boolean;

When true, the Server-side Row Model will not use a full width loading renderer, instead using the colDef loadingCellRenderer if present. ServerSideRowModelModule

property suppressSetFilterByDefault

suppressSetFilterByDefault?: boolean;

When using AG Grid Enterprise, the Set Filter is used by default when filter: true is set on column definitions. Set to true to prevent this and instead use the Text Filter, Number Filter or Date Filter based on the cell data type, the same as when using AG Grid Community. false TextFilterModule / NumberFilterModule / DateFilterModule / MultiFilterModule / CustomFilterModule

property suppressStartEditOnTab

suppressStartEditOnTab?: boolean;

Determine the behavior when navigating to the next/previous editable cell. Default is to begin editing the cell.

property suppressStickyTotalRow

suppressStickyTotalRow?: boolean | 'grand' | 'group';

Suppress the sticky behaviour of the total rows, can be suppressed individually by passing 'grand' or 'group'. RowGroupingModule / ServerSideRowModelModule

property suppressTouch

suppressTouch?: boolean;

Disables touch support (but does not remove the browser's efforts to simulate mouse events on touch). false

property tabIndex

tabIndex?: number;

Change this value to set the tabIndex order of the Grid within your application. 0

property tabToNextCell

tabToNextCell?: TabToNextCell<TData>;

Allows overriding the default behaviour for when user hits Tab key when a cell is focused. Return the next cell position to navigate to, true to stay on the current cell, or false to let the browser handle the tab behaviour.

property tabToNextGridContainer

tabToNextGridContainer?: TabToNextGridContainer<TData>;

Allows overriding the default behaviour when tabbing between core grid containers. Return a container name, a cell position, or a header position to focus that target, true to stay on the current focus, false to let the browser handle tab behaviour, or undefined to use the grid's default behaviour.

property tabToNextHeader

tabToNextHeader?: TabToNextHeader<TData>;

Allows overriding the default behaviour for when user hits Tab key when a header is focused. Return the next header position to navigate to, true to stay on the current header, or false to let the browser handle the tab behaviour.

property theme

theme?: Theme | 'legacy';

Theme to apply to the grid, or the string "legacy" to opt back into the v32 style of theming where themes were imported as CSS files and applied by setting a class name on the parent element.
themeQuartz

property themeCssLayer

themeCssLayer?: string;

The CSS layer that this theme should be rendered onto. When specified, grid CSS will be wrapped in a @layer ${themeCssLayer} { ... } block.
NOTE: when specifying themeCssLayer we recommend setting themeStyleContainer to document.body to ensure that the grid CSS comes after your application CSS, allowing your application to set the order of layers.
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/@layer

property themeStyleContainer

themeStyleContainer?: HTMLElement | (() => HTMLElement | void);

An element to insert style elements into when injecting styles into the grid. Styles are inserted at the start of the element.
If undefined, styles will be added to the document head for grids rendered in the main document fragment, or to the grid wrapper element for other grids (e.g. those rendered in a shadow DOM or detached from the document).

toolbar?: Toolbar;

Specifies the toolbar items to use in the toolbar. ToolbarModule

property tooltipHideDelay

tooltipHideDelay?: number;

The delay in milliseconds that it takes for tooltips to hide once they have been displayed. **Note:** This property does not work if enableBrowserTooltips is true and tooltipHideTriggers includes timeout. 10000 TooltipModule

property tooltipInteraction

tooltipInteraction?: boolean;

Set to true to enable tooltip interaction. When this option is enabled, the tooltip will not hide while the tooltip itself it being hovered or has focus. false TooltipModule

property tooltipMouseTrack

tooltipMouseTrack?: boolean;

Set to true to have tooltips follow the cursor once they are displayed. false TooltipModule

property tooltipShowDelay

tooltipShowDelay?: number;

The delay in milliseconds that it takes for tooltips to show up once an element is hovered over. **Note:** This property does not work if enableBrowserTooltips is true. 2000 TooltipModule

property tooltipShowMode

tooltipShowMode?: 'standard' | 'whenTruncated';

This defines when tooltip will show up for Cells, Headers and SetFilter Items. - standard - The tooltip always shows up when the items configured with Tooltips are hovered. - whenTruncated - The tooltip will only be displayed when the items hovered have truncated (showing ellipsis) values. This property does not work when enableBrowserTooltips={true}. standard TooltipModule

property tooltipSwitchShowDelay

tooltipSwitchShowDelay?: number;

The delay in milliseconds before a tooltip is shown when moving the pointer from one tooltip-enabled element to another while the previous tooltip is still visible or pending hide. **Note:** This property does not work if enableBrowserTooltips is true. 200 TooltipModule

property tooltipTrigger

tooltipTrigger?: 'hover' | 'focus';

The trigger that will cause tooltips to show and hide. - hover - The tooltip will show/hide when a cell/header is hovered. - focus - The tooltip will show/hide when a cell/header is focused. 'hover' TooltipModule

property treeData

treeData?: boolean;

Set to true to enable the Grid to work with Tree Data. You must also implement the getDataPath(data) callback. false TreeDataModule

property treeDataChildrenField

treeDataChildrenField?: string;

The name of the field to use in a data item to retrieve the array of children nodes of a node when while using treeData=true. It supports accessing nested fields using the dot notation. TreeDataModule

property treeDataDisplayType

treeDataDisplayType?: TreeDataDisplayType;

Specifies how tree data should be displayed.
The options are:
- 'auto': group column automatically added by the grid. - 'custom': informs the grid that group columns will be provided. TreeDataModule

property treeDataParentIdField

treeDataParentIdField?: string;

The name of the field to use in a data item to find the parent node of a node when using treeData=true. The tree will be constructed via relationships between nodes using this field. getRowId callback need to be provided as well for this to work. It supports accessing nested fields using the dot notation. TreeDataModule

property undoRedoCellEditing

undoRedoCellEditing?: boolean;

Set to true to enable Undo / Redo while editing. UndoRedoEditModule

property undoRedoCellEditingLimit

undoRedoCellEditingLimit?: number;

Set the size of the undo / redo stack. 10 UndoRedoEditModule

property unSortIcon

unSortIcon?: boolean;

Set to true to show the 'no sort' icon. false
Deprecated
v33 Use defaultColDef.unSortIcon instead

property valueCache

valueCache?: boolean;

Set to true to turn on the value cache. false ValueCacheModule

property valueCacheNeverExpires

valueCacheNeverExpires?: boolean;

Set to true to configure the value cache to not expire after data updates. false ValueCacheModule

property viewportDatasource

viewportDatasource?: IViewportDatasource;

To use the viewport row model you need to provide the grid with a viewportDatasource. ViewportRowModelModule

property viewportRowModelBufferSize

viewportRowModelBufferSize?: number;

When using viewport row model, sets the buffer size for the viewport. ViewportRowModelModule

property viewportRowModelPageSize

viewportRowModelPageSize?: number;

When using viewport row model, sets the page size for the viewport. ViewportRowModelModule

method onAdvancedFilterBuilderVisibleChanged

onAdvancedFilterBuilderVisibleChanged: (
    event: AdvancedFilterBuilderVisibleChangedEvent<TData>
) => void;

Advanced Filter Builder visibility has changed (opened or closed).

method onAsyncTransactionsFlushed

onAsyncTransactionsFlushed: (
    event: AsyncTransactionsFlushedEvent<TData>
) => void;

Async transactions have been applied. Contains a list of all transaction results.

method onBatchEditingStarted

onBatchEditingStarted: (event: BatchEditingStartedEvent<TData>) => void;

Fired when the first edit is made after api.startBatchEdit() is called. This event fires lazily — not immediately on api.startBatchEdit(), but on the first cell value change or editor open within the batch session.

method onBatchEditingStopped

onBatchEditingStopped: (event: BatchEditingStoppedEvent<TData>) => void;

Batch editing has stopped (when batch editing is enabled). Contains a list of edits if the batch was committed via api.commitBatchEdit().

method onBodyScroll

onBodyScroll: (event: BodyScrollEvent<TData>) => void;

The body was scrolled horizontally or vertically.

method onBodyScrollEnd

onBodyScrollEnd: (event: BodyScrollEndEvent<TData>) => void;

Main body of the grid has stopped scrolling, either horizontally or vertically.

method onCellEditRequest

onCellEditRequest: (event: CellEditRequestEvent<TData>) => void;

Value has changed after editing. Only fires when readOnlyEdit=true.

method onCellSelectionDeleteEnd

onCellSelectionDeleteEnd: (event: CellSelectionDeleteEndEvent<TData>) => void;

Cell selection delete operation (cell clear) has ended.

method onCellSelectionDeleteStart

onCellSelectionDeleteStart: (
    event: CellSelectionDeleteStartEvent<TData>
) => void;

Cell selection delete operation (cell clear) has started.

method onCellValueChanged

onCellValueChanged: (event: CellValueChangedEvent<TData>) => void;

Cell value has changed. This occurs after the following scenarios: - Editing. Will not fire if any of the following are true: new value is the same as old value; readOnlyEdit = true; editing was cancelled (e.g. Escape key was pressed); or new value is of the wrong cell data type for the column. - Cut. - Paste. - Cell clear (pressing Delete key). - Fill handle. - Copy range down. - Undo and redo.

method onChartOptionsChanged

onChartOptionsChanged: (event: ChartOptionsChangedEvent<TData>) => void;

Formatting changes have been made by users through the Customize Panel.

method onChartRangeSelectionChanged

onChartRangeSelectionChanged: (
    event: ChartRangeSelectionChangedEvent<TData>
) => void;

The data range for the chart has been changed.

method onColumnEverythingChanged

onColumnEverythingChanged: (event: ColumnEverythingChangedEvent<TData>) => void;

Deprecated
v32.2 Either use onDisplayedColumnsChanged which is fired at the same time, or use one of the more specific column events.

method onColumnHeaderContextMenu

onColumnHeaderContextMenu: (event: ColumnHeaderContextMenuEvent<TData>) => void;

A context menu action, such as right-click or context menu key press, is performed on a column header.

method onColumnHeaderMouseLeave

onColumnHeaderMouseLeave: (event: ColumnHeaderMouseLeaveEvent<TData>) => void;

A mouse cursor is moved out of a column header.

method onColumnHeaderMouseOver

onColumnHeaderMouseOver: (event: ColumnHeaderMouseOverEvent<TData>) => void;

A mouse cursor is initially moved over a column header.

method onColumnMenuVisibleChanged

onColumnMenuVisibleChanged: (
    event: ColumnMenuVisibleChangedEvent<TData>
) => void;

The column menu visibility has changed. Fires twice if switching between tabs - once with the old tab and once with the new tab.

method onColumnPinned

onColumnPinned: (event: ColumnPinnedEvent<TData>) => void;

A column, or group of columns, was pinned / unpinned.

method onColumnPivotChanged

onColumnPivotChanged: (event: ColumnPivotChangedEvent<TData>) => void;

A pivot column was added, removed or order changed.

method onColumnPivotModeChanged

onColumnPivotModeChanged: (event: ColumnPivotModeChangedEvent<TData>) => void;

The pivot mode flag was changed.

method onColumnRowGroupChanged

onColumnRowGroupChanged: (event: ColumnRowGroupChangedEvent<TData>) => void;

A row group column was added, removed or reordered.

method onColumnsReset

onColumnsReset: (event: ColumnsResetEvent<TData>) => void;

Columns have been reset to their default state as reflected by the colDefs.

method onColumnVisible

onColumnVisible: (event: ColumnVisibleEvent<TData>) => void;

A column, or group of columns, was hidden / shown.

method onComponentStateChanged

onComponentStateChanged: (event: ComponentStateChangedEvent<TData>) => void;

Only used by Angular, React and VueJS AG Grid components (not used if doing plain JavaScript). If the grid receives changes due to bound properties, this event fires after the grid has finished processing the change.

method onContextMenuVisibleChanged

onContextMenuVisibleChanged: (
    event: ContextMenuVisibleChangedEvent<TData>
) => void;

The context menu visibility has changed (opened or closed).

method onDisplayedColumnsChanged

onDisplayedColumnsChanged: (event: DisplayedColumnsChangedEvent<TData>) => void;

The list of displayed columns changed. This can result from columns open / close, column move, pivot, group, etc.

method onDragCancelled

onDragCancelled: (event: DragCancelledEvent<TData>) => void;

When dragging is cancelled stops. This is caused by pressing Escape while dragging elements within the grid that uses the grid's Drag and Drop service, e.g. Column Moving, Column Resizing, Range Selection, Fill Handle, etc.

method onDragStarted

onDragStarted: (event: DragStartedEvent<TData>) => void;

When dragging starts. This could be any action that uses the grid's Drag and Drop service, e.g. Column Moving, Column Resizing, Range Selection, Fill Handle, etc.

method onDragStopped

onDragStopped: (event: DragStoppedEvent<TData>) => void;

When dragging stops. This could be any action that uses the grid's Drag and Drop service, e.g. Column Moving, Column Resizing, Range Selection, Fill Handle, etc.

method onExpandOrCollapseAll

onExpandOrCollapseAll: (event: ExpandOrCollapseAllEvent<TData>) => void;

Fired when calling either of the API methods expandAll() or collapseAll().

method onFilterModified

onFilterModified: (event: FilterModifiedEvent<TData>) => void;

Filter was modified but not applied (when using enableFilterHandlers = false). Used when filters have 'Apply' buttons.

method onFilterUiChanged

onFilterUiChanged: (event: FilterUiChangedEvent<TData>) => void;

Filter UI was modified (when using enableFilterHandlers = true).

method onFindChanged

onFindChanged: (event: FindChangedEvent<TData>) => void;

Find details have changed (e.g. Find search value, active match, or updates to grid cells).

method onFirstDataRendered

onFirstDataRendered: (event: FirstDataRenderedEvent<TData>) => void;

Fired the first time data is rendered into the grid. Use this event if you want to auto resize columns based on their contents

method onFloatingFilterUiChanged

onFloatingFilterUiChanged: (event: FloatingFilterUiChangedEvent<TData>) => void;

Floating filter UI modified (when using enableFilterHandlers = true).

method onGridPreDestroyed

onGridPreDestroyed: (event: GridPreDestroyedEvent<TData>) => void;

Invoked immediately before the grid is destroyed. This is useful for cleanup logic that needs to run before the grid is torn down.

method onGridReady

onGridReady: (event: GridReadyEvent<TData>) => void;

The grid has initialised and is ready for most api calls, but may not be fully rendered yet

method onGridSizeChanged

onGridSizeChanged: (event: GridSizeChangedEvent<TData>) => void;

The size of the grid div has changed. In other words, the grid was resized.

method onModelUpdated

onModelUpdated: (event: ModelUpdatedEvent<TData>) => void;

Displayed rows have changed. Triggered after sort, filter or tree expand / collapse events.

method onPaginationChanged

onPaginationChanged: (event: PaginationChangedEvent<TData>) => void;

Triggered every time the paging state changes. Some of the most common scenarios for this event to be triggered are:
- The page size changes. - The current shown page is changed. - New data is loaded onto the grid.

method onPinnedRowDataChanged

onPinnedRowDataChanged: (event: PinnedRowDataChangedEvent<TData>) => void;

The client has set new pinned row data into the grid.

method onPinnedRowsChanged

onPinnedRowsChanged: (event: PinnedRowsChangedEvent<TData>) => void;

A row has been pinned to top or bottom, or unpinned.

method onPivotMaxColumnsExceeded

onPivotMaxColumnsExceeded: (event: PivotMaxColumnsExceededEvent<TData>) => void;

Exceeded the pivotMaxGeneratedColumns limit when generating columns.

method onRangeDeleteEnd

onRangeDeleteEnd: (event: RangeDeleteEndEvent<TData>) => void;

Range delete operation (cell clear) has ended.
Deprecated
v32.2 Use onCellSelectionDeleteEnd instead

method onRangeDeleteStart

onRangeDeleteStart: (event: RangeDeleteStartEvent<TData>) => void;

Range delete operation (cell clear) has started.
Deprecated
v32.2 Use onCellSelectionDeleteStart instead

method onRangeSelectionChanged

onRangeSelectionChanged: (event: RangeSelectionChangedEvent<TData>) => void;

A change to range selection has occurred.
Deprecated
v32.2 Use onCellSelectionChanged instead

method onRowDataUpdated

onRowDataUpdated: (event: RowDataUpdatedEvent<TData>) => void;

Client-Side Row Model only. The client has updated data for the grid by either a) setting new Row Data or b) Applying a Row Transaction.

method onRowDragCancel

onRowDragCancel: (event: RowDragCancelEvent<TData>) => void;

The drag has been cancelled over the grid.

method onRowDragEnter

onRowDragEnter: (event: RowDragEnterEvent<TData>) => void;

A drag has started, or dragging was already started and the mouse has re-entered the grid having previously left the grid.

method onRowDragLeave

onRowDragLeave: (event: RowDragLeaveEvent<TData>) => void;

The mouse has left the grid while dragging.

method onRowEditingStarted

onRowEditingStarted: (event: RowEditingStartedEvent<TData>) => void;

Editing a row has started (when row editing is enabled). When row editing, this event will be fired once and cellEditingStarted will be fired for each individual cell. Only fires when doing Full Row Editing.

method onRowEditingStopped

onRowEditingStopped: (event: RowEditingStoppedEvent<TData>) => void;

Editing a row has stopped (when row editing is enabled). When row editing, this event will be fired once and cellEditingStopped will be fired for each individual cell. Only fires when doing Full Row Editing.

method onRowResizeEnded

onRowResizeEnded: (event: RowResizeEndedEvent<TData>) => void;

The row resize has ended (Row Numbers Feature)

method onRowResizeStarted

onRowResizeStarted: (event: RowResizeStartedEvent<TData>) => void;

The row resize has started (Row Numbers Feature)

method onRowSelected

onRowSelected: (event: RowSelectedEvent<TData>) => void;

Row is selected or deselected. The event contains the node in question, so call the node's isSelected() method to see if it was just selected or deselected.

method onRowValueChanged

onRowValueChanged: (event: RowValueChangedEvent<TData>) => void;

A cell's value within a row has changed. This event corresponds to Full Row Editing only.

method onSelectionChanged

onSelectionChanged: (event: SelectionChangedEvent<TData>) => void;

Row selection is changed. Use the selectedNodes field to get the list of selected nodes at the time of the event. When using the SSRM, selectedNodes will be null when selecting all nodes. Instead, refer to the serverSideState field.

method onSortChanged

onSortChanged: (event: SortChangedEvent<TData>) => void;

Sort has changed. The grid also listens for this and updates the model.

method onStoreRefreshed

onStoreRefreshed: (event: StoreRefreshedEvent<TData>) => void;

A server side store has finished refreshing.

method onToolPanelVisibleChanged

onToolPanelVisibleChanged: (event: ToolPanelVisibleChangedEvent<TData>) => void;

The tool panel visibility has changed. Fires twice if switching between panels - once with the old panel and once with the new panel.

method onViewportChanged

onViewportChanged: (event: ViewportChangedEvent<TData>) => void;

Which rows are rendered in the DOM has changed.

method onVirtualColumnsChanged

onVirtualColumnsChanged: (event: VirtualColumnsChangedEvent<TData>) => void;

The list of rendered columns changed (only columns in the visible scrolled viewport are rendered by default).

method onVirtualRowRemoved

onVirtualRowRemoved: (event: VirtualRowRemovedEvent<TData>) => void;

A row was removed from the DOM, for any reason. Use to clean up resources (if any) used by the row.

interface GridOptionsChangedEvent

interface GridOptionsChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'gridOptionsChanged', TData, TContext> {}

property options

options: GridOptions;

interface GridPreDestroyedEvent

interface GridPreDestroyedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'gridPreDestroyed', TData, TContext> {}

property state

state: GridState;

Current state of the grid

interface GridReadyEvent

interface GridReadyEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'gridReady', TData, TContext> {}

interface GridSizeChangedEvent

interface GridSizeChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'gridSizeChanged', TData, TContext> {}

interface GridState

interface GridState {}

property aggregation

aggregation?: AggregationState;

Includes aggregation functions (column state)

property columnPinning

columnPinning?: ColumnPinningState;

Includes left/right pinned columns (column state)

property columnSizing

columnSizing?: ColumnSizingState;

Includes column width/flex (column state)

property filter

filter?: FilterState;

Includes Column Filters and Advanced Filter

property focusedCell

focusedCell?: FocusedCellState;

Includes currently focused cell. Works for Client-Side Row Model only

property partialColumnState

partialColumnState?: boolean;

When providing a partial initialState with some but not all column state properties, set this to true. Not required if passing the whole state object retrieved from the grid. Not used for api.setState(), as that instead takes a second argument of properties to ignore.

property pivot

pivot?: PivotState;

Includes current pivot mode and pivot columns (column state)

property rangeSelection

rangeSelection?: RangeSelectionState;

Includes currently selected cell ranges
Deprecated
v32.2 Use cellSelection instead.

property rowGroup

rowGroup?: RowGroupState;

Includes current row group columns (column state)

property rowSelection

rowSelection?:
    | string[]
    | ServerSideRowSelectionState
    | ServerSideRowGroupSelectionState;

Includes currently selected rows. For Server-Side Row Model, will be ServerSideRowSelectionState | ServerSideRowGroupSelectionState, for other row models, will be an array of row IDs. Can only be set for Client-Side Row Model and Server-Side Row Model.

property scroll

scroll?: ScrollState;

Includes current scroll position. Works for Client-Side Row Model only

sideBar?: SideBarState;

Includes current Side Bar positioning and opened tool panel

property sort

sort?: SortState;

Includes current sort columns and direction (column state)

property ssrmRowGroupExpansion

ssrmRowGroupExpansion?: RowGroupExpansionState | RowGroupBulkExpansionState;

Includes currently expanded group rows when using ssrmExpandAllAffectsAllRows

property version

version?: string;

Grid version number

interface GroupChangedEvent

interface GroupChangedEvent<TData = any>
    extends RowNodeEvent<'groupChanged', TData> {}

interface GroupRowEditableCallbackParams

interface GroupRowEditableCallbackParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

Parameters passed to the groupRowEditable callback.

Example 1

colDef.groupRowEditable = (params) => {
    // Only allow editing on leaf-level groups
    return params.node.childrenAfterGroup?.some(child => !child.group) ?? false;
};

interface GroupRowValueSetterDistributionOptions

interface GroupRowValueSetterDistributionOptions {}

Distribution options that can be specified at the top level of GroupRowValueSetterOptions (applying to all aggFuncs) or per aggFunc inside a distribution record entry. Per-aggFunc fields inherit from the top-level options when not specified.
Example 1
colDef.groupRowValueSetter = { distribution: { sum: { distribution: 'percentage', precision: 2 }, }, };

property distribution

distribution?: GroupRowValueSetterDistribution | boolean | null;

Distribution strategy to use. See GroupRowValueSetterDistribution for details. Set to true to use the built-in default. Enables custom aggFuncs with 'overwrite'. Note: count/min/max/first/last are only enabled via explicit per-aggFunc record entries. Useful for overriding false/null from a parent in deep-merge scenarios. Set to false or null to suppress distribution and make the cell not editable. When undefined, inherits from the parent options.
When omitted at all levels, defaults to 'uniform' for sum, 'overwrite' for avg and columns without an aggFunc, and disabled for count/min/max/first/last and custom aggFuncs.

property getValue

getValue?: (params: DistributionGetValueParams) => unknown;

Reads a child's current value during distribution. Default: node.getDataValue(column, 'value'). Override to read from a custom data structure or computed field.
Returns
The child's current value.
Example 1
getValue: (params) => params.data?.weight ?? 0,

property precision

precision?: number | false;

Number of decimal places to round values written to **child rows** during distribution. Spreads any rounding remainder across children so their total matches exactly.
- 0 — integers (e.g. 10 / 3 → [4, 3, 3]) - 2 — two decimals (e.g. 10 / 3 → [3.34, 3.33, 3.33]) - false — disable rounding (overrides auto-detect) - undefined (default) — auto-detect from the column definition: cellEditorParams.precision if set, 0 if cellEditorParams.step is a whole number, no rounding otherwise.
Note: the group row's displayed value is re-computed by the aggFunc after distribution. For sum, the sum of rounded children always honours the same precision. For other aggregation functions like avg, the re-aggregated value may not — for example, the average of integers is not necessarily an integer.
Ignored for bigint columns — bigint values are always distributed as integers.
Example 1
// Round child values to integers colDef.groupRowValueSetter = { precision: 0 }; // Round child values to 2 decimal places (e.g. currency) colDef.groupRowValueSetter = { precision: 2 };

property setValue

setValue?: (params: DistributionSetValueParams) => boolean;

Writes a distributed value to a child. Default: node.setDataValue(column, value, 'data'). Override to write to a custom data structure or apply transformations.
Returns
true if the value was changed, false otherwise.
Example 1
setValue: (params) => // Apply a minimum of 0 before writing params.node.setDataValue(params.column, Math.max(0, Number(params.value)), 'data'),

interface GroupRowValueSetterOptions

interface GroupRowValueSetterOptions<TData = any, TValue = any, TContext = any>
    extends Omit<GroupRowValueSetterDistributionOptions, 'distribution'> {}

Options for the built-in group row value distribution. Assign to colDef.groupRowValueSetter or use true for defaults.

**Defaults by aggFunc:** - No aggFunc: 'overwrite' (writes the edited value to all children) - sum: 'uniform' (divides equally) - avg: 'overwrite' (writes the edited value to all children) - count / min / max / first / last: disabled by default (cell is not editable unless explicitly enabled via a per-aggFunc record entry with true or 'overwrite') - Custom aggFuncs: disabled by default (set a distribution or use default to enable)

Example 1

colDef.groupRowValueSetter = {
    distribution: { sum: 'percentage', avg: 'increment' },
    precision: 0,
};

Example 2

Per-aggFunc with custom callback:

colDef.groupRowValueSetter = {
    distribution: {
        sum: 'percentage',
        myCustomAgg: (params) => {
            for (const child of params.aggregatedChildren) {
                child.setDataValue(params.column, params.newValue, 'data');
            }
        },
    },
    precision: 0,
};

Example 3

Fallback handler for unmatched aggregation functions:

colDef.groupRowValueSetter = {
    distribution: { sum: 'percentage' },
    default: (params) => {
        for (const child of params.aggregatedChildren) {
            child.setDataValue(params.column, params.newValue, 'data');
        }
    },
};

RowGroupingEditModule

property default

default?: GroupRowValueSetterDistributionEntry<TData, TValue, TContext>;

Fallback for aggFuncs that don't have a specific distribution strategy. When distribution is a record, applies to aggFuncs not listed in the record. When distribution is omitted, applies only to custom (non-built-in) aggFuncs. Ignored when distribution is a string (all aggFuncs use the specified strategy).
Accepts the same values as record entries: - A function for full custom handling. - A strategy string (e.g. 'overwrite'). - false or null to suppress distribution and make unmatched aggFunc cells not editable. - An options object with strategy and precision.
Example 1
// Custom handler default: (params) => { for (const child of params.aggregatedChildren) { child.setDataValue(params.column, params.newValue, 'data'); } } // Suppress all unmatched aggFuncs default: false

property distribution

distribution?:
    | GroupRowValueSetterDistribution
    | boolean
    | null
    | GroupRowValueSetterDistributionRecord<TData, TValue, TContext>;

Distribution strategy or per-aggregation-function strategy map.
**As a string:** applies the chosen GroupRowValueSetterDistribution strategy to all aggregation functions.
**As true:** enables distribution using built-in defaults for distributable aggregation functions and custom aggFuncs (which get 'overwrite'). Note: count/min/max/first/last are only enabled via explicit per-aggFunc record entries. Useful for overriding false/null from defaultColDef in deep-merge scenarios.
**As false or null:** suppresses distribution and makes the cell not editable (overriding groupRowEditable).
**As a record:** maps aggFunc names to individual strategies, options objects, or custom callbacks. Unmatched aggFuncs fall through to default, then to the built-in defaults.
Example 1
// Single strategy distribution: 'percentage' // Enable all aggFuncs with built-in defaults distribution: true // Per-aggFunc record (entries can be strings, objects, functions, true, or false/null) distribution: { sum: 'percentage', avg: 'increment', count: true, myAgg: (params) => { ... }, min: false }

interface GroupRowValueSetterParams

interface GroupRowValueSetterParams<TData = any, TValue = any, TContext = any> {}

Parameters passed to a groupRowValueSetter callback when a group row cell is edited.

Example 1

colDef.groupRowValueSetter = (params) => {
    for (const child of params.aggregatedChildren) {
        child.setDataValue(params.column, params.newValue, 'data');
    }
};

property aggregatedChildren

aggregatedChildren: IRowNode<TData>[];

The immediate children that contribute to this group's aggregation.
- **Leaf groups** (groups directly containing data rows): the data rows themselves. - **Non-leaf groups** (groups containing sub-groups): the child group rows. Calling setDataValue() on a child group cascades the edit recursively through the full hierarchy. The built-in distributeGroupValue does this automatically. - **Pivot mode**: only rows matching the edited pivot column's keys are included.
Use rowNode.getAggregatedChildren(colKey) to retrieve the same children programmatically. Pass true as the second argument to collect all descendant leaf rows recursively.
Only supported with the Client-Side Row Model.

property api

api: GridApi<TData>;

The grid api.

property colDef

colDef: ColDef<TData, TValue>;

ColDef provided for this column.

property column

column: Column<TValue>;

Column for this callback.

property context

context: TContext;

Application context as set on gridOptions.context.

property data

data: TData | null | undefined;

Row data for the group node. null or undefined for grouping groups or tree data filler nodes.

property eventSource

eventSource: string | undefined;

What triggered the edit (e.g. 'ui', 'undo', 'paste').

property newValue

newValue: TValue | null | undefined;

The value after the change.

property node

node: IRowNode<TData>;

The group row node being edited.

property oldValue

oldValue: TValue | null | undefined;

The value before the change.

property valueChanged

valueChanged: boolean;

Whether the aggregated value actually changed compared to the previous value.

interface HasChildrenChangedEvent

interface HasChildrenChangedEvent<TData = any>
    extends RowNodeEvent<'hasChildrenChanged', TData> {}

interface HeaderCheckboxSelectionCallbackParams

interface HeaderCheckboxSelectionCallbackParams<
    TData = any,
    TValue = any,
    TContext = any
> extends AgGridCommon<TData, TContext> {}

property colDef

colDef: ColDef<TData, TValue>;

property column

column: Column<TValue>;

interface HeaderClassParams

interface HeaderClassParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef: AbstractColDef<TData, TValue>;

property column

column?: Column<TValue> | null;

property columnGroup

columnGroup?: ColumnGroup | null;

property floatingFilter

floatingFilter: boolean;

interface HeaderFocusedEvent

interface HeaderFocusedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'headerFocused', TData, TContext>,
        HeaderFocusedParams {}

interface HeaderFocusedParams

interface HeaderFocusedParams {}

property column

column: Column | ColumnGroup;

interface HeaderHeightChangedEvent

interface HeaderHeightChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'headerHeightChanged', TData, TContext> {}

interface HeaderPosition

interface HeaderPosition {}

property column

column: Column | ColumnGroup;

The grid column or column group

property headerRowIndex

headerRowIndex: number;

A number from 0 to n, where n is the last header row the grid is rendering

interface HeaderStyle

interface HeaderStyle {}

index signature

[cssProperty: string]: string | number;

interface HeaderValueGetterParams

interface HeaderValueGetterParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef: AbstractColDef<TData, TValue>;

property column

column?: Column<TValue> | null;

Column for this callback if applicable

property columnGroup

columnGroup?: ColumnGroup | ProvidedColumnGroup | null;

ColumnGroup for this callback if applicable

property location

location: HeaderLocation;

Where the column is going to appear

property providedColumnGroup

providedColumnGroup: ProvidedColumnGroup | null;

Original column group if applicable

interface HeightChangedEvent

interface HeightChangedEvent<TData = any>
    extends RowNodeEvent<'heightChanged', TData> {}

interface HeightScaleChangedEvent

interface HeightScaleChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'heightScaleChanged', TData, TContext> {}

interface IAdvancedFilterBuilderParams

interface IAdvancedFilterBuilderParams {}

Parameters passed to the Advanced Filter Builder

property addSelectWidth

addSelectWidth?: number;

Width in pixels of the Advanced Filter Builder add button select popup. 120

property buttons

buttons?: FilterAction[];

Specifies the buttons to be shown in the Advanced Filter Builder, in the order they should be displayed in. The options are:
- 'apply': The Apply button will apply the filter and close the builder. - 'clear': The Clear button will clear the filter in the builder without removing the current active filter. - 'reset': The Reset button will clear the filter and apply an empty filter. - 'cancel': The Cancel button will discard any changes that have been made to the filter in the UI, and close the Builder without applying any changes.
['apply', 'cancel']

property minWidth

minWidth?: number;

Minimum width in pixels of the Advanced Filter Builder popup. 500

property pillSelectMaxWidth

pillSelectMaxWidth?: number;

Max width in pixels of the Advanced Filter Builder pill select popup. 200

property pillSelectMinWidth

pillSelectMinWidth?: number;

Min width in pixels of the Advanced Filter Builder pill select popup. 140

property showMoveButtons

showMoveButtons?: boolean;

Whether to show the move up and move down buttons in the Advanced Filter Builder. false

property suppressFullScreenButton

suppressFullScreenButton?: boolean;

Whether to hide the Full Screen button in the Advanced Filter Builder. false

interface IAdvancedFilterParams

interface IAdvancedFilterParams {}

Parameters passed to the Advanced Filter

property buttons

buttons?: FilterAction[];

Specifies the buttons to be shown in the Advanced Filter, in the order they should be displayed in. The options are:
- 'apply': The Apply button will apply the filter. - 'clear': The Clear button will clear the filter input without removing the current active filter. - 'reset': The Reset button will clear the filter and apply an empty filter. - 'cancel': The Cancel button will discard any changes that have been made to the filter in the UI, restoring the applied model.
['apply']

property suppressBuilderButton

suppressBuilderButton?: boolean;

Whether to hide the Builder button to open the Advanced Filter Builder false

interface IAfterGuiAttachedParams

interface IAfterGuiAttachedParams {}

property container

container?: ContainerType;

Where this component is attached to.

property hidePopup

hidePopup?: () => void;

Call this to hide the popup. i.e useful if your component has an action button and you want to hide the popup after it is pressed.

property suppressFocus

suppressFocus?: boolean;

Set to true to not have the component focus its default item.

interface IAggFuncParams

interface IAggFuncParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property aggregatedChildren

aggregatedChildren: IRowNode<TData>[];

The immediate children of rowNode that contribute to the aggregation.
- For leaf groups (groups containing data rows): returns the data rows. With pivot columns, only rows matching the pivot keys are included. - For non-leaf groups (groups containing other groups): returns the child groups.
See Also
- IRowNode.getAggregatedChildren to retrieve the same children programmatically.

property colDef

colDef: ColDef<TData, TValue>;

ColDef of the aggregation column

property column

column: Column<TValue>;

Column the aggregation function is working on

property data

data: TData;

data (if any) of the parent RowNode

property pivotResultColumn

pivotResultColumn?: Column;

Pivot Result Column being produced using this aggregation

property rowNode

rowNode: IRowNode<TData>;

The parent RowNode, where the aggregation result will be shown

property values

values: (TValue | null)[];

Values to aggregate

interface IAggFuncResult

interface IAggFuncResult<TAggValue = number | bigint | null> {}

Wrapper returned by the built-in avg and count aggregation functions, and the recommended shape for custom agg functions that expose a scalar value alongside metadata (e.g. a count, used when re-aggregating across nested groups).
- avg returns { value, count, toString(), toNumber() } - count returns { value, toString(), toNumber() }
Other built-ins (sum, min, max, first, last) return plain scalars.

property count

count?: number;

The count of aggregated values. Present on avg results.

property value

value?: TAggValue;

The aggregated scalar value.

method toNumber

toNumber: () => TAggValue;

Returns the numeric representation of the aggregated value. Used also for sorting.

method toString

toString: () => string;

Returns a string representation of the aggregated value. Used also for sorting.

interface IAggregationStatusPanelParams

interface IAggregationStatusPanelParams extends IProvidedStatusPanelParams {}

property aggFuncs

aggFuncs: AggregationStatusPanelAggFunc[];

interface IBigIntFilterParams

interface IBigIntFilterParams extends IScalarFilterParams {}

Parameters used in colDef.filterParams to configure a BigInt Filter (agBigIntColumnFilter).

property allowedCharPattern

allowedCharPattern?: string;

When specified, the input field will be of type text, and this will be used as a regex of all the characters that are allowed to be typed. This will be compared against any typed character and prevent the character from appearing in the input if it does not match.

property bigintFormatter

bigintFormatter?: (value: bigint | null) => string | null;

Typically used alongside allowedCharPattern, this provides a custom formatter to convert the bigint value in the filter model into a string to be used in the filter input. This is the inverse of the bigintParser.

property bigintParser

bigintParser?: (text: string | null) => bigint | null;

Typically used alongside allowedCharPattern, this provides a custom parser to convert the value entered in the filter inputs into a bigint that can be used for comparisons.

interface IBigIntFloatingFilterParams

interface IBigIntFloatingFilterParams extends ITextInputFloatingFilterParams {}

interface ICellEditor

interface ICellEditor<TValue = any> extends BaseCellEditor {}

method afterGuiAttached

afterGuiAttached: () => void;

Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen. This method is called each time the edit component is activated. This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.

method getPopupPosition

getPopupPosition: () => 'over' | 'under' | undefined;

Optional: Gets called once, only if isPopup() returns true. Return "over" if the popup should cover the cell, or "under" if it should be positioned below leaving the cell value visible. If this method is not present, the default is "over".

method getValue

getValue: () => TValue | null | undefined;

Mandatory - Return the final value. Called by the grid once after editing is complete.

method isPopup

isPopup: () => boolean;

Optional: Gets called once after initialised. If you return true, the editor will appear in a popup, so is not constrained to the boundaries of the cell. This is great if you want to, for example, provide you own custom dropdown list for selection. Default is false (ie if you don't provide the method).

method refresh

refresh: (params: ICellEditorParams<any, TValue>) => void;

Optional: Gets called with the latest cell editor params every time they update

interface ICellEditorComp

interface ICellEditorComp<TData = any, TValue = any, TContext = any>
    extends ICellEditor<TValue>,
        IPopupComponent<ICellEditorParams<TData, TValue, TContext>> {}

interface ICellEditorParams

interface ICellEditorParams<TData = any, TValue = any, TContext = any>
    extends ICellEditorParamsShared<TData, TValue, TContext> {}

property formatValue

formatValue: (value: TValue | null | undefined) => string;

Utility function to format a value using the column's colDef.valueFormatter

property parseValue

parseValue: (value: string) => TValue | null | undefined;

Utility function to parse a value using the column's colDef.valueParser

interface ICellEditorRendererComp

interface ICellEditorRendererComp<TValue>
    extends IComponent<ICellEditorRendererParams<TValue>> {}

interface ICellEditorRendererParams

interface ICellEditorRendererParams<TValue = any, TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property getValue

getValue: () => TValue[] | TValue | null | undefined;

Gets the current value of the editor

property setTooltip

setTooltip: (value: string, shouldDisplayTooltip: () => boolean) => void;

Used to set a tooltip to the renderer

property setValue

setValue: (value: TValue[] | TValue | null) => void;

Sets the value of the editor

property value

value: TValue[] | TValue | null;

The value to be rendered by the renderer

property valueFormatted

valueFormatted: string;

The value to be renderer by the renderer formatted by the editor

interface ICellRenderer

interface ICellRenderer<TData = any> {}

method refresh

refresh: (params: ICellRendererParams<TData>) => boolean;

Get the cell to refresh. Return true if successful. Return false if not (or you don't have refresh logic), then the grid will refresh the cell for you.

interface ICellRendererComp

interface ICellRendererComp<TData = any>
    extends IComponent<ICellRendererParams<TData>>,
        ICellRenderer<TData> {}

interface ICellRendererParams

interface ICellRendererParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef?: ColDef<TData, TValue>;

The cell's column definition.

property column

column?: Column<TValue>;

The cell's column.

property data

data: TData | undefined;

The row's data. Data property can be undefined when row grouping or loading infinite row models.

property eGridCell

eGridCell: HTMLElement;

The grid's cell, a DOM div element.

property eParentOfValue

eParentOfValue: HTMLElement;

The parent DOM item for the cell renderer, same as eGridCell unless using checkbox selection.

property formatValue

formatValue?: (value: TValue | null | undefined) => string;

Convenience function to format a value using the column's formatter.

property fullWidth

fullWidth?: boolean;

True if this is a full width row.

property getValue

getValue?: () => TValue | null | undefined;

Convenience function to get most recent up to data value.

property node

node: IRowNode<TData>;

The row node.

property pinned

pinned?: 'left' | 'right' | null;

Pinned state of the cell.

property refreshCell

refreshCell?: () => void;

Convenience function to refresh the cell.

property registerRowDragger

registerRowDragger: (
    rowDraggerElement: HTMLElement,
    dragStartPixels?: number,
    value?: string,
    suppressVisibilityChange?: boolean
) => void;

registerRowDragger:
Parameter rowDraggerElement
The HTMLElement to be used as Row Dragger
Parameter dragStartPixels
The amount of pixels required to start the drag (Default: 4)
Parameter value
The value to be displayed while dragging. Note: Only relevant with Full Width Rows.
Parameter suppressVisibilityChange
Set to true to prevent the Grid from hiding the Row Dragger when it is disabled.

property setTooltip

setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;

Sets a tooltip to the main element of this component.
Parameter value
The value to be displayed by the tooltip
Parameter shouldDisplayTooltip
A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when enableBrowserTooltips={true}.

property setValue

setValue?: (value: TValue | null | undefined) => void;

Convenience function to set the value.

property value

value: TValue | null | undefined;

Value to be rendered.

property valueFormatted

valueFormatted: string | null | undefined;

Formatted value to be rendered.

interface IChartService

interface IChartService {}

method closeChartToolPanel

closeChartToolPanel: (chartId: string) => void;

method createChartFromCurrentRange

createChartFromCurrentRange: (
    chartType: ChartType,
    fromApi?: boolean
) => ChartRef | undefined;

method createCrossFilterChart

createCrossFilterChart: (
    params: CreateCrossFilterChartParams,
    fromApi?: boolean
) => ChartRef | undefined;

method createPivotChart

createPivotChart: (
    params: CreatePivotChartParams,
    fromApi?: boolean
) => ChartRef | undefined;

method createRangeChart

createRangeChart: (
    params: CreateRangeChartParams,
    fromApi?: boolean
) => ChartRef | undefined;

method downloadChart

downloadChart: (params: ChartDownloadParams) => void;

method getChartImageDataURL

getChartImageDataURL: (params: GetChartImageDataUrlParams) => string | undefined;

method getChartModels

getChartModels: () => ChartModel[];

method getChartRef

getChartRef: (chartId: string) => ChartRef | undefined;

method isEnterprise

isEnterprise: () => boolean;

method openChartToolPanel

openChartToolPanel: (params: OpenChartToolPanelParams) => void;

method restoreChart

restoreChart: (
    model: ChartModel,
    chartContainer?: HTMLElement
) => ChartRef | undefined;

method updateChart

updateChart: (params: UpdateChartParams) => void;

interface ICheckboxCellRendererParams

interface ICheckboxCellRendererParams<TData = any, TContext = any>
    extends ICellRendererParams<TData, boolean, TContext> {}

property disabled

disabled?: boolean;

Set to true for the input to be disabled.

interface IClientSideRowModel

interface IClientSideRowModel<TData = any> extends IRowModel {}

property hierarchical

hierarchical: boolean;

property rootNode

readonly rootNode: RowNode | null;

The root row containing all the rows

property rowCountReady

readonly rowCountReady: boolean;

method batchUpdateRowData

batchUpdateRowData: (
    rowDataTransaction: RowDataTransaction<TData>,
    callback?: (res: RowNodeTransaction<TData>) => void
) => void;

method doAggregate

doAggregate: (changedPath: ChangedPath | undefined) => void;

method flushAsyncTransactions

flushAsyncTransactions: () => void;

method forEachLeafNode

forEachLeafNode: (callback: ForEachNodeCallback<TData>) => void;

method forEachNodeAfterFilter

forEachNodeAfterFilter: (
    callback: ForEachNodeCallback<TData>,
    includeFooterNodes?: boolean
) => void;

method forEachNodeAfterFilterAndSort

forEachNodeAfterFilterAndSort: (
    callback: ForEachNodeCallback<TData>,
    includeFooterNodes?: boolean
) => void;

method forEachPivotNode

forEachPivotNode: (
    callback: ForEachNodeCallback<TData>,
    includeFooterNodes?: boolean,
    afterSort?: boolean
) => void;

method getFormulaRow

getFormulaRow: (index: number) => RowNode;

method getTopLevelNodes

getTopLevelNodes: () => RowNode[] | null;

method onRowHeightChangedDebounced

onRowHeightChangedDebounced: () => void;

Deprecated
v33.1.0 - use gridApi.onRowHeightChanged() instead

method refreshModel

refreshModel: (params: RefreshModelParams) => void;

method reMapRows

reMapRows: () => void;

Executes the 'map' only if we are not already in the middle of a refresh or data update. Forces also that keepRenderedRows is set to false when 'map' is executed when refresh completes

method updateRowData

updateRowData: (
    rowDataTran: RowDataTransaction<TData>
) => RowNodeTransaction<TData> | null;

interface IClipboardCopyParams

interface IClipboardCopyParams {}

property includeGroupHeaders

includeGroupHeaders?: boolean;

property includeHeaders

includeHeaders?: boolean;

interface IClipboardCopyRowsParams

interface IClipboardCopyRowsParams extends IClipboardCopyParams {}

property columnKeys

columnKeys?: (string | Column)[];

interface IColumnLimit

interface IColumnLimit extends WidthLimits {}

property key

key: Column | string;

Selector for the column to which these dimension limits will apply

interface IColumnToolPanel

interface IColumnToolPanel extends IToolPanel {}

method collapseColumnGroups

collapseColumnGroups: (groupIds?: string[]) => void;

method expandColumnGroups

expandColumnGroups: (groupIds?: string[]) => void;

method getState

getState: () => ColumnToolPanelState;

method setColumnLayout

setColumnLayout: (colDefs: (ColDef | ColGroupDef)[]) => void;

method setPivotModeSectionVisible

setPivotModeSectionVisible: (visible: boolean) => void;

method setPivotSectionVisible

setPivotSectionVisible: (visible: boolean) => void;

method setRowGroupsSectionVisible

setRowGroupsSectionVisible: (visible: boolean) => void;

method setValuesSectionVisible

setValuesSectionVisible: (visible: boolean) => void;

method syncLayoutWithGrid

syncLayoutWithGrid: () => void;

interface ICombinedSimpleModel

interface ICombinedSimpleModel<M extends ISimpleFilterModel>
    extends ProvidedFilterModel {}

property conditions

conditions: M[];

property operator

operator: JoinOperator;

interface IComponent

interface IComponent<T> {}

This is for User Components only, do not implement this for internal components.

method destroy

destroy: () => void;

Gets called once by grid when the component is being removed; if your component needs to do any cleanup, do it here

method getGui

getGui: () => HTMLElement;

Return the DOM element of your component, this is what the grid puts into the DOM

method init

init: (params: T) => AgPromise<void> | void;

The init(params) method is called on the component once.

interface IContextMenuParams

interface IContextMenuParams extends ShowContextMenuParams {}

property x

x?: number;

The x position for the Context Menu, if no value is given and rowNode and column are provided, this will default to be middle of the cell, otherwise it will be 0.

property y

y?: number;

The y position for the Context Menu, if no value is given and rowNode and column are provided, this will default to be middle of the cell, otherwise it will be 0.

interface IContextMenuService

interface IContextMenuService {}

method getContextMenuPosition

getContextMenuPosition: (
    rowNode?: RowNode | null,
    column?: AgColumn | null
) => { x: number; y: number };

method handleContextMenuMouseEvent

handleContextMenuMouseEvent: (
    mouseEvent: MouseEvent | undefined,
    touchEvent: TouchEvent | undefined,
    rowComp: RowCtrl | null,
    cellCtrl: CellCtrl
) => void;

method hideActiveMenu

hideActiveMenu: () => void;

method showContextMenu

showContextMenu: (
    params: EventShowContextMenuParams & { anchorToElement?: HTMLElement }
) => void;

interface ICsvCreator

interface ICsvCreator {}

method exportDataAsCsv

exportDataAsCsv: (params?: CsvExportParams) => void;

method getDataAsCsv

getDataAsCsv: (params?: CsvExportParams, skipDefaultParams?: boolean) => string;

interface IDatasource

interface IDatasource {}

Datasource used by both PaginationController and InfiniteRowModel

property rowCount

rowCount?: number;

If you know up front how many rows are in the dataset, set it here. Otherwise leave blank.

method destroy

destroy: () => void;

Optional destroy method, if your datasource has state it needs to clean up.

method getRows

getRows: (params: IGetRowsParams) => void;

Callback the grid calls that you implement to fetch rows from the server.

interface IDate

interface IDate extends BaseDate {}

method getDate

getDate: () => Date | null;

Returns the current date represented by this component

method refresh

refresh: (params: IDateParams) => void;

When used in a floating filter, a hook to perform any necessary operations when the column definition is updated.

method setDate

setDate: (date: Date | null) => void;

Sets the date represented by this component

interface IDateCellEditorParams

interface IDateCellEditorParams<TData = any, TContext = any>
    extends ICellEditorParams<TData, Date, TContext> {}

property includeTime

includeTime?: boolean;

Defines whether time should be included when editing dates.
- true: Date and time will be editable. - false: Only date portion will be editable.
false

property max

max?: string | Date;

Max allowed value. Either Date object or string in format 'yyyy-mm-dd'.

property min

min?: string | Date;

Min allowed value. Either Date object or string in format 'yyyy-mm-dd'.

property step

step?: number;

Size of the value change when stepping up/down, starting from min or the initial value if provided. Step is also the difference between valid values. If the user-provided value isn't a multiple of the step value from the starting value, it will be considered invalid. Defaults to any value allowed.

interface IDateComp

interface IDateComp extends IComponent<IDateParams>, IDate {}

interface IDateFilterParams

interface IDateFilterParams extends IScalarFilterParams {}

Parameters used in colDef.filterParams to configure a Date Filter (agDateColumnFilter).

property browserDatePicker

browserDatePicker?: boolean;

Defines whether the grid uses the browser date picker or a plain text box. - true: Force the browser date picker to be used. - false: Force a plain text box to be used.
If a date component is not provided, then the grid will use the browser date picker for all supported browsers and a plain text box for other browsers.

property comparator

comparator?: IDateComparatorFunc;

Required if the data for the column are not native JS Date objects. If cell values can contain invalid dates, should also implement isValidDate.

property includeTime

includeTime?: boolean;

Defines whether time should be included when filtering dates.
- true: Include the time component in date comparisons. - false: Only compare dates without considering the time component.
false

property inRangeFloatingFilterDateFormat

inRangeFloatingFilterDateFormat?: string;

Defines the date format for the floating filter text when an inRange filter has been applied.
YYYY-MM-DD

property isValidDate

isValidDate?: (value: any) => boolean;

If providing a comparator and cell values can contain invalid dates, this can be implemented to allow invalid date values to be filtered out (as the comparator only allows for greater than, less than and equals).

property maxValidDate

maxValidDate?: Date | string;

The maximum valid date that can be entered in the filter. It can be a Date object or a string in the format YYYY-MM-DD. If set, this will override maxValidYear - the maximum valid year setting.

property maxValidYear

maxValidYear?: number;

This is the maximum year that may be entered in a date field for the value to be considered valid. Default is no restriction.

property minValidDate

minValidDate?: Date | string;

The minimum valid date that can be entered in the filter. It can be a Date object or a string in the format YYYY-MM-DD. If set, this will override minValidYear - the minimum valid year setting.

property minValidYear

minValidYear?: number;

This is the minimum year that may be entered in a date field for the value to be considered valid. 1000

property useIsoSeparator

useIsoSeparator?: boolean;

By default, the dateFrom and dateTo values in the filter model will be in the format YYYY-MM-DD hh:mm:ss. Set this to true to instead use the format YYYY-MM-DDThh:mm:ss.

interface IDateParams

interface IDateParams<TData = any, TContext = any>
    extends BaseDateParams<TData, TContext> {}

property onDateChanged

onDateChanged: () => void;

Method for component to tell AG Grid that the date has changed.

interface IDateStringCellEditorParams

interface IDateStringCellEditorParams<TData = any, TContext = any>
    extends ICellEditorParams<TData, string, TContext> {}

property includeTime

includeTime?: boolean;

Defines whether time should be included when editing dates.
- true: Date and time will be editable. - false: Only date portion will be editable.
false

property max

max?: string | Date;

Max allowed value. Either Date object or string in format 'yyyy-mm-dd'.

property min

min?: string | Date;

Min allowed value. Either Date object or string in format 'yyyy-mm-dd'.

property step

step?: number;

Size of the value change when stepping up/down, starting from min or the initial value if provided. Step is also the difference between valid values. If the user-provided value isn't a multiple of the step value from the starting value, it will be considered invalid. Defaults to any value allowed.

interface IDetailCellRenderer

interface IDetailCellRenderer<TData = any> {}

method getGui

getGui: () => HTMLElement;

method setDetailGrid

setDetailGrid: (gridOptions: GridOptions<TData>) => void;

method setRowData

setRowData: (rowData: TData[]) => void;

method toggleCss

toggleCss: (cssClassName: string, on: boolean) => void;

method toggleDetailGridCss

toggleDetailGridCss: (cssClassName: string, on: boolean) => void;

interface IDetailCellRendererCtrl

interface IDetailCellRendererCtrl extends Bean {}

method init

init: (comp: IDetailCellRenderer, params: IDetailCellRendererParams) => void;

method refresh

refresh: () => boolean;

method registerDetailWithMaster

registerDetailWithMaster: (api: GridApi) => void;

interface IDetailCellRendererParams

interface IDetailCellRendererParams<TData = any, TDetail = any>
    extends ICellRendererParams<TData>,
        FindDetailGridCellRendererParams<TData> {}

property agGridReact

agGridReact: any;

Deprecated
v32.2 This property is no longer used

property detailGridOptions

detailGridOptions: GridOptions<TDetail>;

Provide Grid Options to use for the Detail Grid.

property frameworkComponentWrapper

frameworkComponentWrapper: any;

Deprecated
v32.2 This property is no longer used

property getDetailRowData

getDetailRowData: GetDetailRowData<TData, TDetail>;

A function that provides what rows to display in the Detail Grid.

property pinned

pinned: 'left' | 'right' | null | undefined;

property refreshStrategy

refreshStrategy: 'rows' | 'everything' | 'nothing';

Defines how to refresh the Detail Grids as data is changing in the Master Grid.

property template

template: string | TemplateFunc<TData>;

Allows changing the template used around the Detail Grid.

interface IDoesFilterPassParams

interface IDoesFilterPassParams<TData = any> {}

property data

data: TData;

The data part of the row node in question.

property node

node: IRowNode<TData>;

The row node in question.

interface IDragAndDropImageComponent

interface IDragAndDropImageComponent<
    TData = any,
    TContext = any,
    TParams extends Readonly<
        IDragAndDropImageParams<TData, TContext>
    > = IDragAndDropImageParams<TData, TContext>
> extends IComponent<TParams>,
        IDragAndDropImage {}

interface IDragAndDropImageParams

interface IDragAndDropImageParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property dragSource

dragSource: DragSource;

interface IErrorValidationParams

interface IErrorValidationParams<TData = any, TValue = any, TContext = any> {}

property cellEditorParams

cellEditorParams: ICellEditorParams<TData, TValue, TContext>;

property internalErrors

internalErrors: string[] | null;

property value

value: TValue | null | undefined;

interface IEventEmitter

interface IEventEmitter<TEventType extends string> {}

method addEventListener

addEventListener: (
    eventType: TEventType,
    listener: IEventListener<TEventType>,
    async?: boolean,
    options?: AddEventListenerOptions
) => void;

method removeEventListener

removeEventListener: (
    eventType: TEventType,
    listener: IEventListener<TEventType>,
    async?: boolean,
    options?: AddEventListenerOptions
) => void;

interface IExcelCreator

interface IExcelCreator {}

method exportDataAsExcel

exportDataAsExcel: (params?: ExcelExportParams) => void;

method exportMultipleSheetsAsExcel

exportMultipleSheetsAsExcel: (params: ExcelExportMultipleSheetParams) => void;

method getDataAsExcel

getDataAsExcel: (params?: ExcelExportParams) => Blob | string | undefined;

method getFactoryMode

getFactoryMode: () => ExcelFactoryMode;

method getMultipleSheetsAsExcel

getMultipleSheetsAsExcel: (
    params: ExcelExportMultipleSheetParams
) => Blob | undefined;

method getSheetDataForExcel

getSheetDataForExcel: (params?: ExcelExportParams) => string;

method setFactoryMode

setFactoryMode: (factoryMode: ExcelFactoryMode) => void;

private methods

interface IExportingOverlay

interface IExportingOverlay<TData = any, TContext = any>
    extends IOverlay<TData, TContext, IExportingOverlayParams<TData, TContext>> {}

interface IExportingOverlayComp

interface IExportingOverlayComp<TData = any, TContext = any>
    extends IOverlayComp<
        TData,
        TContext,
        IExportingOverlayParams<TData, TContext>
    > {}

interface IExportingOverlayParams

interface IExportingOverlayParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property overlayType

overlayType: 'exporting';

The default overlay the grid would show in the given state.

interface IFilter

interface IFilter extends BaseFilter {}

method getModel

getModel: () => any;

Returns a model representing the current state of the filter, or null if the filter is not active. The grid calls getModel() on all active filters when gridApi.getFilterModel() is called.

method isFilterActive

isFilterActive: () => boolean;

Returns true if the filter is currently active, otherwise false. If active then 1) the grid will show the filter icon in the column header and 2) the filter will be included in the filtering of the data.

method refresh

refresh: (newParams: IFilterParams) => boolean;

This method is called when the filter parameters change. The result returned by this method will determine if the filter should be refreshed and reused, or if a new filter instance should be created.
This method should return true if the filter should be refreshed and reused instead of being destroyed. This is useful if the new params passed are compatible with the existing filter instance.
When false is returned, the existing filter will be destroyed and a new filter will be created. This should be done if the new params passed are not compatible with the existing filter instance.
Parameter newParams
New filter params.
Returns
{boolean} - true means that the filter should be refreshed and kept. false means that the filter will be destroyed and a new filter instance will be created.

method setModel

setModel: (model: any) => void | AgPromise<void>;

Sets the state of the filter using the supplied model. Providing null as the model will de-activate the filter.

interface IFilterComp

interface IFilterComp<TData = any>
    extends IComponent<IFilterParams<TData>>,
        IFilter {}

interface IFilterDef

interface IFilterDef {}

property filter

filter?: any;

Filter to use for this column. - Set to true to use the default filter. - Set to the name of a provided filter: agNumberColumnFilter, agBigIntColumnFilter, agTextColumnFilter, agDateColumnFilter, agMultiColumnFilter, agSetColumnFilter. - Set to a custom filter IFilterComp when enableFilterHandlers = false. - Set to a ColumnFilter when enableFilterHandlers = true

property filterParams

filterParams?: any;

Params to be passed to the filter component specified in filter.

property floatingFilterComponent

floatingFilterComponent?: any;

The custom component to be used for rendering the floating filter. If none is specified the default AG Grid is used.

property floatingFilterComponentParams

floatingFilterComponentParams?: any;

Params to be passed to floatingFilterComponent.

interface IFilterOptionDef

interface IFilterOptionDef {}

property displayKey

displayKey: string;

A unique key that does not clash with the built-in filter keys.

property displayName

displayName: string;

Display name for the filter. Can be replaced by a locale-specific value using a localeTextFunc.

property numberOfInputs

numberOfInputs?: 0 | 1 | 2;

Number of inputs to display for this option. Defaults to 1 if unspecified.

property predicate

predicate?: (filterValues: any[], cellValue: any) => boolean;

Custom filter logic that returns a boolean based on the filterValues and cellValue.

interface IFilterPanelService

interface IFilterPanelService
    extends IEventEmitter<'filterPanelStateChanged' | 'filterPanelStatesChanged'> {}

property isActive

isActive: boolean;

method add

add: (id: string) => void;

method clear

clear: () => void;

method doAction

doAction: (action: FilterAction) => void;

method expand

expand: (id: string, expanded: boolean) => void;

method getActions

getActions: () => { actions: FilterAction[]; canApply: boolean } | undefined;

method getAvailable

getAvailable: () => { id: string; name: string }[];

method getGridState

getGridState: () => NewFiltersToolPanelState;

method getIds

getIds: () => string[];

method getState

getState: (id: string) => FilterPanelFilterState | undefined;

method remove

remove: (id: string) => void;

method updateParams

updateParams: (
    params: IToolPanelNewFiltersCompParams,
    initialState?: NewFiltersToolPanelState
) => void;

method updateType

updateType: (id: string, filterDef: SelectableFilterDef) => void;

interface IFilterParams

interface IFilterParams<TData = any, TContext = any>
    extends BaseFilterParams<TData, TContext> {}

Parameters provided by the grid to the init method of an IFilterComp

property filterChangedCallback

filterChangedCallback: (additionalEventAttributes?: any) => void;

A function callback to be called when the filter changes. The grid will then respond by filtering the grid data. The callback takes one optional parameter which, if included, will get merged to the FilterChangedEvent object (useful for passing additional information to anyone listening to this event, however such extra attributes are not used by the grid).

property filterModifiedCallback

filterModifiedCallback: (additionalEventAttributes?: any) => void;

A function callback, to be optionally called, when the filter UI changes. The grid will respond with emitting a FilterModifiedEvent. Apart from emitting the event, the grid takes no further action. The callback takes one optional parameter which, if included, will get merged to the FilterModifiedEvent object.

interface IFilterPlaceholderFunctionParams

interface IFilterPlaceholderFunctionParams {}

filterOption: string;

The filter option name as localised text

property filterOptionKey

filterOptionKey: ISimpleFilterModelType;

The filter option key

property placeholder

placeholder: string;

The default placeholder text

interface IFiltersToolPanel

interface IFiltersToolPanel extends IToolPanel {}

method collapseFilterGroups

collapseFilterGroups: (groupIds?: string[]) => void;

method collapseFilters

collapseFilters: (colIds?: string[]) => void;

method expandFilterGroups

expandFilterGroups: (groupIds?: string[]) => void;

method expandFilters

expandFilters: (colIds?: string[]) => void;

method getState

getState: () => FiltersToolPanelState;

method setFilterLayout

setFilterLayout: (colDefs: ColDef[]) => void;

method syncLayoutWithGrid

syncLayoutWithGrid: () => void;

interface IFindService

interface IFindService {}

property activeMatch

activeMatch: FindMatch | undefined;

property totalMatches

totalMatches: number;

method clearActive

clearActive: () => void;

method getNumMatches

getNumMatches: (node: IRowNode, column: Column | null) => number;

method getParts

getParts: (params: FindCellValueParams) => FindPart[];

method goTo

goTo: (match: number, force?: boolean) => void;

method isMatch

isMatch: (node: IRowNode, column: Column | null) => boolean;

method next

next: () => void;

method previous

previous: () => void;

method refresh

refresh: (maintainActive: boolean) => void;

method registerDetailGrid

registerDetailGrid: (node: IRowNode, api: GridApi) => void;

interface IFloatingFilter

interface IFloatingFilter<P = any> extends BaseFloatingFilter {}

method onParentModelChanged

onParentModelChanged: (
    parentModel: any,
    filterChangedEvent?: FilterChangedEvent | null
) => void;

Gets called every time the parent filter changes. Your floating filter would typically refresh its UI to reflect the new filter state. The provided parentModel is what the parent filter returns from its getModel() method. The event is the FilterChangedEvent that the grid fires.

method refresh

refresh: (params: IFloatingFilterParams<P>) => void;

A hook to perform any necessary operations when the column definition is updated.

interface IFloatingFilterComp

interface IFloatingFilterComp<P = any>
    extends IFloatingFilter<P>,
        IComponent<IFloatingFilterParams<P>> {}

interface IFloatingFilterParams

interface IFloatingFilterParams<P = InbuiltParentType, TData = any, TContext = any>
    extends SharedFloatingFilterParams<TData, TContext> {}

property currentParentModel

currentParentModel: () => any;

This is a shortcut to invoke getModel on the parent filter. If the parent filter doesn't exist (filters are lazily created as needed) then it returns null rather than calling getModel() on the parent filter.

property filterParams

filterParams: IFilterParams;

The params object passed to the filter. This is to allow the floating filter access to the configuration of the parent filter. For example, the provided filters use debounceMs from the parent filter params.

property filterPlaceholder

filterPlaceholder?: string | boolean;

Placeholder text for the filter textbox. When set to true, inherits the placeholder text of the parent filter.

property parentFilterInstance

parentFilterInstance: (callback: IFloatingFilterParentCallback<P>) => void;

Gets a reference to the parent filter. The result is returned asynchronously via a callback as the parent filter may not exist yet. If it does not exist, it is created and asynchronously returned (AG Grid itself does not create components asynchronously, however if providing a framework provided filter e.g. React, it might be).
The floating filter can then call any method it likes on the parent filter. The parent filter will typically provide its own method for the floating filter to call to set the filter. For example, if creating custom filter A, it should have a method your floating A can call to set the state when the user updates via the floating filter.

interface IFloatingFilterParent

interface IFloatingFilterParent {}

method onFloatingFilterChanged

onFloatingFilterChanged: (type: string | null, value: any) => void;

Notification that a new floating-filter value was input by the user.
Parameter type
operation type selected.
Parameter value
model-typed value entered.

interface IFormulaCellEditorParams

interface IFormulaCellEditorParams<TData = any, TValue = any, TContext = any>
    extends ICellEditorParams<TData, TValue, TContext> {}

property validateFormulas

validateFormulas?: boolean;

Set to true to validate formulas while editing. If a custom getValidationErrors is provided, internal validation will still run. false

interface IFormulaDataService

interface IFormulaDataService extends Bean {}

method getFormula

getFormula: (params: GetFormulaParams) => string | undefined;

method hasDataSource

hasDataSource: () => boolean;

method setFormula

setFormula: (params: SetFormulaParams) => void;

interface IFormulaInputManagerService

interface IFormulaInputManagerService extends Bean {}

method isActiveEditor

isActiveEditor: (editorId: number) => boolean;

method registerActiveEditor

registerActiveEditor: (editorId: number, onDeactivate: () => void) => boolean;

method unregisterActiveEditor

unregisterActiveEditor: (editorId: number, onDeactivate: () => void) => void;

interface IFormulaService

interface IFormulaService extends Bean {}

property active

active: boolean;

method getColByRef

getColByRef: (ref: string) => AgColumn | null;

method getColRef

getColRef: (col: AgColumn) => string | null;

method getDataSourceFormula

getDataSourceFormula: (row: RowNode, col: AgColumn) => string | undefined;

method getFormulaError

getFormulaError: (col: AgColumn, row: RowNode) => Error | null;

method getFunction

getFunction: (name: string) => (params: FormulaFunctionParams) => unknown;

method getFunctionNames

getFunctionNames: () => string[];

method hasCachedRows

hasCachedRows: () => boolean;

method isFormula

isFormula: (value: unknown) => value is `=${string}`;

method normaliseFormula

normaliseFormula: (value: string, shorthand: boolean) => string | null;

method onRowsChanged

onRowsChanged: (
    changedRowNodes: ChangedRowNodes | undefined,
    newData: boolean | undefined
) => void;

Called by CSRM after every model refresh so the service can evict cache entries for destroyed rows and, if the row order or set changed, drop stale computed values while keeping parsed ASTs.

method refreshFormulas

refreshFormulas: (refreshRows: boolean) => void;

method refreshRow

refreshRow: (row: RowNode | string) => boolean;

Drop a row's formula cache (including pinned / group-footer siblings) and repaint. Accepts a RowNode directly, or a row id string — in which case the main row model, pinned-top and pinned-bottom row models are all consulted and every matching chain is invalidated. Returns true when at least one entry was dropped.

method resolveValue

resolveValue: (col: AgColumn, row: RowNode) => unknown;

method setFormulasActive

setFormulasActive: (cols: ColumnCollections) => void;

method updateFormulaByOffset

updateFormulaByOffset: (params: {
    value: string;
    rowDelta?: number;
    columnDelta?: number;
    useRefFormat?: boolean;
}) => string;

interface IGetRowsParams

interface IGetRowsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

Params for the above IDatasource.getRows()

property endRow

endRow: number;

The first row index to NOT get.

property filterModel

filterModel: any;

If doing server side filtering, contains the filter model

property sortModel

sortModel: SortModelItem[];

If doing server side sorting, contains the sort model

property startRow

startRow: number;

The first row index to get.

method failCallback

failCallback: () => void;

Callback to call when the request fails.

method successCallback

successCallback: (rowsThisBlock: any[], lastRow?: number) => void;

Callback to call for the result when successful.

interface IGroupCellRenderer

interface IGroupCellRenderer {}

method setCheckboxSpacing

setCheckboxSpacing: (add: boolean) => void;

method setCheckboxVisible

setCheckboxVisible: (value: boolean) => void;

method setChildCount

setChildCount: (count: string) => void;

method setContractedDisplayed

setContractedDisplayed: (value: boolean) => void;

method setExpandedDisplayed

setExpandedDisplayed: (value: boolean) => void;

method setInnerRenderer

setInnerRenderer: (
    compDetails: UserCompDetails | undefined,
    valueToDisplay: any
) => void;

method toggleCss

toggleCss: (cssClassName: string, on: boolean) => void;

interface IGroupCellRendererCtrl

interface IGroupCellRendererCtrl<TData = any, TValue = any> {}

method destroy

destroy: () => void;

method getCellAriaRole

getCellAriaRole: () => string;

method init

init: (
    comp: IGroupCellRenderer,
    eGui: HTMLElement,
    eCheckbox: HTMLElement,
    eExpanded: HTMLElement,
    eContracted: HTMLElement,
    compClass: any,
    params: GroupCellRendererParams<TData, TValue>
) => void;

interface IGroupCellRendererFullRowParams

interface IGroupCellRendererFullRowParams {}

property fullWidth

fullWidth: boolean;

'true' if comp is showing full width.

property pinned

pinned?: 'left' | 'right' | null;

Only when in fullWidth, this gives whether the comp is pinned or not. If not doing fullWidth, then this is not provided, as pinned can be got from the column.

property rowDrag

rowDrag?: boolean;

interface IGroupCellRendererParams

interface IGroupCellRendererParams<TData = any, TValue = any> {}

Parameters used in colDef.cellRendererParams to configure a Group Cell Renderer (agGroupCellRenderer).

property checkbox

checkbox?: boolean | GroupCheckboxSelectionCallback<TData, TValue>;

Set to true, or a function that returns true, if a checkbox should be included.
Deprecated
v33 Use rowSelection.checkboxes and rowSelection.checkboxLocation instead.

property innerRenderer

innerRenderer?: any;

The renderer to use for inside the cell (after grouping functions are added)

property innerRendererParams

innerRendererParams?: any;

Additional params to customise to the innerRenderer.

property innerRendererSelector

innerRendererSelector?: CellRendererSelectorFunc;

Callback to enable different innerRenderers to be used based of value of params.

property suppressCount

suppressCount?: boolean;

If true, count is not displayed beside the name.

property suppressDoubleClickExpand

suppressDoubleClickExpand?: boolean;

Set to true to suppress expand on double click.

property suppressEnterExpand

suppressEnterExpand?: boolean;

Set to true to suppress expand on ↵ Enter

property suppressPadding

suppressPadding?: boolean;

Set to true to not include any padding (indentation) in the child rows.

property totalValueGetter

totalValueGetter?: string | TotalValueGetterFunc;

The value getter for the total row text. Can be a function or expression.

interface IHeader

interface IHeader {}

method refresh

refresh: (params: IHeaderParams) => boolean;

Get the header to refresh. Gets called whenever Column Defs are updated.

interface IHeaderComp

interface IHeaderComp extends IHeader, IComponent<IHeaderParams> {}

interface IHeaderGroup

interface IHeaderGroup {}

interface IHeaderGroupComp

interface IHeaderGroupComp extends IHeaderGroup, IComponent<IHeaderGroupParams> {}

interface IHeaderGroupParams

interface IHeaderGroupParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property columnGroup

columnGroup: ColumnGroup;

The column group the header is for.

property displayName

displayName: string;

The text label to render. If the column is using a headerValueGetter, the displayName will take this into account.

property eGridHeader

eGridHeader: HTMLElement;

The header the grid provides. The custom group header component is a child of the grid provided header. The grid's header component is what contains the grid managed functionality such as resizing, keyboard navigation etc. This is provided should you want to make changes to this cell, eg add ARIA tags, or add keyboard event listener (as focus goes here when navigating to the header).

property innerHeaderGroupComponent

innerHeaderGroupComponent?: any;

The component to use for inside the header group (replaces the text value and leaves the remainder of the Grid's original component).

property innerHeaderGroupComponentParams

innerHeaderGroupComponentParams?: any;

Additional params to customise to the innerHeaderGroupComponent.

property setExpanded

setExpanded: (expanded: boolean) => void;

Opens / closes the column group

property setTooltip

setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;

Sets a tooltip to the main element of this component.
Parameter value
The value to be displayed by the tooltip
Parameter shouldDisplayTooltip
A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when enableBrowserTooltips={true}.

property showColumnMenu

showColumnMenu: (source: HTMLElement, onClosedCallback?: () => void) => void;

Callback to request the grid to show the column menu. Pass in an html element to have the grid position the menu over the element. If provided, the grid will call onClosedCallback when the menu is closed. Note that this only works with the new column menu.

property showColumnMenuAfterMouseClick

showColumnMenuAfterMouseClick: (
    mouseEvent: MouseEvent | Touch,
    onClosedCallback?: () => void
) => void;

Callback to request the grid to show the column menu. Similar to showColumnMenu, but will position the menu next to the provided mouseEvent. If provided, the grid will call onClosedCallback when the menu is closed. Note that this only works with the new column menu.

interface IHeaderParams

interface IHeaderParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column: Column;

The column the header is for.

property displayName

displayName: string;

The name to display for the column. If the column is using a headerValueGetter, the displayName will take this into account.

property eGridHeader

eGridHeader: HTMLElement;

The header the grid provides. The custom header component is a child of the grid provided header. The grid's header component is what contains the grid managed functionality such as resizing, keyboard navigation etc. This is provided should you want to make changes to this cell, eg add ARIA tags, or add keyboard event listener (as focus goes here when navigating to the header).

property enableFilterButton

enableFilterButton: boolean;

Whether filter button should be displayed in the header (for new column menu).

property enableFilterIcon

enableFilterIcon: boolean;

Whether filter icon should be displayed in the header (for legacy tabbed column menu).

property enableMenu

enableMenu: boolean;

Whether menu is enabled for the column. Only display a menu button in your header if this is true.

property enableSorting

enableSorting: boolean | undefined;

Whether sorting is enabled for the column. Only put sort logic into your header if this is true.

property innerHeaderComponent

innerHeaderComponent?: any;

The component to use for inside the header (replaces the text value and leaves the remainder of the Grid's original component).

property innerHeaderComponentParams

innerHeaderComponentParams?: any;

Additional params to customise to the innerHeaderComponent.

property progressSort

progressSort: (multiSort?: boolean) => void;

Callback to progress the sort for this column. The grid will decide the next sort direction eg ascending, descending or 'no sort'. Pass multiSort=true if you want to do a multi sort (eg user has Shift held down when they click).

property setSort

setSort: (sort: SortDirection | SortDef, multiSort?: boolean) => void;

Callback to set the sort for this column. Pass the sort direction to use ignoring the current sort eg one of 'asc', 'desc' or null (for no sort). Pass multiSort=true if you want to do a multi sort (eg user has Shift held down when they click)

property setTooltip

setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;

Sets a tooltip to the main element of this component.
Parameter value
The value to be displayed by the tooltip
Parameter shouldDisplayTooltip
A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when enableBrowserTooltips={true}.

property showColumnMenu

showColumnMenu: (source: HTMLElement, onClosedCallback?: () => void) => void;

Callback to request the grid to show the column menu. Pass in the html element of the column menu button to have the grid position the menu over the button. If provided, the grid will call onClosedCallback when the menu is closed.

property showColumnMenuAfterMouseClick

showColumnMenuAfterMouseClick: (
    mouseEvent: MouseEvent | Touch,
    onClosedCallback?: () => void
) => void;

Callback to request the grid to show the column menu. Similar to showColumnMenu, but will position the menu next to the provided mouseEvent. If provided, the grid will call onClosedCallback when the menu is closed.

property showFilter

showFilter: (source: HTMLElement) => void;

Callback to request the grid to show the filter. Pass in the html element of the filter button to have the grid position the menu over the button.

property template

template?: string;

Custom header template if provided to headerComponentParams, otherwise will be undefined. See [Header Templates](https://www.ag-grid.com/javascript-data-grid/column-headers/#header-templates)

interface IInnerHeaderComponent

interface IInnerHeaderComponent<
    TData = any,
    TContext = any,
    TParams extends Readonly<IHeaderParams<TData, TContext>> = IHeaderParams<
        TData,
        TContext
    >
> extends IComponent<TParams>,
        IHeader {}

interface IInnerHeaderGroupComponent

interface IInnerHeaderGroupComponent<
    TData = any,
    TContext = any,
    TParams extends Readonly<
        IHeaderGroupParams<TData, TContext>
    > = IHeaderGroupParams<TData, TContext>
> extends IComponent<TParams>,
        IHeaderGroup {}

interface ILargeTextEditorParams

interface ILargeTextEditorParams extends ICellEditorParams {}

property cols

cols: number;

Number of character columns to display. 60

property maxLength

maxLength: number;

Max number of characters to allow. 200

property rows

rows: number;

Number of character rows to display. 10

interface ILoadingCellRenderer

interface ILoadingCellRenderer {}

interface ILoadingCellRendererComp

interface ILoadingCellRendererComp
    extends ILoadingCellRenderer,
        IComponent<ILoadingCellRendererParams> {}

interface ILoadingCellRendererParams

interface ILoadingCellRendererParams<TData = any, TValue = any, TContext = any>
    extends ICellRendererParams<TData, TValue, TContext> {}

property deferRender

deferRender?: boolean;

true if the loading cell renderer is being displayed in place of a slow cell renderer via cellRendererParams.deferRender.

interface ILoadingOverlay

interface ILoadingOverlay<TData = any, TContext = any>
    extends IOverlay<TData, TContext, ILoadingOverlayParams<TData, TContext>> {}

interface ILoadingOverlayComp

interface ILoadingOverlayComp<TData = any, TContext = any>
    extends IOverlayComp<TData, TContext, ILoadingOverlayParams<TData, TContext>> {}

interface ILoadingOverlayParams

interface ILoadingOverlayParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property overlayType

overlayType: 'loading';

The default overlay the grid would show in the given state.

interface IMasterDetailService

interface IMasterDetailService {}

property store

store: {
    [id: string]: DetailGridInfo | undefined;
};

method getDetail

getDetail: (masterNode: RowNode) => RowNode | null;

Used by flatten stage to get or create a detail node from a master node

method refreshModel

refreshModel: (params: RefreshModelParams) => void;

method setMaster

setMaster: (row: RowNode, created: boolean, updated: boolean) => void;

method setupDetailRowAutoHeight

setupDetailRowAutoHeight: (rowCtrl: RowCtrl, eDetailGui: HTMLElement) => void;

interface IMenuActionParams

interface IMenuActionParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column: Column | null;

The column, if a cell was clicked, otherwise null.

property node

node: IRowNode<TData> | null;

The row node, if a cell was clicked, otherwise null.

property noteParams

noteParams?: GetNoteParams;

The note params for the cell or full width row that was clicked, if notes are enabled.

property value

value: any;

The value, if a cell was clicked, otherwise null.

interface IMenuConfigParams

interface IMenuConfigParams {}

property suppressAria

suppressAria?: boolean;

Suppress setting Aria properties on the root element.

property suppressClick

suppressClick?: boolean;

Suppress handling of click events. If true, the component will need to implement its own click event handler. The grid will no longer handle performing the action and opening the sub menu (if appropriate).

property suppressFocus

suppressFocus?: boolean;

Suppress focusing the root element when made active. If true, will need to handle keyboard navigation.

property suppressKeyboardSelect

suppressKeyboardSelect?: boolean;

Suppress handling of keyboard events to select the current item. If true, the grid will not select the menu item on Enter or Space.

property suppressMouseDown

suppressMouseDown?: boolean;

Suppress handling of mouse down events.

property suppressMouseOver

suppressMouseOver?: boolean;

Suppress handling of mouseenter and mouseleave events. If true, the grid will no longer update the active status of the menu item or open sub menus.

property suppressRootStyles

suppressRootStyles?: boolean;

Suppress setting CSS classes on the root element. If true and mixing custom menu item components with grid-provided ones, will need to style with table display rules, as well as adding active and disabled styling.

property suppressTabIndex

suppressTabIndex?: boolean;

Suppress setting tabindex on the root element. If true, will need to set tabindex elsewhere for keyboard navigation to work.

property suppressTooltip

suppressTooltip?: boolean;

Suppress the grid-provided tooltip on hover.

interface IMenuItem

interface IMenuItem extends BaseMenuItem {}

method setActive

setActive: (active: boolean) => void;

Called when the item is activated/deactivated, either via mouseover or keyboard navigation.

method setExpanded

setExpanded: (expanded: boolean) => void;

If the item has a sub menu, called when the sub menu is opened/closed.

interface IMenuItemComp

interface IMenuItemComp<TData = any, TContext = any>
    extends IComponent<IMenuItemParams<TData, TContext>>,
        IMenuItem {}

interface IMenuItemParams

interface IMenuItemParams<TData = any, TContext = any>
    extends BaseMenuItemParams<TData, TContext> {}

property onItemActivated

onItemActivated: () => void;

Callback to let the menu know that the current item has become active. Required if updating the active status within the menu item.

interface IMultiFilter

interface IMultiFilter extends IProvidedFilter {}

Interface contract for the public aspects of the ProvidedFilter implementation(s).

property filterType

readonly filterType: 'multi';

method getChildFilterInstance

getChildFilterInstance: <TFilter = IFilter>(
    index: number
) => TFilter | undefined;

Returns
the child filter instance at the given index.

interface IMultiFilterComp

interface IMultiFilterComp {}

method getChildFilterInstance

getChildFilterInstance: (index: number) => IFilterComp | undefined;

Returns the child filter instance at the specified index or undefined for an invalid index.

method getModel

getModel: () => ProvidedFilterModel | null;

Returns a model representing the current state of the filter, or null if the filter is not active.

method isFilterActive

isFilterActive: () => boolean;

Returns true if the filter is currently active, otherwise false.

method setModel

setModel: (model: IMultiFilterModel | null) => void | AgPromise<void>;

Sets the state of the child filters using the supplied models. Providing null will de-activate all child filters.
**Note:** if you are providing values asynchronously to a child Set Filter, you need to wait for these changes to be applied before performing any further actions by waiting on the returned grid promise, e.g. filter.setModel([null, { values: ['a', 'b'] }]).then(function() { gridApi.onFilterChanged(); });

interface IMultiFilterDef

interface IMultiFilterDef extends IFilterDef {}

property display

display?: 'inline' | 'accordion' | 'subMenu';

Configures how the filter is shown in the Multi Filter. 'inline'

property filter

filter?: IFilterType | ColumnFilter;

Child filter component to use inside the Multi Filter.

property filterParams

filterParams?: any;

Custom parameters to be passed to the child filter component.

property filterValueGetter

filterValueGetter?: string | ValueGetterFunc;

Function or expression. Gets the value for filtering purposes. Allows for different values to be used for child filters instead of using colDef.filterValueGetter.

property floatingFilterComponent

floatingFilterComponent?: IFloatingFilterType;

Floating filter component to use for the child filter.

property floatingFilterComponentParams

floatingFilterComponentParams?: any;

Custom parameters to be passed to the floating filter component.

property title

title?: string;

The title to be used when a filter is displayed inside a sub-menu or accordion.

interface IMultiFilterModel

interface IMultiFilterModel {}

property filterModels

filterModels: any[] | null;

Child filter models in the same order as the filters are specified in filterParams.

property filterType

filterType?: 'multi';

Multi filter type.

interface IMultiFilterParams

interface IMultiFilterParams {}

Parameters used in colDef.filterParams to configure a Multi Filter (agMultiColumnFilter).

property filters

filters?: IMultiFilterDef[];

An array of filter definition objects.

property readOnly

readOnly?: boolean;

If true, all UI inputs managed by this filter are for display only, and the filter can only be affected by API calls. Does NOT affect child filters, they need to be individually configured with readOnly where applicable. false

interface INewFiltersToolPanel

interface INewFiltersToolPanel extends IToolPanel {}

method getState

getState: () => NewFiltersToolPanelState;

interface InitialGroupOrderComparatorParams

interface InitialGroupOrderComparatorParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property nodeA

nodeA: IRowNode<TData>;

property nodeB

nodeB: IRowNode<TData>;

interface INoMatchingRowsOverlay

interface INoMatchingRowsOverlay<TData = any, TContext = any>
    extends IOverlay<
        TData,
        TContext,
        INoMatchingRowsOverlayParams<TData, TContext>
    > {}

interface INoMatchingRowsOverlayComp

interface INoMatchingRowsOverlayComp<TData = any, TContext = any>
    extends IOverlayComp<
        TData,
        TContext,
        INoMatchingRowsOverlayParams<TData, TContext>
    > {}

interface INoMatchingRowsOverlayParams

interface INoMatchingRowsOverlayParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property overlayType

overlayType: 'noMatchingRows';

The default overlay the grid would show in the given state.

interface INoRowsOverlay

interface INoRowsOverlay<TData = any, TContext = any>
    extends IOverlay<TData, TContext, INoRowsOverlayParams<TData, TContext>> {}

interface INoRowsOverlayComp

interface INoRowsOverlayComp<TData = any, TContext = any>
    extends IOverlayComp<TData, TContext, INoRowsOverlayParams<TData, TContext>> {}

interface INoRowsOverlayParams

interface INoRowsOverlayParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property overlayType

overlayType: 'noRows';

The default overlay the grid would show in the given state.

interface INumberCellEditorParams

interface INumberCellEditorParams<TData = any, TContext = any>
    extends ICellEditorParams<TData, number, TContext> {}

property max

max?: number;

Max allowed value.

property min

min?: number;

Min allowed value.

property precision

precision?: number;

Number of digits allowed after the decimal point.

property preventStepping

preventStepping?: boolean;

Set to true to prevent key up/down from stepping the field's value. false

property showStepperButtons

showStepperButtons?: boolean;

Display stepper buttons in editor. Note: Does not work when preventStepping is true. false

property step

step?: number;

Size of the value change when stepping up/down, starting from min or the initial value if provided. Step is also the difference between valid values. If the user-provided value isn't a multiple of the step value from the starting value, it will be considered invalid. Defaults to any value allowed.

interface INumberFilterParams

interface INumberFilterParams extends IScalarFilterParams {}

Parameters used in colDef.filterParams to configure a Number Filter (agNumberColumnFilter).

property allowedCharPattern

allowedCharPattern?: string;

When specified, the input field will be of type text, and this will be used as a regex of all the characters that are allowed to be typed. This will be compared against any typed character and prevent the character from appearing in the input if it does not match.

property numberFormatter

numberFormatter?: (value: number | null) => string | null;

Typically used alongside allowedCharPattern, this provides a custom formatter to convert the number value in the filter model into a string to be used in the filter input. This is the inverse of the numberParser.

property numberParser

numberParser?: (text: string | null) => number | null;

Typically used alongside allowedCharPattern, this provides a custom parser to convert the value entered in the filter inputs into a number that can be used for comparisons.

interface INumberFloatingFilterParams

interface INumberFloatingFilterParams extends ITextInputFloatingFilterParams {}

interface IOverlay

interface IOverlay<
    TData = any,
    TContext = any,
    TParams extends Readonly<IOverlayParams<TData, TContext>> = IOverlayParams<
        TData,
        TContext
    >
> {}

method refresh

refresh: (params: TParams) => void;

Gets called when the overlayComponentParams grid option is updated

interface IOverlayComp

interface IOverlayComp<
    TData = any,
    TContext = any,
    TParams extends Readonly<IOverlayParams<TData, TContext>> = IOverlayParams<
        TData,
        TContext
    >
> extends IComponent<TParams>,
        IOverlay<TData, TContext, TParams> {}

interface IProvidedFilter

interface IProvidedFilter extends IFilter {}

Interface contract for the public aspects of the ProvidedFilter implementation(s).

property filterType

readonly filterType: 'text' | 'number' | 'bigint' | 'date' | 'set' | 'multi';

The type of filter. Matches the filterType property in the filter model

method applyModel

applyModel: (source?: 'api' | 'ui' | 'rowDataUpdated') => boolean;

Applies the model shown in the UI (so that getModel() will now return what was in the UI when applyModel() was called).
Parameter source
The source of the method call. Default 'api'.

method getModelFromUi

getModelFromUi: () => any;

Returns the filter model from the UI. If changes have been made to the UI but not yet applied, this model will reflect those changes.

interface IProvidedFilterParams

interface IProvidedFilterParams {}

Common parameters in colDef.filterParams used by all provided filters. Extended by the specific filter types.

property buttons

buttons?: FilterAction[];

Specifies the buttons to be shown in the filter, in the order they should be displayed in. The options are:
- 'apply': If the Apply button is present, the filter is only applied after the user hits the Apply button. - 'clear': The Clear button will clear the (form) details of the filter without removing any active filters on the column. - 'reset': The Reset button will clear the details of the filter and any active filters on that column. - 'cancel': The Cancel button will discard any changes that have been made to the filter in the UI, restoring the applied model.

property closeOnApply

closeOnApply?: boolean;

If the Apply button is present, the filter popup will be closed immediately when the Apply or Reset button is clicked if this is set to true.
false

property debounceMs

debounceMs?: number;

Overrides the default debounce time in milliseconds for the filter. Defaults are: - TextFilter and NumberFilter: 500ms. (These filters have text field inputs, so a short delay before the input is formatted and the filtering applied is usually appropriate). - DateFilter and SetFilter: 0ms

property readOnly

readOnly?: boolean;

If set to true, disables controls in the filter to mutate its state. Normally this would be used in conjunction with the Filter API.
false

interface IProvidedStatusPanelParams

interface IProvidedStatusPanelParams {}

property valueFormatter

valueFormatter?: (params: IStatusPanelValueFormatterParams) => string;

interface IRichCellEditorParams

interface IRichCellEditorParams<TData = any, TValue = any, GValue = any> {}

property allowTyping

allowTyping?: boolean;

Set to true to be able to type values in the display area. false

property cellHeight

cellHeight?: number;

The row height, in pixels, of each value.

property cellRenderer

cellRenderer?: any;

The cell renderer to use to render each value. Cell renderers are useful for rendering rich HTML values, or when processing complex data.

property cellRendererParams

cellRendererParams?: any;

The custom parameters to be used by the cell render.

filterList?: boolean;

If true it will filter the list of values as you type (only relevant when allowTyping=true). false

property filterListAsync

filterListAsync?: boolean;

Set to true to enable asynchronous filtering of values via the values or valuesPage callback. (only relevant when allowTyping=true and filterList=true). false

property formatValue

formatValue?: (value: TValue | null | undefined) => string;

A callback function that allows you to change the displayed value for simple data.

property highlightMatch

highlightMatch?: boolean;

If true, each item on the list of values will highlight the part of the text that matches the input. Note: It only makes sense to use this option when filterList is true and searchType is **not** fuzzy. false

property multiSelect

multiSelect?: boolean;

If true this component will allow multiple items from the list of values to be selected.

property parseValue

parseValue?: (value: TValue[] | TValue | null | undefined) => GValue;

A callback function that allows you to convert the value of the Rich Select Editor to the data format of the Grid Column when they are different.

property searchDebounceDelay

searchDebounceDelay?: number;

The value in ms for the search algorithm debounce delay 300

property searchType

searchType?: 'match' | 'matchAny' | 'fuzzy';

The type of search algorithm that is used when searching for values. - match - Matches if the value starts with the text typed. - matchAny - Matches if the value contains the text typed. - fuzzy - Matches the closest value to text typed. Note: When a cellRenderer is specified, this option will not work. 'fuzzy'

property suppressDeselectAll

suppressDeselectAll?: boolean;

If true the option to remove all selected options will not be displayed. Note: This feature only works when multiSelect=true.

property suppressMultiSelectPillRenderer

suppressMultiSelectPillRenderer?: boolean;

When multiSelect=true the editor will automatically show the selected items as "pills". Set this property to true suppress this behaviour.

property valueListGap

valueListGap?: number;

The space in pixels between the value display and the list of items. 4

property valueListMaxHeight

valueListMaxHeight?: number | string;

The maximum height of the list of items. If the value is a number it will be treated as pixels, otherwise it should be a valid CSS size string. 'calc(var(--ag-row-height) * 6.5)'

property valueListMaxWidth

valueListMaxWidth?: number | string;

The maximum width of the list of items. If the value is a number it will be treated as pixels, otherwise it should be a valid CSS size string. Default: Width of the cell being edited.

property valuePlaceholder

valuePlaceholder?: string;

A string value to be used when no value has been selected.

property values

values?: TValue[] | RichCellEditorValuesCallback<TData, TValue>;

The list of values to be selected from. Required when valuesPage is not provided.

property valuesPage

valuesPage?: RichCellEditorValuesPageCallback<TData, TValue>;

Optional paged datasource for very large value lists. When provided, values are loaded incrementally and additional pages are requested as the user scrolls. If both values and valuesPage are set, valuesPage takes precedence.

property valuesPageInitialStartRow

valuesPageInitialStartRow?:
    | number
    | RichCellEditorValuesPageStartRowCallback<TValue>;

Initial page start row when using valuesPage. Can be a fixed number or a callback that derives the start row from the current editor value. Only applied for the initial, unfiltered load. Filtered searches always start from row 0. 0

property valuesPageLoadThreshold

valuesPageLoadThreshold?: number;

Number of rows from the end of the loaded list at which the next page is requested. 10

property valuesPageSize

valuesPageSize?: number;

Number of rows requested per page when using valuesPage. 100

interface IRichCellEditorRendererParams

interface IRichCellEditorRendererParams<TValue>
    extends ICellEditorRendererParams<TValue> {}

property cellRendererParams

cellRendererParams: any;

interface IRowDragItem

interface IRowDragItem extends DragItem {}

property defaultTextValue

defaultTextValue: string;

The default text that would be applied to this Drag Element

interface IRowModel

interface IRowModel {}

property hierarchical

readonly hierarchical: boolean;

True when grouping or tree data is active (i.e. there may be group nodes below root).

property rootNode

readonly rootNode: RowNode | null;

The root row. - in Client Side Row Model and Server Side Row Model, this is the top level node above all groups and rows. - in Infinite Row Model and Viewport Row Model, this is a dummy empty node with no children as these row models do not have a concept of hierarchy.

method ensureRowHeightsValid

ensureRowHeightsValid: (
    startPixel: number,
    endPixel: number,
    startLimitIndex: number,
    endLimitIndex: number
) => boolean;

Used by CSRM only - is makes sure there are now estimated row heights within the range.

method forEachDisplayedNode

forEachDisplayedNode: (callback: ForEachNodeCallback) => void;

Iterate through each each flattened node, appearing as the grid does when scrolled Used for spanning

method forEachNode

forEachNode: (
    callback: ForEachNodeCallback,
    includeFooterNodes?: boolean
) => void;

Iterate through each node. What this does depends on the model type. For clientSide, goes through all nodes. For serverSide, goes through what's loaded in memory.

method getNodesInRangeForSelection

getNodesInRangeForSelection: (first: RowNode, last: RowNode) => RowNode[] | null;

Returns all rows in range that should be selected. If there is a gap in range (non ClientSideRowModel) then then no rows should be returned

method getOverlayType

getOverlayType: () => OverlayType | null;

method getRow

getRow: (index: number) => RowNode | undefined;

Returns the rowNode at the given index.

method getRowBounds

getRowBounds: (index: number) => RowBounds | null;

Returns row top and bottom for a given row

method getRowCount

getRowCount: () => number;

Returns the number of rows

method getRowIndexAtPixel

getRowIndexAtPixel: (pixel: number) => number;

Returns the row index at the given pixel

method getRowNode

getRowNode: (id: string) => RowNode | undefined;

Returns the rowNode for given id.

method getTopLevelIndexFromDisplayedIndex

getTopLevelIndexFromDisplayedIndex: (displayedIndex: number) => number;

method getTopLevelRowCount

getTopLevelRowCount: () => number;

method getTopLevelRowDisplayedIndex

getTopLevelRowDisplayedIndex: (topLevelIndex: number) => number;

method getType

getType: () => RowModelType;

The base class returns the type. We use this instead of 'instanceof' as the client might provide their own implementation of the models in the future.

method isEmpty

isEmpty: () => boolean;

Returns true if this model has no rows, regardless of model filter. EG if rows present, but filtered out, this still returns false. If it returns true, then the grid shows the 'no rows' overlay - but we don't show that overlay if the rows are just filtered out.

method isLastRowIndexKnown

isLastRowIndexKnown: () => boolean;

It tells us if this row model knows about the last row that it can produce. This is used by the PaginationPanel, if last row is not found, then the 'last' button is disabled and the last page is not shown. This is always true for ClientSideRowModel. It toggles for InfiniteRowModel.

method isRowPresent

isRowPresent: (rowNode: RowNode) => boolean;

Returns true if the provided rowNode is in the list of rows to render

method isRowsToRender

isRowsToRender: () => boolean;

Returns true if no rows (either no rows at all, or the rows are filtered out). This is what the grid uses to know if there are rows to render or not.

method onRowHeightChanged

onRowHeightChanged: () => void;

Tells the grid to reposition the rows after their heights have changed.

method resetRowHeights

resetRowHeights: () => void;

Tells the grid to recalculate the row heights.

method start

start: () => void;

Gets called after grid is initialised. What happens depends on row model. Client Side will take rowData from gridOptions, the other row models will start calling their datasources.

interface IRowNode

interface IRowNode<TData = any> extends BaseRowNode<TData>, GroupRowNode<TData> {}

property primaryRow

readonly primaryRow: IRowNode<TData>;

The primary (canonical) row node, resolving footer and pinned sibling relationships.
- If this is a **footer** row, returns its parent group row. - If this is a **manually pinned** row, returns the source row in the main viewport. - If both (pinned footer), follows both links to the primary group row. - Otherwise, returns this.

method addEventListener

addEventListener: <T extends RowNodeEventType>(
    eventType: T,
    userListener: AgRowNodeEventListener<T>
) => void;

Add an event listener.

method depthFirstSearch

depthFirstSearch: (callback: (rowNode: IRowNode<TData>) => void) => void;

Perform a depth-first search of this node and its children.

method getAggregatedChildren

getAggregatedChildren: (
    colKey: ColKey<TData> | null | undefined,
    recursive?: boolean
) => IRowNode<TData>[];

Returns children that contribute to the aggregation of this group RowNode.
- For leaf groups (groups containing data rows): returns the data rows. With pivot columns, only rows matching the pivot keys are included. - For non-leaf groups (groups containing other groups): returns the child groups. - For leaf (non-group) RowNodes: returns an empty array.
When recursive is true, traverses the full group hierarchy and returns all descendant leaf (data) rows instead of the immediate children. This creates a new array on each call. Use with care on large datasets as it visits every descendant node.
**Note:** Only supported with the Client-Side Row Model.
Parameter colKey
The column key. Pass the pivot column to filter by pivot keys, or null to get all children.
Parameter recursive
When true, returns all descendant leaf rows instead of only the immediate children. Defaults to false.
Returns
An array of child IRowNode instances contributing to this group's aggregation. When recursive is false (the default), the returned array must not be modified.

method getDataValue

getDataValue: {
    <TValue = any>(
        colKey: ColKey<TValue>,
        from: 'value' | 'data-raw' | 'edit' | 'batch'
    ): TValue | null | undefined;
    <TValue = any>(colKey: ColKey<TValue, any>, from?: 'data'):
        | TValue
        | IAggFuncResult<TValue>;
    <TValue = any>(colKey: ColKey<TValue, any>, from?: DataValueFrom):
        | TValue
        | IAggFuncResult<TValue>;
};

Returns the data value from the rowNode for the specified column.
By default, returns committed data ignoring any pending edits. For group rows, returns aggregated values or the group key. For formula cells in 'data' / 'value' modes, returns the **computed result**; in 'edit' / 'batch' / 'data-raw' modes, returns the **raw formula string** (so the edit pipeline can round-trip it).
To get the **displayed** value (with formatting and value formatter applied), use api.getCellValue() instead.
In **Pivot Mode**, pivot columns on leaf rows resolve to their underlying value column.
The from parameter controls value resolution:
- 'data' (default) — Returns the aggregated value for group rows, otherwise committed data. May return an IAggFuncResult<TValue> wrapper for aggregation columns; use 'value' to unwrap. Formulas are resolved to their computed value. - 'edit' — Returns the active editor's value if editing, or the pending batch value if not editing, then falls back to aggregation and committed data. **Formulas are NOT resolved** — returns the raw formula string to mirror the edit-pipeline buffer. - 'batch' — Returns the pending batch value if batching, then falls back to aggregation and committed data. **Formulas are NOT resolved** — returns the raw formula string to mirror the edit-pipeline buffer. - 'value' — Same as 'data' but unwraps IAggFuncResult (e.g. from avg or count) to its scalar value. Formulas are resolved to their computed value. - 'data-raw' — Always returns committed data, skipping aggregation results (rowNode.aggData) and formula resolution. For group rows this is typically undefined since group rows do not hold leaf data.
Parameter colKey
The column to read (field name, colId, or Column object)
Parameter from
Controls value resolution. Defaults to 'data'.
Returns
The value, or undefined if the column is not found. When from is omitted or 'data', aggregation columns may return an IAggFuncResult<TValue> wrapper object instead of a plain TValue. Pass from: 'value' to always receive a scalar TValue.

method getRoute

getRoute: () => string[] | undefined;

Returns the route of the row node. If the Row Node does not have a key (i.e it's a leaf row inside a row group) returns undefined

method isExpandable

isExpandable: () => boolean;

Returns: - true if the node can be expanded, i.e it is a group or master row. - false if the node cannot be expanded.

method isFullWidthCell

isFullWidthCell: () => boolean;

Deprecated
v32.2.0 Check node.detail then user provided callback isFullWidthRow instead.
Returns: - true if the node is a full width cell. - false if the node is not a full width cell.

method isHovered

isHovered: () => boolean;

Returns: - true if the node is currently hovered. - false if the node is not hovered.

method isRowPinned

isRowPinned: () => boolean;

Returns: - true if node is either pinned to the top or bottom. - false if the node isn't pinned.

method isSelected

isSelected: () => boolean | undefined;

Returns: - true if node is selected. - false if the node isn't selected. - undefined if it's partially selected (a group where not all descendants are selected, and groupSelects is 'descendants' or 'filteredDescendants').

method removeEventListener

removeEventListener: <T extends RowNodeEventType>(
    eventType: T,
    userListener: AgRowNodeEventListener<T>
) => void;

Remove event listener.

method resetQuickFilterAggregateText

resetQuickFilterAggregateText: () => void;

The first time quickFilter runs, the grid creates a one-off string representation of the row. This string is then used for the quick filter instead of hitting each column separately. When you edit, using grid editing, this string gets cleared down. However, if you edit without using grid editing, you need to clear this string down for the row to be updated with the new values. Otherwise, new values would not work with the quickFilter.

method setData

setData: (data: TData) => void;

Replaces the data on the rowNode. When this method is called, the grid refreshes the entire rendered row if it is displayed.

method setDataValue

setDataValue: (
    colKey: string | Column,
    newValue: any,
    eventSource?: string
) => boolean;

Sets the value on the rowNode for the specified column and refreshes the rendered cell.
In **Read Only** mode, this fires onCellEditRequest instead of writing directly.
In **Pivot Mode**, pivot columns on leaf rows resolve to their underlying value column.
The eventSource parameter controls how the value is written:
- (default) — Closes the active editor, writes to the pending batch if batching, otherwise writes to committed data. - 'edit' — Writes directly into the active editor if present (via refresh() or recreation); falls back to pending batch or committed data. - 'batch' — Leaves the active editor open, writes to the pending batch if batching, otherwise writes to committed data. - 'data' — Leaves the active editor open, skips the pending batch, always writes to committed data.
With 'edit', the active editor receives the new value via refresh() if implemented; otherwise the editor is recreated with focus preserved.
Parameter colKey
The column to update (field name, colId, or Column object)
Parameter newValue
The new value to set
Parameter eventSource
Controls how the value is written
Returns
true if the value changed, false otherwise

method setExpanded

setExpanded: (
    expanded: boolean,
    sourceEvent?: MouseEvent | KeyboardEvent,
    forceSync?: boolean
) => void;

Set the expanded state of this rowNode.
Parameter expanded
true to expand, false to collapse.
Parameter sourceEvent
Optional event that gets passed to the rowGroupOpened event.
Parameter forceSync
By default rows are expanded asynchronously for best performance. Set to true if you need to interact with the expanded row immediately after this function.

method setRowHeight

setRowHeight: (
    rowHeight: number | undefined | null,
    estimated?: boolean
) => void;

Sets the row height. Call if you want to change the height initially assigned to the row. After calling, you must call api.onRowHeightChanged() so the grid knows it needs to work out the placement of the rows.
Parameter rowHeight
new height of the row
Parameter estimated
is this an estimated height. Default: false

method setSelected

setSelected: (
    newValue: boolean,
    clearSelection?: boolean,
    source?: SelectionEventSourceType
) => void;

Select (or deselect) the node.
Parameter newValue
true for selection, false for deselection.
Parameter clearSelection
If selecting, then passing true selects the node exclusively (i.e. NOT do multi select). If doing deselection, clearSelection has no impact. Default: false
Parameter source
Source property that appears in the selectionChanged event. Default: 'api'

method updateData

updateData: (data: TData) => void;

Updates the data on the rowNode. When this method is called, the grid refreshes the entire rendered row if it is displayed.

interface IRowNumbersRowResizeFeature

interface IRowNumbersRowResizeFeature {}

method destroy

destroy: () => void;

method refreshRowResizer

refreshRowResizer: () => void;

interface IsApplyServerSideTransactionParams

interface IsApplyServerSideTransactionParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property groupLevelInfo

groupLevelInfo: any;

Store info, if any, as passed via the success() callback when loading data.

property parentNode

parentNode: IRowNode;

The parent RowNode, if transaction is applied to a group.

property transaction

transaction: ServerSideTransaction;

The transaction getting applied.

interface IScalarFilterParams

interface IScalarFilterParams extends ISimpleFilterParams {}

Common parameters in colDef.filterParams used by all scalar filters. Extended by the specific filter types.

property includeBlanksInEquals

includeBlanksInEquals?: boolean;

If true, blank (null or undefined) values will pass the 'equals' filter option.

property includeBlanksInGreaterThan

includeBlanksInGreaterThan?: boolean;

If true, blank (null or undefined) values will pass the 'greaterThan' and 'greaterThanOrEqual' filter options.

property includeBlanksInLessThan

includeBlanksInLessThan?: boolean;

If true, blank (null or undefined) values will pass the 'lessThan' and 'lessThanOrEqual' filter options.

property includeBlanksInNotEqual

includeBlanksInNotEqual?: boolean;

If true, blank (null or undefined) values will pass the 'notEqual' filter option.

property includeBlanksInRange

includeBlanksInRange?: boolean;

If true, blank (null or undefined) values will pass the 'inRange' filter option.

property inRangeInclusive

inRangeInclusive?: boolean;

If true, the 'inRange' filter option will include values equal to the start and end of the range.

interface ISelectableFilterService

interface ISelectableFilterService extends IEventEmitter<'selectedFilterChanged'> {}

method clearActive

clearActive: (colId: string) => void;

method getDefs

getDefs: (
    column: AgColumn,
    filterDef: IFilterDef
) =>
    | { filterDefs: SelectableFilterDef[]; activeFilterDef: SelectableFilterDef }
    | undefined;

method getFilterDef

getFilterDef: (column: AgColumn, filterDef: IFilterDef) => IFilterDef;

method getFilterValueGetter

getFilterValueGetter: (colId: string) => string | ValueGetterFunc | undefined;

method getState

getState: () => { [colId: string]: number };

method isSelectable

isSelectable: (filterDef: IFilterDef) => boolean;

method setActive

setActive: (
    colId: string,
    filterDefs: SelectableFilterDef[],
    activeFilterDef: SelectableFilterDef
) => void;

method setState

setState: (state: { [colId: string]: number }) => void;

interface ISelectCellEditorParams

interface ISelectCellEditorParams<TValue = any> {}

property valueListGap

valueListGap?: number;

The space in pixels between the value display and the list of items. 4

property valueListMaxHeight

valueListMaxHeight?: number | string;

The maximum height of the list of items. If the value is a number it will be treated as pixels, otherwise it should be a valid CSS size string. Default: Height of Popup Parent.

property valueListMaxWidth

valueListMaxWidth?: number | string;

The maximum width of the list of items. If the value is a number it will be treated as pixels, otherwise it should be a valid CSS size string. Default: Width of the cell being edited.

property values

values: TValue[];

List of values to display

interface IServerSideDatasource

interface IServerSideDatasource<TData = any> {}

method destroy

destroy: () => void;

Optional method, if your datasource has state it needs to clean up.

method getRows

getRows: (params: IServerSideGetRowsParams<TData>) => void;

Grid calls getRows when it requires more rows as specified in the params. Params object contains callbacks for responding to the request.

interface IServerSideGetRowsParams

interface IServerSideGetRowsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property needsGrandTotal

needsGrandTotal: boolean;

A hint indicating the grid does not yet have grand total data cached. When true, the server should include grand total data in the response via grandTotalData or as a row in rowData whose getRowId returns 'rowGroupFooter_ROOT_NODE_ID'.
This is only a hint — the server may always provide updated grand total data regardless of this flag, and the grid will accept it. Providing grand total data when this is false will update the existing grand total row.

property parentNode

parentNode: IRowNode<TData>;

The parent row node. The RootNode (level -1) if request is top level. This is NOT part fo the request as it cannot be serialised to JSON (a rowNode has methods).

property request

request: IServerSideGetRowsRequest;

Details for the request. A simple object that can be converted to JSON.

method fail

fail: () => void;

Fail callback, tell the grid the call failed so it can adjust it's state.

method success

success: (params: LoadSuccessParams<TData>) => void;

Success callback, pass the rows back to the grid that were requested.

interface IServerSideGetRowsRequest

interface IServerSideGetRowsRequest {}

property endRow

endRow: number | undefined;

Index after the last row required row or undefined for all rows.

property filterModel

filterModel: FilterModel | AdvancedFilterModel | null;

If filtering, what the filter model is. If Advanced Filter is enabled, will be of type AdvancedFilterModel | null. If Advanced Filter is disabled, will be of type FilterModel.

property groupKeys

groupKeys: string[];

What groups the user is viewing.

property pivotCols

pivotCols: ColumnVO[];

Columns that have pivot on them.

property pivotMode

pivotMode: boolean;

Defines if pivot mode is on or off.

property rowGroupCols

rowGroupCols: ColumnVO[];

Columns that are currently row grouped.

property sortModel

sortModel: SortModelItem[];

If sorting, what the sort model is.

property startRow

startRow: number | undefined;

First row requested or undefined for all rows.

property valueCols

valueCols: ColumnVO[];

Columns that have aggregations on them.

interface IServerSideGroupSelectionState

interface IServerSideGroupSelectionState extends ServerSideRowGroupSelectionState {}

property toggledNodes

toggledNodes?: IServerSideGroupSelectionState[];

interface IServerSideRowModel

interface IServerSideRowModel<TData = any> extends IRowModel {}

method applyRowData

applyRowData: (
    rowDataParams: LoadSuccessParams<TData>,
    startRow: number,
    route: string[]
) => void;

method forEachNodeAfterFilterAndSort

forEachNodeAfterFilterAndSort: (
    callback: (node: IRowNode<TData>, index: number) => void,
    includeFooterNodes?: boolean
) => void;

method getBlockStates

getBlockStates: () => void;

method getStoreState

getStoreState: () => ServerSideGroupLevelState[];

method onRowHeightChangedDebounced

onRowHeightChangedDebounced: () => void;

Deprecated
v33.1.0 - use gridApi.onRowHeightChanged() instead

method refreshStore

refreshStore: (params?: RefreshServerSideParams) => void;

method resetRootStore

resetRootStore: () => void;

method retryLoads

retryLoads: () => void;

method setDatasource

setDatasource: (datasource: IServerSideDatasource<TData>) => void;

method setRowCount

setRowCount: (rowCount: number, isLastRowIndexKnown?: boolean) => void;

interface IServerSideSelectionState

interface IServerSideSelectionState extends ServerSideRowSelectionState {}

interface IServerSideStore

interface IServerSideStore extends Bean {}

method getFirstNode

getFirstNode: () => IRowNode | null;

Returns the first child of the group (index 0), if the node is not loaded, returns null.

method getStoreBounds

getStoreBounds: () => { topPx: number; heightPx: number };

interface IServerSideTransactionManager

interface IServerSideTransactionManager<TData = any> {}

method applyTransaction

applyTransaction: (
    transaction: ServerSideTransaction<TData>
) => ServerSideTransactionResult<TData> | undefined;

method applyTransactionAsync

applyTransactionAsync: (
    transaction: ServerSideTransaction<TData>,
    callback?: (res: ServerSideTransactionResult<TData>) => void
) => void;

method flushAsyncTransactions

flushAsyncTransactions: () => void;

interface ISetFilter

interface ISetFilter<V = string> extends IProvidedFilter {}

Deprecated
v34 Use SetFilterUi for the filter UI component, and SetFilterHandler for the filter handler.

property filterType

readonly filterType: 'set';

method getFilterKeys

getFilterKeys: () => SetFilterModelValue;

Returns the full list of unique keys used by the Set Filter.

method getFilterValues

getFilterValues: () => (V | null)[];

Returns the full list of unique values used by the Set Filter.

method getMiniFilter

getMiniFilter: () => string | null;

Returns the current mini-filter text.

method getModel

getModel: () => SetFilterModel | null;

Returns a model representing the current state of the filter, or null if the filter is not active.

method getModelFromUi

getModelFromUi: () => SetFilterModel | null;

Returns the current UI state (potentially un-applied).

method refreshFilterValues

refreshFilterValues: () => void;

Refreshes the values shown in the filter from the original source. For example, if a callback was provided, the callback will be executed again and the filter will refresh using the values returned.

method resetFilterValues

resetFilterValues: () => void;

Resets the Set Filter to use values from the grid, rather than any values that have been provided directly.

method setFilterValues

setFilterValues: (values: (V | null)[]) => void;

Sets the values used in the Set Filter on the fly.

method setMiniFilter

setMiniFilter: (newMiniFilter: string | null) => void;

Sets the text in the Mini Filter at the top of the filter (the 'quick search' in the popup).

method setModel

setModel: (model: SetFilterModel | null) => AgPromise<void>;

Sets the state of the filter using the supplied model. Providing null as the model will de-activate the filter.
**Note:** if you are [providing values asynchronously](/filter-set-filter-list/#asynchronous-values) to the Set Filter, you need to wait for these changes to be applied before performing any further actions by waiting on the returned grid promise, e.g. filter.setModel({ values: ['a', 'b'] }).then(function() { gridApi.onFilterChanged(); });

interface ISetFilterCellRendererParams

interface ISetFilterCellRendererParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef?: ColDef;

The cell's column definition.

property column

column?: Column;

The cell's column.

property setTooltip

setTooltip: (value: string, shouldDisplayTooltip?: () => boolean) => void;

Sets a tooltip to the main element of this component.
Parameter value
The value to be displayed by the tooltip
Parameter shouldDisplayTooltip
A function returning a boolean that allows the tooltip to be displayed conditionally. This option does not work when enableBrowserTooltips={true}.

property value

value: any;

property valueFormatted

valueFormatted: string | null | undefined;

interface ISetFilterParams

interface ISetFilterParams<TData = any, V = string> extends IProvidedFilterParams {}

Parameters used in colDef.filterParams to configure a Set Filter (agSetColumnFilter).
Parameter TData
type of data row
Parameter V
type of value in the Set Filter

property applyMiniFilterWhileTyping

applyMiniFilterWhileTyping?: boolean;

Set to true to apply the Set Filter immediately when the user is typing in the Mini Filter.
false

property caseSensitive

caseSensitive?: boolean;

If true, enables case-sensitivity in the SetFilter Mini-Filter and Filter List. false

property cellHeight

cellHeight?: number;

The height of values in the Filter List in pixels.

property cellRenderer

cellRenderer?: any;

Similar to the Cell Renderer for the grid. Setting it separately here allows for the value to be rendered differently in the filter.

property comparator

comparator?: (a: V | null, b: V | null) => number;

Comparator for sorting. If not provided, the Column Definition comparator is used. If Column Definition comparator is also not provided, the default (grid provided) comparator is used.

property defaultToNothingSelected

defaultToNothingSelected?: boolean;

By default, when the Set Filter is opened all values are shown selected. Set this to true to instead show all values as de-selected by default.
This does not work when excelMode is enabled.

property excelMode

excelMode?: 'mac' | 'windows';

Changes the behaviour of the Set Filter to match that of Excel's AutoFilter.

property keyCreator

keyCreator?: (params: KeyCreatorParams<TData>) => string;

Function to return a string key for a value. This is required when the filter values are complex objects, or when treeList = true and the column is a group column with Tree Data or Grouping enabled. If not provided, the Column Definition Key Creator is used.

property refreshValuesOnOpen

refreshValuesOnOpen?: boolean;

Refresh the values every time the Set filter is opened.

property showTooltips

showTooltips?: boolean;

If true, hovering over a value in the Set Filter will show a tooltip containing the full, untruncated value.
false

property suppressClearModelOnRefreshValues

suppressClearModelOnRefreshValues?: boolean;

By default, if using provided filter values and there is an active filter model, when the filter values are refreshed such that every value is in the filter model, the filter model will be cleared (reset to null).
To prevent this behaviour, set this property to true. This is useful if using SSRM and updating the filter values based on other column filters.

property suppressMiniFilter

suppressMiniFilter?: boolean;

Set to true to hide the Mini Filter.
false

property suppressSelectAll

suppressSelectAll?: boolean;

Set to true to remove the Select All checkbox. false

property suppressSorting

suppressSorting?: boolean;

If true, the Set Filter values will not be sorted. Use this if you are providing your own values and don't want them sorted as you are providing in the order you want.
false

property textFormatter

textFormatter?: (from: string) => string;

If specified, this formats the text before applying the Mini Filter compare logic, useful for instance to substitute accented characters.

property treeList

treeList?: boolean;

If true, the Set Filter List will be displayed in a tree format. If enabled, one of the following must be true:
- A treeListPathGetter is provided to get the tree path for the column values. - The column values are of type Date, in which case the tree will be year -> month -> day. - Tree Data mode is enabled and the column is the group column. The Filter List will match the tree structure. A Key Creator must be supplied. - Grouping is enabled and the column is the group column. The Filter List will match the group structure. A Key Creator must be supplied.

property treeListFormatter

treeListFormatter?: (
    pathKey: string | null,
    level: number,
    parentPathKeys: (string | null)[]
) => string;

Requires treeList = true. If specified, this formats the tree values before they are displayed in the Filter List.
Parameter pathKey
The key for the current node in the tree.
Parameter level
The level of the current node in the tree (starting at 0).
Parameter parentPathKeys
The keys of the parent nodes up until the current node (exclusive). This will be an empty array if the node is at the root level.

property treeListPathGetter

treeListPathGetter?: (value: V | null) => string[] | null;

Requires treeList = true. If provided, this gets the tree path to display in the Set Filter List based on the column values. Each row must map to a leaf value in the tree.

property valueFormatter

valueFormatter?: (params: ValueFormatterParams) => string;

If specified, this formats the value before it is displayed in the Filter List. If a Key Creator is provided (see keyCreator), this must also be provided.

property values

values?: SetFilterValues<TData, V>;

The values to display in the Filter List. If this is not set, the filter will take its values from what is loaded in the table.

interface ISetFilterTreeListTooltipParams

interface ISetFilterTreeListTooltipParams extends ITooltipParams {}

Tooltip params used with the Set Filter Tree List.

property level

level: number;

Level of the tree (starting at 0).

interface IsExternalFilterPresentParams

interface IsExternalFilterPresentParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

interface IsFullWidthRowParams

interface IsFullWidthRowParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property rowNode

rowNode: IRowNode<TData>;

interface IsGroupOpenByDefaultParams

interface IsGroupOpenByDefaultParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property field

field: string;

Same as rowNode.field - the field we are grouping on, e.g. 'country'

property key

key: string;

Same as rowNode.key, the value of this group, e.g. 'Ireland'

property level

level: number;

Same as rowNode.level - what level the group is at, e.g. 0 for top level, 1 for second etc

property rowGroupColumn

rowGroupColumn: Column;

The Column for which this row is grouping.

property rowNode

rowNode: IRowNode<TData>;

The row node being considered.

interface ISimpleFilter

interface ISimpleFilter extends IProvidedFilter, IFloatingFilterParent {}

Interface contract for the public aspects of the SimpleFilter implementation(s).

property filterType

readonly filterType: 'text' | 'number' | 'bigint' | 'date';

interface ISimpleFilterModel

interface ISimpleFilterModel extends ProvidedFilterModel {}

property type

type?: ISimpleFilterModelType | null;

One of the filter options, e.g. 'equals'

interface ISimpleFilterParams

interface ISimpleFilterParams extends IProvidedFilterParams {}

Common parameters in colDef.filterParams used by all simple filters. Extended by the specific filter types.

property defaultJoinOperator

defaultJoinOperator?: JoinOperator;

By default, the two conditions are combined using AND. You can change this default by setting this property. Options: AND, OR

property defaultOption

defaultOption?: string;

The default filter option to be selected.

filterOptions?: (IFilterOptionDef | ISimpleFilterModelType)[];

Array of filter options to present to the user.

property filterPlaceholder

filterPlaceholder?: FilterPlaceholderFunction | string;

Placeholder text for the filter textbox.

property maxNumConditions

maxNumConditions?: number;

Maximum number of conditions allowed in the filter.
2

property numAlwaysVisibleConditions

numAlwaysVisibleConditions?: number;

By default only one condition is shown, and additional conditions are made visible when the previous conditions are entered (up to maxNumConditions). To have more conditions shown by default, set this to the number required. Conditions will be disabled until the previous conditions have been entered. Note that this cannot be greater than maxNumConditions - anything larger will be ignored.
1

interface ISizeAllColumnsToContentParams

interface ISizeAllColumnsToContentParams extends DefaultWidthLimits {}

property colIds

colIds?: string[];

If not provided will auto-size all columns. Otherwise will size the specified columns.

property columnLimits

columnLimits?: SizeColumnsToContentColumnLimits[];

Provide to limit specific column widths when sizing.

property scaleUpToFitGridWidth

scaleUpToFitGridWidth?: boolean;

Proportionally scale up columns after sizing to fill any empty space remaining in the grid.

property skipHeader

skipHeader?: boolean;

If true, the header won't be included when calculating the column widths.

interface ISizeColumnsToContentParams

interface ISizeColumnsToContentParams extends ISizeAllColumnsToContentParams {}

property colIds

colIds?: string[];

If not provided will auto-size all columns. Otherwise will size the specified columns.

interface ISizeColumnsToFitParams

interface ISizeColumnsToFitParams extends DefaultWidthLimits {}

property columnLimits

columnLimits?: IColumnLimit[];

Provides a minimum and/or maximum width to specific columns

interface ISparklineCellRendererParams

interface ISparklineCellRendererParams<TData = any, TContext = any>
    extends ICellRendererParams<TData, TContext> {}

property createSparkline

createSparkline?: (
    options: AgSparklineOptions
) => AgChartInstance<AgSparklineOptions>;

property sparklineOptions

sparklineOptions?: AgSparklineOptions;

interface IsRowValidDropPositionParams

interface IsRowValidDropPositionParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property allowed

allowed: boolean;

True if the drop is allowed, false otherwise

property draggingEvent

draggingEvent: DraggingEvent<TData, TContext> | null;

The dragging event that originated this drop operation

property moved

moved: boolean;

True if the current row dragged is not the same as the target row

property newParent

newParent: IRowNode<TData> | null;

The new parent row the rows will have after dropped

property overIndex

overIndex: number;

The row index the mouse is dragging over or -1 if over no row.

property overNode

overNode: IRowNode<TData> | undefined;

The row node the mouse is dragging over or undefined if over no row. Might be different than target.

property pointerPos

pointerPos: RowDropTargetPosition;

The pointer position relative to the current over node

property position

position: RowDropTargetPosition;

The position of the rows relative to the target row

property rootNode

rootNode: IRowNode<TData>;

The root row node that contains all the rows

property rowDragManaged

rowDragManaged: boolean;

True if the grid is managing row dragging, false if using unmanaged row dragging

property rows

rows: IRowNode<TData>[];

The rows that are being dropped

property sameGrid

sameGrid: boolean;

True if this rows comes from the same grid, false if is coming from another grid

property source

source: IRowNode<TData>;

The source row node that was dragged, if any

property suppressMoveWhenRowDragging

suppressMoveWhenRowDragging: boolean;

True if the grid is suppressing move when row dragging, false otherwise

property target

target: IRowNode<TData> | null;

The target row node where the row is being dropped.

property withinGrid

withinGrid: boolean;

True if the drop zone is within this grid, false otherwise

property y

y: number;

The vertical pixel location the mouse is over, with 0 meaning the top of the first row. This can be compared to the rowNode.rowHeight and rowNode.rowTop to work out the mouse position relative to rows. The provided attributes overIndex and overNode means the y property is mostly redundant. The y property can be handy if you want more information such as 'how close is the mouse to the top or bottom of the row?'

interface IsRowValidDropPositionResult

interface IsRowValidDropPositionResult<TData = any> {}

property allowed

allowed?: boolean;

True if the drop is allowed, false otherwise

property changed

changed?: boolean;

True if relevant information about the drop target are changed and the drag ghost need to be updated

property highlight

highlight?: boolean;

True if the drop target can be highlighted, matching the position value. Can be set to true during unmanaged row dragging to show the drop position indicator.

property newParent

newParent?: IRowNode<TData> | null;

The new parent row the rows will have after dropped

property position

position?: RowDropTargetPosition;

The position of the rows relative to the target row. If "none" the drop is not allowed

property rows

rows?: IRowNode<TData>[] | null;

The rows that are being dropped, can be used to filter the rows. If empty, the operation is aborted.

property target

target?: IRowNode<TData> | null;

The target row node where the row is being dropped.

interface IsServerSideGroupOpenByDefaultParams

interface IsServerSideGroupOpenByDefaultParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property data

data: any;

property rowNode

rowNode: IRowNode;

interface IStatusPanel

interface IStatusPanel<TData = any, TContext = any> {}

method refresh

refresh: (params: IStatusPanelParams<TData, TContext>) => boolean;

Called when the statusBar grid option is updated. If this method returns true, the grid assumes that the status panel has updated with the latest params, and takes no further action. If this method returns false, or is not implemented, the grid will destroy and recreate the status panel.

interface IStatusPanelComp

interface IStatusPanelComp<TData = any, TContext = any>
    extends IStatusPanel<TData, TContext>,
        IComponent<IStatusPanelParams<TData, TContext>> {}

interface IStatusPanelParams

interface IStatusPanelParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property key

key: string;

interface IStatusPanelValueFormatterParams

interface IStatusPanelValueFormatterParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property bigintValue

bigintValue?: bigint;

property key

key: string;

property totalRows

totalRows: number;

property value

value: number | null;

interface ITextCellEditorParams

interface ITextCellEditorParams<TData = any, TValue = any, TContext = any>
    extends ICellEditorParams<TData, TValue, TContext> {}

property maxLength

maxLength?: number;

Max number of characters to allow. 524288

property useFormatter

useFormatter: boolean;

If true, the editor will use the provided colDef.valueFormatter to format the value displayed in the editor. Used when the cell value needs formatting prior to editing, such as when using reference data and you want to display text rather than code.

interface ITextFilterParams

interface ITextFilterParams extends ISimpleFilterParams {}

Parameters used in colDef.filterParams to configure a Text Filter (agTextColumnFilter).

property caseSensitive

caseSensitive?: boolean;

By default, text filtering is case-insensitive. Set this to true to make text filtering case-sensitive. false

property textFormatter

textFormatter?: (from: string) => string | null;

Formats the text before applying the filter compare logic. Useful if you want to substitute accented characters, for example.

property textMatcher

textMatcher?: TextMatcher;

Used to override how to filter based on the user input. Returns true if the value passes the filter, otherwise false.

property trimInput

trimInput?: boolean;

If true, the input that the user enters will be trimmed when the filter is applied, so any leading or trailing whitespace will be removed. If only whitespace is entered, it will be left as-is. If you enable trimInput, it is best to also increase the debounceMs to give users more time to enter text. false

interface ITextFloatingFilterParams

interface ITextFloatingFilterParams extends ITextInputFloatingFilterParams {}

interface IToolbarItem

interface IToolbarItem<TData = any, TContext = any> {}

Interface that custom toolbar item components may implement to receive lifecycle callbacks from the grid. Implement refresh to update in-place when the toolbar option changes, avoiding a full destroy/recreate cycle.

method refresh

refresh: (params: IToolbarItemParams<TData, TContext>) => boolean;

Called when the toolbar grid option updates. Return true if the component updates itself with the new params. Return false (or omit) to have the grid destroy and recreate the component.

interface IToolbarItemComp

interface IToolbarItemComp<TData = any, TContext = any>
    extends IToolbarItem<TData, TContext>,
        IComponent<IToolbarItemParams<TData, TContext>> {}

Full interface for toolbar item components: combines IToolbarItem (optional refresh callback) with the standard AG Grid component lifecycle (IComponent). Custom toolbar components that are class-based should implement this interface.

interface IToolbarItemParams

interface IToolbarItemParams<TData = any, TContext = any, TParams = any>
    extends AgGridCommon<TData, TContext> {}

Params delivered to a toolbar item component. Mirrors the runtime shape produced by the grid: a flat object containing the item-definition fields the grid forwards, merged with AgGridCommon. The toolbarItem reference itself is intentionally not forwarded — the component already knows what it is.

property action

action?: (params: ToolbarItemActionParams<TData, TContext>) => void;

Action callback, when using the action-button shorthand.

property alignment

alignment?: 'left' | 'right';

Explicit alignment, when set on the item definition.

property icon

icon?: IconName;

Icon name, when set on the item definition.

property key

key: string;

Identifier for the item. Mirrors the key set on the item definition, or an auto-generated key when none was provided. Used internally; only items with an explicit key on the definition are reachable via api.getToolbarItemInstance(key).

property label

label?: string;

Label, when set on the item definition (action-button shorthand or agMenuToolbarItem).

property toolbarItemParams

toolbarItemParams?: TParams;

Custom params forwarded from the item definition's toolbarItemParams.

property tooltip

tooltip?: string;

Tooltip / aria-label, when set on the item definition.

interface IToolPanel

interface IToolPanel<TData = any, TContext = any, TState = any> {}

method getState

getState: () => TState;

If saving and restoring state, this should return the current state

method refresh

refresh: (params: IToolPanelParams<TData, TContext, TState>) => boolean | void;

Called when api.refreshToolPanel() is called (with the current params). Also called when the sideBar grid option is updated (with the updated params). When sideBar is updated, if this method returns true, then the grid will take no further action. Otherwise, the tool panel will be destroyed and recreated.

interface IToolPanelColumnCompParams

interface IToolPanelColumnCompParams {}

property buttons

buttons?: ColumnToolPanelAction[];

Buttons to display at the bottom of the Columns Tool Panel. When 'apply' is included, changes are deferred until the apply button is clicked.

property contractColumnSelection

contractColumnSelection: boolean;

By default, column groups start expanded. Pass true to default to contracted groups

property suppressColumnExpandAll

suppressColumnExpandAll: boolean;

Suppress Expand / Collapse all widget

property suppressColumnFilter

suppressColumnFilter: boolean;

Suppress Column Filter section

property suppressColumnMove

suppressColumnMove: boolean;

Suppress Column Move

property suppressColumnSelectAll

suppressColumnSelectAll: boolean;

Suppress Select / Un-select all widget

property suppressPivotMode

suppressPivotMode: boolean;

Suppress Pivot Mode selection

property suppressPivots

suppressPivots: boolean;

Suppress Column Labels (Pivot) section

property suppressRowGroups

suppressRowGroups: boolean;

Suppress Row Groups section

property suppressSyncLayoutWithGrid

suppressSyncLayoutWithGrid: boolean;

Suppress updating the layout of columns as they are rearranged in the grid

property suppressValues

suppressValues: boolean;

Suppress Values section

interface IToolPanelComp

interface IToolPanelComp<TData = any, TContext = any, TState = any>
    extends IToolPanel<TData, TContext, TState>,
        IComponent<IToolPanelParams<TData, TContext, TState>> {}

interface IToolPanelFiltersCompParams

interface IToolPanelFiltersCompParams {}

property suppressExpandAll

suppressExpandAll: boolean;

To suppress Expand / Collapse All

property suppressFilterSearch

suppressFilterSearch: boolean;

To suppress the Filter Search

property suppressSyncLayoutWithGrid

suppressSyncLayoutWithGrid: boolean;

Suppress updating the layout of columns as they are rearranged in the grid

interface IToolPanelNewFiltersCompParams

interface IToolPanelNewFiltersCompParams {}

property buttons

buttons?: FilterAction[];

Allows global buttons to be provided to the filter tool panel

interface IToolPanelParams

interface IToolPanelParams<TData = any, TContext = any, TState = any>
    extends BaseToolPanelParams<TData, TContext, TState> {}

property onStateUpdated

onStateUpdated: () => void;

If tool panel is saving and restoring state, this should be called after the state is updated

interface ITooltipComp

interface ITooltipComp extends IComponent<ITooltipParams> {}

interface ITooltipParams

interface ITooltipParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef?: ColDef<TData, TValue> | ColGroupDef<TData> | null;

Column / ColumnGroup definition.

property column

column?: Column<TValue> | ColumnGroup;

Column / ColumnGroup

property data

data?: TData;

Data for the row node in question.

property hideTooltipCallback

hideTooltipCallback?: () => void;

A callback function that hides the tooltip

property location

location: TooltipLocation;

What part of the application is showing the tooltip, e.g. 'cell', 'header', 'menuItem' etc

property node

node?: IRowNode<TData>;

The row node.

property rowIndex

rowIndex?: number;

The index of the row containing the cell rendering the tooltip.

property value

value?: TValue | null;

The value to be rendered by the tooltip.

property valueFormatted

valueFormatted?: string | null;

The formatted value to be rendered by the tooltip.

interface IViewportDatasource

interface IViewportDatasource {}

method destroy

destroy: () => void;

Gets called once when viewPort is no longer used. If you need to do any cleanup, do it here.

method init

init: (params: IViewportDatasourceParams) => void;

Gets called exactly once before viewPort is used. Passes methods to be used to tell viewPort of data loads / changes.

method setViewportRange

setViewportRange: (firstRow: number, lastRow: number) => void;

Tell the viewport what the scroll position of the grid is, so it knows what rows it has to get.

interface IViewportDatasourceParams

interface IViewportDatasourceParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property getRow

getRow: (rowIndex: number) => IRowNode;

Datasource calls this when it wants a row node - typically used when it wants to update the row node.

property setRowCount

setRowCount: (count: number, keepRenderedRows?: boolean) => void;

Datasource calls this method when the total row count changes. This in turn sets the height of the grids vertical scroll.

property setRowData

setRowData: (rowData: { [key: number]: any }) => void;

Datasource calls this when new data arrives. The grid then updates the provided rows. The rows are mapped [rowIndex]=>rowData].

interface JoinAdvancedFilterModel

interface JoinAdvancedFilterModel {}

Represents a series of filter conditions joined together.

property conditions

conditions: AdvancedFilterModel[];

The filter conditions that are joined by the type

property filterType

filterType: 'join';

property type

type: 'AND' | 'OR';

How the conditions are joined together

interface KeyCreatorParams

interface KeyCreatorParams<TData = any, TValue = any, TContext = any>
    extends BaseColDefParams<TData, TValue, TContext> {}

property value

value: TValue | null | undefined;

Value for the cell.

interface KeyShortcutChangedCellEndEvent

interface KeyShortcutChangedCellEndEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'keyShortcutChangedCellEnd', TData, TContext> {}

interface KeyShortcutChangedCellStartEvent

interface KeyShortcutChangedCellStartEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'keyShortcutChangedCellStart', TData, TContext> {}

interface LastChildChangedEvent

interface LastChildChangedEvent<TData = any>
    extends RowNodeEvent<'lastChildChanged', TData> {}

Deprecated
v33 Use the modelUpdated event instead and calculate whether the last child has changed.

interface LeftPinnedWidthChangedEvent

interface LeftPinnedWidthChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'leftPinnedWidthChanged', TData, TContext> {}

interface LoadingCellRendererSelectorResult

interface LoadingCellRendererSelectorResult {}

property component

component?: any;

Equivalent of setting loadingCellRenderer

property params

params?: any;

Equivalent of setting loadingCellRendererParams

interface LoadingOverlayUserParams

interface LoadingOverlayUserParams extends ProvidedOverlayUserParams {}

interface LoadSuccessParams

interface LoadSuccessParams<TData = any> {}

property grandTotalData

grandTotalData?: Partial<TData> | null;

Data for the grand total row. When provided, the grid will display or update the grand total footer row. Set to null to remove an existing grand total row. Takes priority over a grand total row found in rowData. Only the fields you want to display need to be provided; the grid assigns the row ID automatically.

property groupLevelInfo

groupLevelInfo?: any;

Any extra information for the grid to associate with this load.

property pivotResultFields

pivotResultFields?: string[];

The pivot fields in the response - if provided the grid will attempt to generate secondary columns.

property rowCount

rowCount?: number;

The last row, if known, to help Infinite Scroll.

property rowData

rowData: TData[];

Data retrieved from the server as requested by the grid.

interface LongTapEvent

interface LongTapEvent extends AgEvent<'longTap'> {}

property touchEvent

touchEvent: TouchEvent;

property touchStart

touchStart: Touch;

interface MasterChangedEvent

interface MasterChangedEvent<TData = any>
    extends RowNodeEvent<'masterChanged', TData> {}

interface MenuItemDef

interface MenuItemDef<TData = any, TContext = any>
    extends MenuItemLeafDef<TData, TContext> {}

property menuItem

menuItem?: any;

Provide a custom menu item component. See [Menu Item Component](https://www.ag-grid.com/javascript-data-grid/component-menu-item/#implementing-a-menu-item-component) for framework specific implementation details.

property menuItemParams

menuItemParams?: any;

Parameters to be passed to the custom menu item component specified in menuItem.

property subMenu

subMenu?: (MenuItemDef<TData, TContext> | string)[];

If this item is a sub menu, contains a list of menu item definitions

property subMenuRole

subMenuRole?: 'menu' | 'listbox' | 'tree' | 'grid' | 'dialog';

The aria role for the subMenu 'menu'

interface MenuItemLeafDef

interface MenuItemLeafDef<TData = any, TContext = any> {}

property action

action?: (params: IMenuActionParams<TData, TContext>) => void;

Function that gets executed when item is chosen.

property checked

checked?: boolean;

Set to true to provide a check beside the option.

property cssClasses

cssClasses?: string[];

CSS classes to apply to the menu item.

property disabled

disabled?: boolean;

Set to true to display the menu item as disabled.

property icon

icon?: Element | string;

The icon to display, either a DOM element or HTML string.

property name

name: string;

Name of the menu item.

property shortcut

shortcut?: string;

Shortcut text displayed inside menu item. Setting this doesn’t actually create a keyboard shortcut binding.

property suppressCloseOnSelect

suppressCloseOnSelect?: boolean;

If true, will keep the menu open when the item is selected. Note that if this item has a sub menu, it will always remain open regardless of this property.

property tooltip

tooltip?: string;

Tooltip text to be displayed for the menu item.

interface ModelUpdatedEvent

interface ModelUpdatedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'modelUpdated', TData, TContext> {}

property animate

animate: boolean | undefined;

If true, the grid will try and animate the rows to the new positions

property keepRenderedRows

keepRenderedRows: boolean | undefined;

If the grid has new data loaded, eg user called setRowData(), this will be false, otherwise it's the same data but sorted or filtered, in which case this is true, and rows can animate around (eg rowNode id 24 is the same row node as last time).

property keepUndoRedoStack

keepUndoRedoStack?: boolean;

true if all we did is changed row height, data still the same, no need to clear the undo/redo stacks

property newData

newData: boolean | undefined;

If true, then this update was a result of setRowData() getting called. This gets the grid to scroll to the top again.

property newPage

newPage: boolean;

True when pagination and a new page is navigated to.

property newPageSize

newPageSize?: boolean;

True when page size changes from the page size selector.

interface Module

interface Module {}

A Module contains all the code related to this feature to enable tree shaking when this module is not used.

property beans

beans?: SingletonBean[];

singleton beans which are created once on grid init

property css

css?: string[];

property dependsOn

dependsOn?: Module[];

property dynamicBeans

dynamicBeans?: Partial<Record<DynamicBeanName, ClassImp>>;

beans which can have many instances, and can be created/destroyed at any time

property enterprise

enterprise?: boolean;

property icons

icons?: Partial<Record<IconName, IconValue>>;

icon mappings *** IMPORTANT NOTE! *** If you change the icons, copy/paste the new content into the docs page custom-icons

property moduleName

moduleName: ModuleName;

property rowModels

rowModels?: RowModelType[];

property selectors

selectors?: ComponentSelector[];

selectors for grid components that can be defined in templates and created by AG stack

property userComponents

userComponents?: Partial<Record<UserComponentName, ComponentMeta>>;

components which can be overridden by the user (e.g. cell renderers). These are the default grid provided versions

property validate

validate?: () => ModuleValidationResult;

Validation run when registering the module
Returns
Whether the module is valid or not. If not, a message explaining why it is not valid

property version

version: string;

interface MouseEnterEvent

interface MouseEnterEvent<TData = any> extends RowNodeEvent<'mouseEnter', TData> {}

interface MouseLeaveEvent

interface MouseLeaveEvent<TData = any> extends RowNodeEvent<'mouseLeave', TData> {}

interface MouseShowContextMenuParams

interface MouseShowContextMenuParams {}

property mouseEvent

mouseEvent: MouseEvent;

interface MultiFilterHandler

interface MultiFilterHandler {}

method getHandler

getHandler: <TFilterHandler>(index: number) => TFilterHandler | undefined;

interface MultiRowSelectionOptions

interface MultiRowSelectionOptions<TData = any, TValue = any, TContext = any>
    extends CommonRowSelectionOptions<TData, TValue, TContext> {}

Determines selection behaviour when multiple rows can be selected at once.

property ctrlASelectsRows

ctrlASelectsRows?: boolean;

If true, using CTRL+A will select all rows when [Cell Selection](./cell-selection) is enabled false

property groupSelects

groupSelects?: GroupSelectionMode;

Determine group selection behaviour 'self'

property headerCheckbox

headerCheckbox?: boolean;

If true a 'select all' checkbox will be put into the header. true

property mode

mode: 'multiRow';

property selectAll

selectAll?: SelectAllMode;

Determines how "select all" behaviour works. This controls header checkbox selection. 'all'

interface NavigateToNextCellParams

interface NavigateToNextCellParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property event

event: KeyboardEvent | null;

property key

key: string;

The keycode for the arrow key pressed: left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown'

property nextCellPosition

nextCellPosition: CellPosition | null;

The cell the grid would normally pick as the next cell for navigation

property previousCellPosition

previousCellPosition: CellPosition;

The cell that currently has focus

interface NavigateToNextHeaderParams

interface NavigateToNextHeaderParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property event

event: KeyboardEvent;

property headerRowCount

headerRowCount: number;

The number of header rows present in the grid

property key

key: string;

The key for the arrow key pressed, left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown'

property nextHeaderPosition

nextHeaderPosition: HeaderPosition | null;

The header the grid would normally pick as the next header for this navigation

property previousHeaderPosition

previousHeaderPosition: HeaderPosition | null;

The header that currently has focus

interface NewColumnsLoadedEvent

interface NewColumnsLoadedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'newColumnsLoaded', TData, TContext> {}

property source

source: ColumnEventType;

interface NewFiltersToolPanelFilterState

interface NewFiltersToolPanelFilterState {}

property colId

colId: string;

property expanded

expanded?: boolean;

interface NewFiltersToolPanelState

interface NewFiltersToolPanelState {}

property filters

filters?: NewFiltersToolPanelFilterState[];

Ordered list of filters and their expansion state

interface NewValueParams

interface NewValueParams<TData = any, TValue = any, TContext = any>
    extends ChangedValueParams<
        TData,
        TValue | null | undefined,
        TValue | null | undefined,
        TContext
    > {}

property newRawValue

newRawValue: TValue | null | undefined;

The raw value from the edit, before any value getter is applied.

property source

source: string | undefined;

The source of the value change, e.g. 'edit', 'paste', 'undo', 'redo', 'data'.

interface NoMatchingRowsOverlayUserParams

interface NoMatchingRowsOverlayUserParams extends ProvidedOverlayUserParams {}

interface NoRowsOverlayUserParams

interface NoRowsOverlayUserParams extends ProvidedOverlayUserParams {}

interface Note

interface Note<TMetadata = any> {}

property author

author?: string;

Optional author of the note.

property createdAt

createdAt?: string;

Optional creation timestamp.

property metadata

metadata?: TMetadata;

Optional application metadata to be associated with this note.

property readOnly

readOnly?: boolean;

Set to true to make this note readonly.

property text

text: string;

Text content of the note.

property updatedAt

updatedAt?: string;

Optional updated timestamp.

interface NoteParams

interface NoteParams {}

property column

column: ColKey;

Column that the note is for.

property location

location?: 'cell';

If using fullWidthRows the location is cell for normal cells.

property rowNode

rowNode: IRowNode;

Row that the note is for.

interface NotesDataSource

interface NotesDataSource<TMetadata = any> extends BaseNotesDataSource {}

Control where notes are stored/retrieved from. An implementation can store note state separately from the row data, or persist it remotely.

method getNote

getNote: (params: NotesDataSourceGetNoteParams) => Note<TMetadata> | undefined;

Return the note for the given cell.

method setNote

setNote: (params: NotesDataSourceSetNoteParams<TMetadata>) => void;

Set or clear the note for the given cell.

interface NotesDataSourceFullWidthRowNoteParams

interface NotesDataSourceFullWidthRowNoteParams {}

property location

location: 'fullWidthRow';

Location of the note.

property pinned

pinned?: 'left' | 'right';

If embedFullWidthRows=true identifies the pinned section the note has been applied to.

property rowNode

rowNode: IRowNode;

Row for the note.

interface NotesDataSourceNoteParams

interface NotesDataSourceNoteParams {}

property column

column: Column;

Column for the note.

property location

location?: 'cell';

Location of the note.

property rowNode

rowNode: IRowNode;

Row for the note.

interface NotesDataSourceParams

interface NotesDataSourceParams extends AgGridCommon<any, any> {}

interface NotesDataSourceSetNoteParams

interface NotesDataSourceSetNoteParams<TMetadata = any>
    extends NotesDataSourceNoteParams {}

property note

note: Note<TMetadata> | undefined;

Note to be saved.

interface NumberAdvancedFilterModel

interface NumberAdvancedFilterModel {}

Represents a single filter condition for a number column

property colId

colId: string;

The ID of the column being filtered.

property filter

filter?: number;

The value to filter on.

property filterType

filterType: 'number';

property type

type: ScalarAdvancedFilterModelType;

The filter option that is being applied.

interface NumberDataTypeDefinition

interface NumberDataTypeDefinition<TData = any, TContext = any>
    extends BaseDataTypeDefinition<'number', TData, number, TContext> {}

Represents a 'number' data type (type number).

interface NumberFilterModel

interface NumberFilterModel extends ISimpleFilterModel {}

property filter

filter?: number | null;

The number value(s) associated with the filter. Custom filters can have no values (hence both are optional). Range filter has two values (from and to), where filter acts as a from value.

property filterTo

filterTo?: number | null;

Range filter to value.

property filterType

filterType?: 'number';

Filter type is always 'number'

interface ObjectAdvancedFilterModel

interface ObjectAdvancedFilterModel {}

Represents a single filter condition for an object column

property colId

colId: string;

The ID of the column being filtered.

property filter

filter?: string;

The value to filter on. This is the same value as displayed in the input.

property filterType

filterType: 'object';

property type

type: TextAdvancedFilterModelType;

The filter option that is being applied.

interface ObjectDataTypeDefinition

interface ObjectDataTypeDefinition<TData, TValue, TContext>
    extends BaseDataTypeDefinition<'object', TData, TValue, TContext> {}

Represents an 'object' data type (any type).

interface OpenChartToolPanelParams

interface OpenChartToolPanelParams {}

property chartId

chartId: string;

The id of the created chart.

property panel

panel?: ChartToolPanelName;

Name of the Chart Tool Panel. The default 'Settings' Tool Panel will be used if not specified.

interface OverlayComponentUserParams

interface OverlayComponentUserParams {}

Parameters available to configure the provided overlays.

property exporting

exporting?: ExportingOverlayUserParams;

Parameters to customise the provided exporting overlay.

property loading

loading?: LoadingOverlayUserParams;

Parameters to customise the provided loading overlay.

property noMatchingRows

noMatchingRows?: NoMatchingRowsOverlayUserParams;

Parameters to customise the provided no-matching-rows overlay.

property noRows

noRows?: NoRowsOverlayUserParams;

Parameters to customise the provided no-rows overlay.

interface OverlaySelectorResult

interface OverlaySelectorResult {}

property component

component?: any;

Equivalent of setting gridOptions.overlayComponent.

property params

params?: any;

Equivalent of setting gridOptions.overlayComponentParams

interface PaginationChangedEvent

interface PaginationChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'paginationChanged', TData, TContext> {}

property animate

animate?: boolean;

True if rows were animated to new position

property keepRenderedRows

keepRenderedRows?: boolean;

True if rows were kept (otherwise complete redraw)

property newData

newData?: boolean;

True if data was new (i.e user set new data)

property newPage

newPage: boolean;

True if user went to a new page

property newPageSize

newPageSize?: boolean;

True if user changed the page size

interface PaginationNumberFormatterParams

interface PaginationNumberFormatterParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property value

value: number;

interface PaginationPixelOffsetChangedEvent

interface PaginationPixelOffsetChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'paginationPixelOffsetChanged', TData, TContext> {}

interface PaginationState

interface PaginationState {}

property page

page?: number;

Current page

property pageSize

pageSize?: number;

Current page size. Only use when the pageSizeSelector dropdown is visible

interface Params

interface Params {}

property modules

modules?: Module[];

Modules to be registered directly with this grid instance.

interface PasteEndEvent

interface PasteEndEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'pasteEnd', TData, TContext> {}

property source

source: string;

interface PasteStartEvent

interface PasteStartEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'pasteStart', TData, TContext> {}

property source

source: string;

interface PinnedHeightChangedEvent

interface PinnedHeightChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'pinnedHeightChanged', TData, TContext> {}

interface PinnedRowDataChangedEvent

interface PinnedRowDataChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'pinnedRowDataChanged', TData, TContext> {}

interface PinnedRowsChangedEvent

interface PinnedRowsChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'pinnedRowsChanged', TData, TContext> {}

interface PivotMaxColumnsExceededEvent

interface PivotMaxColumnsExceededEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'pivotMaxColumnsExceeded', TData, TContext> {}

property message

message: string;

interface PivotState

interface PivotState {}

property pivotColIds

pivotColIds: string[];

property pivotMode

pivotMode: boolean;

interface PopupEventParams

interface PopupEventParams {}

property forceHide

forceHide?: boolean;

property keyboardEvent

keyboardEvent?: KeyboardEvent;

property mouseEvent

mouseEvent?: MouseEvent;

property originalMouseEvent

originalMouseEvent?: MouseEvent | Touch | null;

property touchEvent

touchEvent?: TouchEvent;

interface PopupPositionParams

interface PopupPositionParams {}

property column

column?: AgColumn | null;

property rowNode

rowNode?: IRowNode | null;

interface PostProcessPopupParams

interface PostProcessPopupParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column?: Column | null;

If popup is for a column, this gives the Column

property ePopup

ePopup: HTMLElement;

The popup we are showing

property eventSource

eventSource?: HTMLElement | null;

If the popup is as a result of a button click (eg menu button), this is the component that the user clicked

property mouseEvent

mouseEvent?: MouseEvent | Touch | null;

If the popup is as a result of a click or touch, this is the event - eg user showing context menu

property rowNode

rowNode?: IRowNode<TData> | null;

If popup is for a row, this gives the RowNode

property type

type: string;

The different types are: 'contextMenu', 'columnMenu', 'aggFuncSelect', 'popupCellEditor', 'chart', 'advancedFilterBuilder', 'colorPicker', 'columnChooser', 'subMenu'

interface PostSortRowsParams

interface PostSortRowsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property nodes

nodes: IRowNode<TData>[];

interface PresetDateRangeFilterModel

interface PresetDateRangeFilterModel extends DateFilterModel {}

Date filter model used when a built-in preset range (for example, Today or Last 7 Days) is selected. dateFrom and dateTo are always undefined and the type carries the preset key.

property dateFrom

dateFrom: undefined;

Preset range does not provide an explicit from date.

property dateTo

dateTo: undefined;

Preset range does not provide an explicit to date.

property type

type: ISimpleFilterModelPresetType;

Preset range type (for example, today or last7Days).

interface ProcessCellForExportParams

interface ProcessCellForExportParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property accumulatedRowIndex

accumulatedRowIndex?: number;

The zero-based row index in the exported output, including any prepended content rows. Only populated for file export flows ('excel', 'csv'); omitted for clipboard flows.

property column

column: Column;

The column for the cell.

property formatValue

formatValue: (value: any) => string;

Utility function to format a value using the column's colDef.valueFormatter

property node

node?: IRowNode<TData> | null;

The row node for the cell. May be null or undefined for clipboard flows when no row is associated.

property parseValue

parseValue: (value: string) => any;

Utility function to parse a value using the column's colDef.valueParser

property type

type: string;

The operation that triggered the callback

property value

value: any;

The raw cell value before any formatting or processing.

interface ProcessDataFromClipboardParams

interface ProcessDataFromClipboardParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property data

data: string[][];

2D array of all cells from the clipboard

interface ProcessGroupHeaderForExportParams

interface ProcessGroupHeaderForExportParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property columnGroup

columnGroup: ColumnGroup;

The grid column group

interface ProcessHeaderForExportParams

interface ProcessHeaderForExportParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column: Column;

The grid column

interface ProcessNoteForExportParams

interface ProcessNoteForExportParams<TData = any, TContext = any>
    extends ProcessCellForExportParams<TData, TContext> {}

property excelNote

excelNote?: ExcelNote;

The Excel note/comment value derived from gridNote when automatic note export is enabled.

property gridNote

gridNote?: Note;

The grid note resolved for the current cell, when the Notes feature is available.

interface ProcessRowGroupForExportParams

interface ProcessRowGroupForExportParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column?: Column;

The grid column

property node

node: IRowNode<TData>;

Row node.

interface ProcessRowParams

interface ProcessRowParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property addRenderedRowListener

addRenderedRowListener: (
    eventType: RenderedRowEvent,
    listener: (...args: any[]) => any
) => void;

property ePinnedLeftRow

ePinnedLeftRow?: HTMLElement;

property ePinnedRightRow

ePinnedRightRow?: HTMLElement;

property eRow

eRow: HTMLElement;

property node

node: IRowNode<TData>;

property rowIndex

rowIndex: number;

interface ProcessUnpinnedColumnsParams

interface ProcessUnpinnedColumnsParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property columns

columns: Column[];

property viewportWidth

viewportWidth: number;

interface ProvidedColumnGroup

interface ProvidedColumnGroup
    extends IProvidedColumn,
        IEventEmitter<AgProvidedColumnGroupEvent> {}

property isColumn

isColumn: false;

isColumn is always false. Used to distinguish between columns and column groups.

method getChildren

getChildren: () => (Column | ProvidedColumnGroup)[];

Returns the children of this group.

method getColGroupDef

getColGroupDef: () => ColGroupDef | null;

Returns the column group definition for this column. The column group definition will be the result of merging the application provided column group definition with any provided defaults (e.g. defaultColGroupDef grid option.

method getGroupId

getGroupId: () => string;

Returns the group column id.

method getLeafColumns

getLeafColumns: () => Column[];

Returns the leaf columns of this group.

method getLevel

getLevel: () => number;

Returns the level of this group.

method isExpandable

isExpandable: () => boolean;

Returns true if this column group is expandable.

method isExpanded

isExpanded: () => boolean;

Returns true if this column group is expanded.

method isPadding

isPadding: () => boolean;

Returns true if this column group is a padding group that is used to correctly align column groups / children.

interface ProvidedFilterModel

interface ProvidedFilterModel {}

property filterType

filterType?: string;

interface RangeDeleteEndEvent

interface RangeDeleteEndEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rangeDeleteEnd', TData, TContext> {}

property source

source: 'deleteKey';

interface RangeDeleteStartEvent

interface RangeDeleteStartEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rangeDeleteStart', TData, TContext> {}

property source

source: 'deleteKey';

interface RangeHandleOptions

interface RangeHandleOptions {}

Configuration options for the range handle

property mode

mode: 'range';

interface RangeParam

interface RangeParam extends Iterable<unknown> {}

property colEnd

colEnd: AgColumn;

property colStart

colStart: AgColumn;

property kind

kind: 'range';

property rowEnd

rowEnd: number;

property rowStart

rowStart: number;

interface RangeSelectionCellState

interface RangeSelectionCellState extends CellSelectionCellState {}

Deprecated
v32.2 Use CellSelectionCellState instead.

interface RangeSelectionChangedEvent

interface RangeSelectionChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rangeSelectionChanged', TData, TContext> {}

property finished

finished: boolean;

True for the last change event, otherwise false

property id

id?: string;

property started

started: boolean;

True for the first change event, otherwise false

interface RangeSelectionState

interface RangeSelectionState {}

Deprecated
v32.2 Use CellSelectionState instead.

property cellRanges

cellRanges: RangeSelectionCellState[];

interface RecalculateRowBoundsEvent

interface RecalculateRowBoundsEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'recalculateRowBounds', TData, TContext> {}

interface RedoEndedEvent

interface RedoEndedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'redoEnded', TData, TContext> {}

property operationPerformed

operationPerformed: boolean;

true if any redo operations were performed.

property source

source: 'api' | 'ui';

Source of the event. api if via API method. ui if via keyboard shortcut.

interface RedoStartedEvent

interface RedoStartedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'redoStarted', TData, TContext> {}

property source

source: 'api' | 'ui';

Source of the event. api if via API method. ui if via keyboard shortcut.

interface RedrawRowsParams

interface RedrawRowsParams<TData = any> {}

property rowNodes

rowNodes?: IRowNode<TData>[];

Row nodes to redraw

interface RefreshCellsParams

interface RefreshCellsParams<TData = any> extends RefreshParams<TData> {}

interface RefreshModelParams

interface RefreshModelParams<TData = any> {}

property afterColumnsChanged

afterColumnsChanged?: boolean;

true if this update is due to columns changing, ie no rows were changed

property animate

animate?: boolean;

if true, rows that are kept are animated to the new position

property changedPath

changedPath?: ChangedPath;

The changedPath, if any

property changedProps

changedProps?: Set<keyof GridOptions<TData>>;

The set of changed grid options, if any

property changedRowNodes

changedRowNodes?: ChangedRowNodes<TData>;

A data structure that holds the affected row nodes, if this was an update and not a full reload.

property keepRenderedRows

keepRenderedRows?: boolean;

if NOT new data, then this flag tells grid to check if rows already exist for the nodes (matching by node id) and reuses the row if it does.

property keepUndoRedoStack

keepUndoRedoStack?: boolean;

true if all we did is changed row height, data still the same, no need to clear the undo/redo stacks

property newData

newData?: boolean;

Indicates a completely new rowData array is loaded. Is true if user called setRowData() (or a new page in pagination). the grid scrolls back to the top when this is true.

property rowDataUpdated

rowDataUpdated?: boolean;

true if the row data changed, due to a setRowData, immutable row data or a transaction, or an update of the row data.

property step

step: ClientSideRowModelStage;

how much of the pipeline to execute

interface RefreshNotesParams

interface RefreshNotesParams {}

property columns

columns?: (string | Column)[];

Only refresh the provided columns. If undefined refresh all columns.

property rowNodes

rowNodes?: IRowNode[];

Only refresh the provided rowNodes. If undefined refresh all rows.

interface RefreshServerSideParams

interface RefreshServerSideParams {}

property purge

purge?: boolean;

If true, then all rows at the level getting refreshed are immediately destroyed and 'loading' rows will appear. If false, then all rows at the level getting refreshed are kept until rows are loaded (no 'loading' rows appear).

property route

route?: string[];

List of group keys, pointing to the level to refresh. For example, to purge two levels down under 'Canada'and then '2002', pass in the string array ['Canada','2002']. If no route is passed, or an empty array, then the top level is refreshed.

interface RichCellEditorParams

interface RichCellEditorParams<TData = any, TValue = any, TContext = any>
    extends IRichCellEditorParams<TData, TValue>,
        ICellEditorParamsShared<TData, TValue, TContext> {}

interface RichCellEditorValuesCallbackParams

interface RichCellEditorValuesCallbackParams<TData = any, TValue = any>
    extends RichCellEditorParams<TData, TValue> {}

property search

search?: string;

The current search string entered by the user. Is always defined when async filtering is enabled.

interface RichCellEditorValuesPageParams

interface RichCellEditorValuesPageParams<TData = any, TValue = any>
    extends RichCellEditorParams<TData, TValue> {}

property cursor

cursor?: string | null;

Opaque continuation token returned by the previous page.

property endRow

endRow: number;

The last row index requested (exclusive).

property search

search: string;

The current search string. Empty string means unfiltered values.

property startRow

startRow: number;

The first row index requested (inclusive).

interface RichCellEditorValuesPageResult

interface RichCellEditorValuesPageResult<TValue = any> {}

property cursor

cursor?: string | null;

Optional continuation token for the next page.

property lastRow

lastRow?: number;

Optional absolute row index where data ends.

property values

values: TValue[];

The page of values returned by the server.

interface RichSelectListRowSelectedEvent

interface RichSelectListRowSelectedEvent<TData = any, TContext = any>
    extends FieldValueEvent<'richSelectListRowSelected', TData, TContext> {}

property fromEnterKey

fromEnterKey: boolean;

interface RichSelectListRowSelectedEvent

interface RichSelectListRowSelectedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'richSelectListRowSelected', TData, TContext> {}

interface RichSelectParams

interface RichSelectParams<TValue = any>
    extends AgPickerFieldParams<AgComponentSelectorType> {}

property allowNoResultsCopy

allowNoResultsCopy?: boolean;

property allowTyping

allowTyping?: boolean;

property cellRenderer

cellRenderer?: any;

property cellRendererParams

cellRendererParams?: any;

property cellRowHeight

cellRowHeight?: number;

filterList?: boolean;

property highlightMatch

highlightMatch?: boolean;

property initialInputValue

initialInputValue?: string;

property multiSelect

multiSelect?: boolean;

property onSearch

onSearch?: (search?: string) => void;

property placeholder

placeholder?: string;

property searchDebounceDelay

searchDebounceDelay?: number;

property searchStringCreator

searchStringCreator?: (values: TValue[]) => string[];

property searchType

searchType?: 'match' | 'matchAny' | 'fuzzy';

property suppressDeselectAll

suppressDeselectAll?: boolean;

property suppressMultiSelectPillRenderer

suppressMultiSelectPillRenderer?: boolean;

property value

value?: TValue[] | TValue | null;

property valueFormatter

valueFormatter?: (value: TValue[] | TValue | null | undefined) => string;

property valueList

valueList?: TValue[];

interface RightPinnedWidthChangedEvent

interface RightPinnedWidthChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rightPinnedWidthChanged', TData, TContext> {}

interface RowBounds

interface RowBounds {}

property rowHeight

rowHeight: number;

property rowIndex

rowIndex?: number;

property rowTop

rowTop: number;

interface RowClassParams

interface RowClassParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property data

data: TData | undefined;

The data associated with this row from rowData. Data is undefined for row groups.

property node

node: IRowNode<TData>;

The RowNode associated with this row

property rowIndex

rowIndex: number;

The index of the row

interface RowClassRules

interface RowClassRules<TData = any, TContext = any> {}

index signature

[cssClassName: string]:
    | ((params: RowClassParams<TData, TContext>) => boolean)
    | string;

interface RowClickedEvent

interface RowClickedEvent<TData = any, TContext = any>
    extends RowMouseEvent<'rowClicked', TData, TContext> {}

interface RowContainerHeightChanged

interface RowContainerHeightChanged<TData = any, TContext = any>
    extends AgGlobalEvent<'rowContainerHeightChanged', TData, TContext> {}

interface RowContainerHeightChangedEvent

interface RowContainerHeightChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rowContainerHeightChanged', TData, TContext> {}

interface RowCountReadyEvent

interface RowCountReadyEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rowCountReady', TData, TContext> {}

interface RowDataTransaction

interface RowDataTransaction<TData = any> {}

property add

add?: TData[] | null;

Rows to add

property addIndex

addIndex?: number | null;

Index to add rows

property remove

remove?: TData[] | null;

Rows to remove

property update

update?: TData[] | null;

Rows to update

interface RowDataUpdatedEvent

interface RowDataUpdatedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rowDataUpdated', TData, TContext> {}

interface RowDataUpdateStartedEvent

interface RowDataUpdateStartedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rowDataUpdateStarted', TData, TContext> {}

property firstRowData

firstRowData: TData | null;

interface RowDoubleClickedEvent

interface RowDoubleClickedEvent<TData = any, TContext = any>
    extends RowMouseEvent<'rowDoubleClicked', TData, TContext> {}

interface RowDragCallbackParams

interface RowDragCallbackParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

interface RowDragCancelEvent

interface RowDragCancelEvent<TData = any, TContext = any>
    extends RowDragEvent<TData, TContext, 'rowDragCancel'> {}

interface RowDragEndEvent

interface RowDragEndEvent<TData = any, TContext = any>
    extends RowDragEvent<TData, TContext, 'rowDragEnd'> {}

interface RowDragEnterEvent

interface RowDragEnterEvent<TData = any, TContext = any>
    extends RowDragEvent<TData, TContext, 'rowDragEnter'> {}

interface RowDragEvent

interface RowDragEvent<
    TData = any,
    TContext = any,
    T extends RowDragEventType = RowDragEventType
> extends AgGlobalEvent<T, TData, TContext> {}

property event

event: MouseEvent;

The underlying mouse move event associated with the drag.

property eventPath

eventPath?: EventTarget[];

The eventPath persists the event.composedPath() result for access within AG Grid event handlers.

property node

node: IRowNode<TData>;

The row node getting dragged. Also the node that started the drag when multi-row dragging.

property nodes

nodes: IRowNode<TData>[];

The list of nodes being dragged.

property overIndex

overIndex: number;

The row index the mouse is dragging over or -1 if over no row.

property overNode

overNode?: IRowNode<TData>;

The row node the mouse is dragging over or undefined if over no row.

property rowsDrop

rowsDrop: RowsDropParams<TData, TContext> | null;

Details about the row dragging drop target.

property vDirection

vDirection: 'up' | 'down' | null;

Direction of the drag, either 'up', 'down' or null (if mouse is moving horizontally and not vertically).

property y

y: number;

The vertical pixel location the mouse is over, with 0 meaning the top of the first row. This can be compared to the rowNode.rowHeight and rowNode.rowTop to work out the mouse position relative to rows. The provided attributes overIndex and overNode means the y property is mostly redundant. The y property can be handy if you want more information such as 'how close is the mouse to the top or bottom of the row?'

interface RowDragLeaveEvent

interface RowDragLeaveEvent<TData = any, TContext = any>
    extends RowDragEvent<TData, TContext, 'rowDragLeave'> {}

interface RowDragMoveEvent

interface RowDragMoveEvent<TData = any, TContext = any>
    extends RowDragEvent<TData, TContext, 'rowDragMove'> {}

interface RowDropPositionIndicator

interface RowDropPositionIndicator<TData = any> {}

property dropIndicatorPosition

dropIndicatorPosition: DropIndicatorPosition;

property row

row: IRowNode<TData> | null;

interface RowDropZoneEvents

interface RowDropZoneEvents {}

property onDragCancel

onDragCancel?: (params: RowDragCancelEvent) => void;

property onDragEnter

onDragEnter?: (params: RowDragEnterEvent) => void;

Callback function that will be executed when the rowDrag enters the target.

property onDragging

onDragging?: (params: RowDragMoveEvent) => void;

Callback function that will be executed when the rowDrag is dragged inside the target. Note: this gets called multiple times.

property onDragLeave

onDragLeave?: (params: RowDragLeaveEvent) => void;

Callback function that will be executed when the rowDrag leaves the target

property onDragStop

onDragStop?: (params: RowDragEndEvent) => void;

Callback function that will be executed when the rowDrag drops rows within the target.

interface RowDropZoneParams

interface RowDropZoneParams extends RowDropZoneEvents {}

property getContainer

getContainer: () => HTMLElement;

A callback method that returns the DropZone HTMLElement.

interface RowEditingStartedEvent

interface RowEditingStartedEvent<TData = any, TContext = any>
    extends RowEvent<'rowEditingStarted', TData, TContext> {}

interface RowEditingStoppedEvent

interface RowEditingStoppedEvent<TData = any, TContext = any>
    extends RowEvent<'rowEditingStopped', TData, TContext> {}

interface RowEvent

interface RowEvent<T extends AgEventType, TData = any, TContext = any>
    extends BaseRowEvent<T, TData, TContext> {}

property data

data: TData | undefined;

The user provided data for the row. Data is undefined for row groups.

interface RowGroupBulkExpansionState

interface RowGroupBulkExpansionState {}

property expandAll

expandAll: boolean | undefined;

If true, all groups are expanded except those in invertedRowGroupIds. If false, all groups are collapsed except those in invertedRowGroupIds. If undefined, the grid is in its initial state (no groups expanded or collapsed).

property invertedRowGroupIds

invertedRowGroupIds: string[];

interface RowGroupExpansionState

interface RowGroupExpansionState {}

property collapsedRowGroupIds

collapsedRowGroupIds?: string[];

Collapsed Row Group Ids array is only used in SSRM when bulk expansion feature is not used. It contains row IDs that were explicitly collapsed.

property expandedRowGroupIds

expandedRowGroupIds: string[];

By default, all group nodes in a grid are collapsed. This array would contain row IDs that were explicitly expanded.

interface RowGroupOpenedEvent

interface RowGroupOpenedEvent<TData = any, TContext = any>
    extends RowEvent<'rowGroupOpened', TData, TContext> {}

property expanded

expanded: boolean;

True if the group is expanded.

interface RowGroupState

interface RowGroupState {}

property groupColIds

groupColIds: string[];

Grouped columns in order

interface RowHeightCallbackParams

interface RowHeightCallbackParams {}

property rowIndex

rowIndex: number;

interface RowHeightParams

interface RowHeightParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property data

data: TData | undefined;

The data associated with this row from rowData. Data is undefined for row groups.

property node

node: IRowNode<TData>;

The RowNode of the row in question.

interface RowHighlightChangedEvent

interface RowHighlightChangedEvent<TData = any>
    extends RowNodeEvent<'rowHighlightChanged', TData> {}

interface RowIndexChangedEvent

interface RowIndexChangedEvent<TData = any>
    extends RowNodeEvent<'rowIndexChanged', TData> {}

interface RowNodeDataChangedEvent

interface RowNodeDataChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'rowNodeDataChanged', TData, TContext> {}

property node

node: RowNode<TData>;

interface RowNodePinnedEvent

interface RowNodePinnedEvent<TData = any> extends RowNodeEvent<'rowPinned', TData> {}

interface RowNodeSelectedEvent

interface RowNodeSelectedEvent<TData = any>
    extends RowNodeEvent<'rowSelected', TData> {}

interface RowNodeTransaction

interface RowNodeTransaction<TData = any> {}

property add

add: IRowNode<TData>[];

Row nodes added

property remove

remove: IRowNode<TData>[];

Row nodes removed

property update

update: IRowNode<TData>[];

Row nodes updated

interface RowNumbersOptions

interface RowNumbersOptions
    extends Pick<
        ColDef,
        | 'contextMenuItems'
        | 'context'
        | 'onCellClicked'
        | 'onCellContextMenu'
        | 'onCellDoubleClicked'
        | 'headerTooltip'
        | 'headerStyle'
        | 'headerComponent'
        | 'headerComponentParams'
        | 'suppressHeaderKeyboardEvent'
        | 'suppressNavigable'
        | 'tooltipField'
        | 'tooltipValueGetter'
        | 'tooltipComponent'
        | 'tooltipComponentParams'
        | 'tooltipComponentSelector'
        | 'valueGetter'
        | 'valueFormatter'
        | 'maxWidth'
        | 'cellRenderer'
        | 'cellRendererSelector'
        | 'cellRendererParams'
    > {}

property enableRowResizer

enableRowResizer?: boolean;

Set to true to add a resizer to each Row Number cell that allows row resizing. false

property minWidth

minWidth?: number;

The minimum width for the row number column. 60

property resizable

resizable?: boolean;

Whether this column is resizable. false

property suppressCellSelectionIntegration

suppressCellSelectionIntegration?: boolean;

Set to true to prevent selecting all the currently visible cells in the row when clicking a Row Number. false

property width

width?: number;

The default width for the row number column. 60

interface RowPinningState

interface RowPinningState {}

property bottom

bottom: string[];

Row IDs of rows pinned to the bottom container

property top

top: string[];

Row IDs of rows pinned to the top container

interface RowPosition

interface RowPosition {}

property rowIndex

rowIndex: number;

A positive number from 0 to n, where n is the last row the grid is rendering or -1 if you want to navigate to the grid header

property rowPinned

rowPinned: RowPinnedType;

Either 'top', 'bottom' or null/undefined (for not pinned)

interface RowResizeEndedEvent

interface RowResizeEndedEvent<TData = any, TContext = any>
    extends RowResizeEvent<TData, TContext, 'rowResizeEnded'> {}

interface RowResizeStartedEvent

interface RowResizeStartedEvent<TData = any, TContext = any>
    extends RowResizeEvent<TData, TContext, 'rowResizeStarted'> {}

interface RowsDropParams

interface RowsDropParams<TData = any, TContext = any>
    extends IsRowValidDropPositionParams<TData, TContext> {}

interface RowSelectedEvent

interface RowSelectedEvent<TData = any, TContext = any>
    extends RowEvent<'rowSelected', TData, TContext> {}

property source

source: SelectionEventSourceType;

interface RowSpanParams

interface RowSpanParams<TData = any, TValue = any, TContext = any>
    extends BaseColDefOptionalDataParams<TData, TValue, TContext> {}

interface RowStyle

interface RowStyle {}

index signature

[cssProperty: string]: string | number;

interface RowValueChangedEvent

interface RowValueChangedEvent<TData = any, TContext = any>
    extends RowEvent<'rowValueChanged', TData, TContext> {}

interface ScrollbarWidthChangedEvent

interface ScrollbarWidthChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'scrollbarWidthChanged', TData, TContext> {}

interface ScrollOverflowChangedEvent

interface ScrollOverflowChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'scrollGapChanged', TData, TContext> {}

interface ScrollState

interface ScrollState {}

property left

left: number;

property top

top: number;

interface ScrollVisibilityChangedEvent

interface ScrollVisibilityChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'scrollVisibilityChanged', TData, TContext> {}

interface SelectableChangedEvent

interface SelectableChangedEvent<TData = any>
    extends RowNodeEvent<'selectableChanged', TData> {}

interface SelectableFilterDef

interface SelectableFilterDef {}

property filter

filter: any;

Filter to use for this column. - Set to true to use the default filter. - Set to the name of a provided filter: agNumberColumnFilter, agBigIntColumnFilter, agTextColumnFilter, agDateColumnFilter, agMultiColumnFilter, agSetColumnFilter. - Set to a ColumnFilter

property filterParams

filterParams?: any;

Params to be passed to the filter component specified in filter.

property filterValueGetter

filterValueGetter?: string | ValueGetterFunc;

Function or expression. Gets the value for filtering purposes. Allows for different values to be used for different filters instead of using colDef.filterValueGetter.

property name

name?: string;

Name that will be displayed in the filter card dropdown. Required for custom filters

interface SelectableFilterParams

interface SelectableFilterParams {}

property defaultFilterIndex

defaultFilterIndex?: number;

If providing filters, the index of the filter that should be active by default. 0

property defaultFilterParams

defaultFilterParams?: FilterWrapperParams;

Params which will be passed to all filters

property filters

filters?: SelectableFilterDef[];

List of possible filters which will show in the filter card. If not provided, will default to grid-provided filters

interface SelectionChangedEvent

interface SelectionChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'selectionChanged', TData, TContext> {}

property selectedNodes

selectedNodes: IRowNode<TData>[] | null;

The row nodes that are selected at the time the event is generated. When selecting all nodes in SSRM or when group selecting in SSRM, this will be null.

property serverSideState

serverSideState:
    | IServerSideSelectionState
    | IServerSideGroupSelectionState
    | null;

The SSRM selection state. This can be referred to when selectedNodes is null. This will be null when using a row model other than SSRM.

property source

source: SelectionEventSourceType;

The source that triggered the selection change event.

interface SendToClipboardParams

interface SendToClipboardParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property data

data: string;

interface SeriesChartType

interface SeriesChartType {}

property chartType

chartType: ChartType;

property colId

colId: string;

property secondaryAxis

secondaryAxis?: boolean;

interface ServerSideGroupLevelParams

interface ServerSideGroupLevelParams {}

property cacheBlockSize

cacheBlockSize?: number;

For Infinite Scroll only. Cache block size. If missing, defaults to grid options cacheBlockSize.

property maxBlocksInCache

maxBlocksInCache?: number;

For Infinite Scroll only. How many blocks to keep in cache. If missing, defaults to grid options maxBlocksInCache.

interface ServerSideGroupLevelState

interface ServerSideGroupLevelState {}

property cacheBlockSize

cacheBlockSize?: number;

Infinite Scroll only. The size (number of rows) of each infinite cache block.

property info

info?: any;

Any extra info provided to the level, when data was loaded.

property lastRowIndexKnown

lastRowIndexKnown?: boolean;

Infinite Scroll only. Whether the last row index is know.

property maxBlocksInCache

maxBlocksInCache?: number;

Infinite Scroll only. Max blocks allowed in the infinite cache.

property route

route: string[];

The route that identifies this level.

property rowCount

rowCount: number;

How many rows the level has. This includes 'loading rows'.

interface ServerSideRowGroupSelectionState

interface ServerSideRowGroupSelectionState {}

property nodeId

nodeId?: string;

property selectAllChildren

selectAllChildren?: boolean;

property toggledNodes

toggledNodes?: ServerSideRowGroupSelectionState[];

interface ServerSideRowSelectionState

interface ServerSideRowSelectionState {}

property selectAll

selectAll: boolean;

Whether the majority of rows are selected or not

property toggledNodes

toggledNodes: string[];

All rows that have the opposite selection state to selectAll

interface ServerSideStoreParams

interface ServerSideStoreParams extends ServerSideGroupLevelParams {}

Deprecated
use ServerSideGroupLevelParams instead

interface ServerSideTransaction

interface ServerSideTransaction<TData = any> {}

property add

add?: TData[];

Rows to add

property addIndex

addIndex?: number;

Index position to add at. If missing, rows will be added to the end.

property remove

remove?: TData[];

Rows to remove

property route

route?: string[];

The Row Store to apply the transaction to, ie what group level. eg ['Ireland','2002'] to update the child store found after expanding Ireland and 2002 groups. Passing in blank to empty applies the transaction to the top level.

property rowCount

rowCount?: number;

Optional new total row count. Use this when a transaction deletes rows that are not currently in cache.

property update

update?: TData[];

Rows to update

interface ServerSideTransactionResult

interface ServerSideTransactionResult<TData = any> {}

property add

add?: IRowNode<TData>[];

If rows were added, the newly created Row Nodes for those rows.

property remove

remove?: IRowNode<TData>[];

If rows were removed, the deleted Row Nodes.

property status

status: ServerSideTransactionResultStatus;

The status of applying the transaction.

property update

update?: IRowNode<TData>[];

If rows were updated, the updated Row Nodes.

interface SetFilterHandler

interface SetFilterHandler<TValue = string> {}

method getFilterKeys

getFilterKeys: () => SetFilterModelValue;

Returns the full list of unique keys used by the Set Filter.

method getFilterValues

getFilterValues: () => (TValue | null)[];

Returns the full list of unique values used by the Set Filter.

method refreshFilterValues

refreshFilterValues: () => void;

Refreshes the values shown in the filter from the original source. For example, if a callback was provided, the callback will be executed again and the filter will refresh using the values returned.

method resetFilterValues

resetFilterValues: () => void;

Resets the Set Filter to use values from the grid, rather than any values that have been provided directly.

method setFilterValues

setFilterValues: (values: (TValue | null)[]) => void;

Sets the values used in the Set Filter on the fly.

interface SetFilterModel

interface SetFilterModel extends ProvidedFilterModel {}

property filterType

filterType?: 'set';

property values

values: SetFilterModelValue;

interface SetFilterUi

interface SetFilterUi<TValue = string> {}

method getFilterHandler

getFilterHandler: () => SetFilterHandler<TValue>;

Returns the corresponding Set Filter Handler.

method getMiniFilter

getMiniFilter: () => string | null;

Returns the current mini-filter text.

method setMiniFilter

setMiniFilter: (newMiniFilter: string | null) => void;

Sets the text in the Mini Filter at the top of the filter (the 'quick search' in the popup).

interface SetFilterUiChangedEvent

interface SetFilterUiChangedEvent<TData = any, TContext = any>
    extends FilterUiChangedEvent<TData, TContext> {}

property miniFilterValue

miniFilterValue?: string | null;

interface SetFilterValuesFuncParams

interface SetFilterValuesFuncParams<TData = any, V = string>
    extends AgGridCommon<TData, any> {}

Parameter TData
type of data row
Parameter V
type of value in the Set Filter

property colDef

colDef: ColDef<TData>;

The column definition from which the set filter is invoked.

property column

column: Column;

Column from which the set filter is invoked.

property success

success: (values: (V | null)[]) => void;

The function to call with the values to load into the filter once they are ready.

interface SetFormulaParams

interface SetFormulaParams extends GetFormulaParams {}

property formula

formula: string | undefined;

property value

value?: unknown;

Optional computed value associated with the formula.

interface SetRowDropPositionIndicatorParams

interface SetRowDropPositionIndicatorParams<TData = any> {}

property dropIndicatorPosition

dropIndicatorPosition: DropIndicatorPosition | null | false;

property row

row: IRowNode<TData> | null | undefined;

interface SharedFilterUi

interface SharedFilterUi extends SharedFilter {}

method afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen. If a parent popup is closed and reopened (e.g. for filters), this method is called each time the component is shown. This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.

method afterGuiDetached

afterGuiDetached: () => void;

Optional: A hook to perform any necessary operation just after the GUI for this component has been removed from the screen. If a parent popup is opened and closed (e.g. for filters), this method is called each time the component is hidden. This is useful for any logic to reset the UI state back to the model before the component is reopened.

interface ShouldRowBeSkippedParams

interface ShouldRowBeSkippedParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property node

node: IRowNode<TData>;

Row node.

interface ShowContextMenuParams

interface ShowContextMenuParams {}

property column

column?: Column | null;

The column associated with the Context Menu

property rowNode

rowNode?: IRowNode | null;

The row node associated with the Context Menu

property source

source: 'api' | 'ui';

property value

value: any;

The value that will be passed to the Context Menu (useful with getContextMenuItems). If none is passed, and rowNode and column are provided, this will be the respective Cell value

interface SideBarDef

interface SideBarDef {}

property defaultToolPanel

defaultToolPanel?: string;

The panel (identified by ID) to open by default. If none specified, the side bar is initially displayed closed.

property hiddenByDefault

hiddenByDefault?: boolean;

To hide the side bar by default, set this to true. If left undefined the side bar will be shown.

property hideButtons

hideButtons?: boolean;

To hide the side bar buttons by default set this to true. If left undefined the buttons will be shown. This is useful if you want to show a tool panel without showing the buttons.

property position

position?: 'left' | 'right';

Sets the side bar position relative to the grid.

property toolPanels

toolPanels?: (ToolPanelDef | string)[];

A list of all the panels to place in the side bar. The panels will be displayed in the provided order from top to bottom.

interface SideBarState

interface SideBarState {}

property openToolPanel

openToolPanel: string | null;

Open tool panel, or null if closed

property position

position: 'left' | 'right';

property toolPanels

toolPanels: {
    [id: string]: any;
};

State for each tool panel

property visible

visible: boolean;

Is side bar visible

interface SideBarUpdatedEvent

interface SideBarUpdatedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'sideBarUpdated', TData, TContext> {}

interface SingleRowSelectionOptions

interface SingleRowSelectionOptions<TData = any, TValue = any, TContext = any>
    extends CommonRowSelectionOptions<TData, TValue, TContext> {}

Determines selection behaviour when only a single row can be selected at a time

property mode

mode: 'singleRow';

interface SizeColumnsToContentColumnLimits

interface SizeColumnsToContentColumnLimits extends WidthLimits {}

property colId

colId: string;

interface SizeColumnsToContentStrategy

interface SizeColumnsToContentStrategy extends ISizeAllColumnsToContentParams {}

Auto-size columns to fit their cell contents.
Not supported by the Viewport Row Model

property type

type: 'fitCellContents';

interface SizeColumnsToFitGridColumnLimits

interface SizeColumnsToFitGridColumnLimits extends WidthLimits {}

Limit a column width when auto-sizing to fit grid width.

property colId

colId: string;

interface SizeColumnsToFitGridStrategy

interface SizeColumnsToFitGridStrategy extends DefaultWidthLimits {}

Auto-size columns to fit the grid width.

property columnLimits

columnLimits?: SizeColumnsToFitGridColumnLimits[];

Provide to limit specific column widths when sizing.

property type

type: 'fitGridWidth';

interface SizeColumnsToFitProvidedWidthStrategy

interface SizeColumnsToFitProvidedWidthStrategy {}

Auto-size columns to fit a provided width.

property type

type: 'fitProvidedWidth';

property width

width: number;

interface SortChangedEvent

interface SortChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'sortChanged', TData, TContext> {}

property columns

columns?: Column[];

The list of columns impacted by the sort change.

property source

source: string;

Source of the sort change.

interface SortModelItem

interface SortModelItem {}

property colId

colId: string;

Column Id to apply the sort to.

property sort

sort: NonNullable<SortDirection>;

Sort direction

property type

type?: SortType;

Sort type

interface SortState

interface SortState {}

property sortModel

sortModel: SortModelItem[];

Sorted columns and directions in order

interface SpanRowsParams

interface SpanRowsParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef: ColDef<TData, TValue>;

ColDef provided for this column

property column

column: Column<TValue>;

Column for this callback

property nodeA

nodeA: IRowNode<TData> | null;

First row of the span, which if spanned represents the spanned cells

property nodeB

nodeB: IRowNode<TData> | null;

Next row of the span to test

property valueA

valueA: TValue | null | undefined;

First rows value

property valueB

valueB: TValue | null | undefined;

Next rows value

interface StartEditingCellParams

interface StartEditingCellParams {}

property colKey

colKey: string | Column;

The column key of the row to start editing

property key

key?: string;

The key to pass to the cell editor

property rowIndex

rowIndex: number;

The row index of the row to start editing

property rowPinned

rowPinned?: RowPinnedType;

Set to 'top' or 'bottom' to start editing a pinned row

interface StateUpdatedEvent

interface StateUpdatedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'stateUpdated', TData, TContext> {}

property sources

sources: (keyof GridState | 'gridInitializing' | 'api')[];

Which parts of the state triggered the update, or gridInitializing when the state has been created during grid initialization, or 'api' when the state has been set via api.setState

property state

state: GridState;

The updated state

interface StatusPanelDef

interface StatusPanelDef {}

property align

align?: string;

property key

key?: string;

property statusPanel

statusPanel?: any;

property statusPanelParams

statusPanelParams?: any;

interface StickyTopOffsetChangedEvent

interface StickyTopOffsetChangedEvent extends AgEvent<'stickyTopOffsetChanged'> {}

property offset

offset: number;

interface StickyTopOffsetChangedEvent

interface StickyTopOffsetChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'stickyTopOffsetChanged', TData, TContext> {}

interface StoreRefreshAfterParams

interface StoreRefreshAfterParams {}

property changedColumns

changedColumns: string[];

property secondaryColChanged

secondaryColChanged: boolean;

property valueColChanged

valueColChanged: boolean;

interface StoreRefreshedEvent

interface StoreRefreshedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'storeRefreshed', TData, TContext> {}

property route

route?: string[];

The route of the store which has finished refreshing, undefined if root level

interface StoreUpdatedEvent

interface StoreUpdatedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'storeUpdated', TData, TContext> {}

interface StylesChangedEvent

interface StylesChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'stylesChanged', TData, TContext> {}

property headerHeightChanged

headerHeightChanged?: boolean;

property listItemHeightChanged

listItemHeightChanged?: boolean;

property rowBorderWidthChanged

rowBorderWidthChanged?: boolean;

property rowHeightChanged

rowHeightChanged?: boolean;

property themeChanged

themeChanged?: boolean;

interface SuppressFieldDotNotationEvent

interface SuppressFieldDotNotationEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'suppressFieldDotNotation', TData, TContext> {}

interface SuppressHeaderKeyboardEventParams

interface SuppressHeaderKeyboardEventParams<
    TData = any,
    TValue = any,
    TContext = any
> extends AgGridCommon<TData, TContext> {}

property colDef

colDef: ColDef<TData, TValue> | ColGroupDef<TData> | null;

property column

column: Column<TValue> | ColumnGroup;

property event

event: KeyboardEvent;

The keyboard event the grid received

property headerRowIndex

headerRowIndex: number;

The index of the header row of the current focused header

interface SuppressKeyboardEventParams

interface SuppressKeyboardEventParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

property editing

editing: boolean;

Whether the cell is editing or not

property event

event: KeyboardEvent;

The keyboard event the grid received

interface SuppressMenuHideEvent

interface SuppressMenuHideEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'suppressMenuHide', TData, TContext> {}

interface SuppressMouseEventHandlingParams

interface SuppressMouseEventHandlingParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property column

column?: Column<TValue>;

Column that the event was on, or undefined for full width rows.

property event

event: MouseEvent;

Mouse event.

property node

node: IRowNode<TData>;

Row node that the event was on.

interface SuppressMovableColumnsEvent

interface SuppressMovableColumnsEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'suppressMovableColumns', TData, TContext> {}

interface SuppressNavigableCallbackParams

interface SuppressNavigableCallbackParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

interface SuppressNoteActionsCallbackParams

interface SuppressNoteActionsCallbackParams<
    TData = any,
    TValue = any,
    TContext = any
> extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

interface SuppressPasteCallbackParams

interface SuppressPasteCallbackParams<TData = any, TValue = any, TContext = any>
    extends ColumnFunctionCallbackParams<TData, TValue, TContext> {}

interface TabToNextCellParams

interface TabToNextCellParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property backwards

backwards: boolean;

True if the Shift key is also down

property editing

editing: boolean;

True if the current cell is editing (you may want to skip cells that are not editable, as the grid will enter the next cell in editing mode also if tabbing)

property nextCellPosition

nextCellPosition: CellPosition | null;

The cell the grid would normally pick as the next cell for navigation.

property previousCellPosition

previousCellPosition: CellPosition;

The cell that currently has focus

interface TabToNextGridContainerParams

interface TabToNextGridContainerParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property backwards

backwards: boolean;

True if the Shift key is also down.

property defaultTarget

defaultTarget: TabToNextGridContainerTarget | null;

The target the grid would normally focus when moving to nextContainer, or null if it can't be represented.

property nextContainer

nextContainer: GridContainerName;

The container the grid would normally focus next.

property previousContainer

previousContainer: GridContainerName;

The container that currently has focus.

interface TabToNextHeaderParams

interface TabToNextHeaderParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property backwards

backwards: boolean;

True if the Shift key is also down

property headerRowCount

headerRowCount: number;

The number of header rows present in the grid

property nextHeaderPosition

nextHeaderPosition: HeaderPosition | null;

The header the grid would normally pick as the next header for this navigation

property previousHeaderPosition

previousHeaderPosition: HeaderPosition | null;

The header that currently has focus

interface TapEvent

interface TapEvent extends AgEvent<'tap'> {}

property touchStart

touchStart: Touch;

interface TextAdvancedFilterModel

interface TextAdvancedFilterModel {}

Represents a single filter condition for a text column

property colId

colId: string;

The ID of the column being filtered.

property filter

filter?: string;

The value to filter on. This is the same value as displayed in the input.

property filterType

filterType: 'text';

property type

type: TextAdvancedFilterModelType;

The filter option that is being applied.

interface TextDataTypeDefinition

interface TextDataTypeDefinition<TData = any, TContext = any>
    extends BaseDataTypeDefinition<'text', TData, string, TContext> {}

Represents a 'text' data type (type string).

interface TextFilterModel

interface TextFilterModel extends ISimpleFilterModel {}

property filter

filter?: string | null;

The text value associated with the filter. It's optional as custom filters may not have a text value.

property filterTo

filterTo?: string | null;

The 2nd text value associated with the filter, if supported.

property filterType

filterType?: 'text';

Filter type is always 'text'

interface TextMatcherParams

interface TextMatcherParams extends BaseColDefParams {}

property filterOption

filterOption: string | null | undefined;

The applicable filter option being tested. One of: equals, notEqual, contains, notContains, startsWith, endsWith.

property filterText

filterText: string | null;

The value to filter by. If a textFormatter is provided, this value will have been formatted. If no textFormatter is provided and caseSensitive is not provided or is false, the value will have been converted to lower case.

property textFormatter

textFormatter?: TextFormatter;

property value

value: any;

The value about to be filtered. If this column has a value getter, this value will be coming from the value getter, otherwise it is the raw value injected into the grid. If a textFormatter is provided, this value will have been formatted. If no textFormatter is provided and caseSensitive is not provided or is false, the value will have been converted to lower case.

interface ToolbarBuiltInItemDef

interface ToolbarBuiltInItemDef extends ToolbarItemDefBase {}

Reference to a built-in toolbar item component (or 'separator') that does not accept params.

property action

action?: never;

Not used for built-in items — use the Action Button variant for label/icon/action.

property icon

icon?: never;

Not used for built-in items — use the Action Button variant for label/icon/action.

property label

label?: never;

Not used for built-in items — use the Action Button variant for label/icon/action.

property toolbarItem

toolbarItem:
    | Exclude<ToolbarItemComponentName, 'agMenuToolbarItem'>
    | 'separator';

A built-in toolbar item component name, or 'separator'.

property toolbarItemParams

toolbarItemParams?: never;

Built-in items (other than agMenuToolbarItem) do not accept params.

interface ToolbarButtonItemDef

interface ToolbarButtonItemDef<TData = any, TContext = any>
    extends ToolbarItemDefBase {}

Action Button shorthand — renders a default button using label, icon and action, without requiring a component reference. Provide at least one of label, icon or action.

property action

action?: (params: ToolbarItemActionParams<TData, TContext>) => void;

Function invoked when the default button is clicked.

property icon

icon?: IconName;

Icon displayed on the default button.

property label

label?: string;

Visible text rendered next to the icon. Omit to render an icon-only button.

property toolbarItem

toolbarItem?: never;

Not used for action buttons — set toolbarItem to use a built-in or custom component instead.

property toolbarItemParams

toolbarItemParams?: never;

Not used for action buttons — set toolbarItem to use a built-in or custom component instead.

property tooltip

tooltip?: string;

Hover tooltip and aria-label. Falls back to label when omitted.

interface ToolbarCustomItemDef

interface ToolbarCustomItemDef<TParams = any, TCustom = any>
    extends ToolbarItemDefBase {}

Reference to a user-provided custom toolbar item component. toolbarItem is a component class/function, or the name of a registered custom component.

property action

action?: never;

Not used for custom items — use the Action Button variant for label/icon/action.

property icon

icon?: never;

Not used for custom items — use the Action Button variant for label/icon/action.

property label

label?: never;

Not used for custom items — use the Action Button variant for label/icon/action.

property toolbarItem

toolbarItem: TCustom;

Custom component reference, or the name of a registered custom component.

property toolbarItemParams

toolbarItemParams?: TParams;

Parameters forwarded to the custom component.

interface ToolbarItemActionParams

interface ToolbarItemActionParams<TData = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

Params passed to a toolbar item's action callback when the item is activated.

property key

key: string;

The toolbar item key identifying which item triggered the action.

interface ToolbarMenuBuiltInItemDef

interface ToolbarMenuBuiltInItemDef<TData = any, TContext = any>
    extends ToolbarItemDefBase {}

Reference to the agMenuToolbarItem built-in toolbar item — a button that opens a dropdown menu. Configure label, icon, and tooltip at the top level; toolbarItemParams carries the menu contents.

property action

action?: never;

Not used for menu items.

property icon

icon?: IconName;

Icon displayed on the button. Defaults to the menu icon.

property label

label?: string;

Visible text rendered next to the icon. Omit to render an icon-only button.

property toolbarItem

toolbarItem: 'agMenuToolbarItem';

The agMenuToolbarItem built-in component.

property toolbarItemParams

toolbarItemParams?: ToolbarMenuItemParams<TData, TContext>;

Configuration for the menu button (menu items).

property tooltip

tooltip?: string;

Hover tooltip and aria-label. Falls back to label, then to the locale "Menu" text.

interface ToolbarMenuItemParams

interface ToolbarMenuItemParams<TData = any, TContext = any> {}

Params accepted by the agMenuToolbarItem built-in toolbar item.

property menuItems

menuItems?: (MenuItemDef<TData, TContext> | DefaultMenuItem)[];

Items shown in the dropdown. Accepts MenuItemDef objects or built-in string names (e.g. 'copy', 'export', 'separator').

interface ToolPanelClassParams

interface ToolPanelClassParams<TData = any, TValue = any, TContext = any>
    extends AgGridCommon<TData, TContext> {}

property colDef

colDef: AbstractColDef<TData, TValue>;

property column

column?: Column<TValue> | null;

property columnGroup

columnGroup?: ProvidedColumnGroup | null;

interface ToolPanelDef

interface ToolPanelDef {}

property iconKey

iconKey: string;

The key of the icon to be used as a graphical aid beside the label in the side bar.

property id

id: string;

The unique ID for this panel. Used in the API and elsewhere to refer to the panel.

property labelDefault

labelDefault: string;

The default label if labelKey is missing or does not map to valid text through localisation.

property labelKey

labelKey: string;

The key used for localisation for displaying the label. The label is displayed in the tab button.

property maxWidth

maxWidth?: number;

The max width of the tool panel.

property minWidth

minWidth?: number;

The min width of the tool panel. 100

property parent

parent?: HTMLElement | null;

DOM element to use as the parent for the tool panel to allow it to appear outside the grid. Set to null or omit the property for tool panel to appear inside the grid.

property toolPanel

toolPanel?: any;

The tool panel component to use as the panel. The provided panels use components agColumnsToolPanel, agFiltersToolPanel and agNewFiltersToolPanel. To provide your own custom panel component, you reference it here.

property toolPanelParams

toolPanelParams?: any;

Customise the parameters provided to the toolPanel component.

property width

width?: number;

The initial width of the tool panel. $side-bar-panel-width (theme variable)

interface ToolPanelSizeChangedEvent

interface ToolPanelSizeChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'toolPanelSizeChanged', TData, TContext> {}

property ended

ended: boolean;

True if this is the last change to the Tool Panel size.

property started

started: boolean;

True if this is the first change to the Tool Panel size.

property width

width: number;

New width of the ToolPanel component.

interface ToolPanelVisibleChangedEvent

interface ToolPanelVisibleChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'toolPanelVisibleChanged', TData, TContext> {}

property key

key: string;

Key of tool panel.

property source

source: 'sideBarButtonClicked' | 'sideBarInitializing' | 'api';

property switchingToolPanel

switchingToolPanel: boolean;

True if switching between tool panels. False if showing/hiding.

property visible

visible: boolean;

True if now visible; false if now hidden.

interface TooltipHideEvent

interface TooltipHideEvent<TData = any, TContext = any>
    extends TooltipEvent<'tooltipHide', TData, TContext> {}

interface TooltipShowEvent

interface TooltipShowEvent<TData = any, TContext = any>
    extends TooltipEvent<'tooltipShow', TData, TContext> {}

property tooltipGui

tooltipGui: HTMLElement;

interface TopChangedEvent

interface TopChangedEvent<TData = any> extends RowNodeEvent<'topChanged', TData> {}

interface TouchShowContextMenuParam

interface TouchShowContextMenuParam {}

property touchEvent

touchEvent: TouchEvent;

interface UiLevelChangedEvent

interface UiLevelChangedEvent<TData = any>
    extends RowNodeEvent<'uiLevelChanged', TData> {}

interface UndoEndedEvent

interface UndoEndedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'undoEnded', TData, TContext> {}

property operationPerformed

operationPerformed: boolean;

true if any undo operations were performed.

property source

source: 'api' | 'ui';

Source of the event. api if via API method. ui if via keyboard shortcut.

interface UndoStartedEvent

interface UndoStartedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'undoStarted', TData, TContext> {}

property source

source: 'api' | 'ui';

Source of the event. api if via API method. ui if via keyboard shortcut.

interface UpdateCrossFilterChartParams

interface UpdateCrossFilterChartParams extends BaseUpdateChartParams {}

property aggFunc

aggFunc?: string | IAggFunc;

The aggregation function that should be applied to all series data.

property cellRange

cellRange?: ChartParamsCellRange;

The range of cells to be charted. If no rows / rowIndexes are specified all rows will be included.

property suppressChartRanges

suppressChartRanges?: boolean;

Suppress highlighting the selected range in the grid.

property type

type: 'crossFilterChartUpdate';

interface UpdatePivotChartParams

interface UpdatePivotChartParams extends BaseUpdateChartParams {}

property type

type: 'pivotChartUpdate';

interface UpdateRangeChartParams

interface UpdateRangeChartParams extends BaseUpdateChartParams {}

property aggFunc

aggFunc?: string | IAggFunc;

The aggregation function that should be applied to all series data.

property cellRange

cellRange?: ChartParamsCellRange;

The range of cells to be charted. If no rows / rowIndexes are specified all rows will be included.

property seriesChartTypes

seriesChartTypes?: SeriesChartType[];

The series chart type configurations used in combination charts.

property seriesGroupType

seriesGroupType?: SeriesGroupType;

Group type for chart types that support grouped series.

property suppressChartRanges

suppressChartRanges?: boolean;

Suppress highlighting the selected range in the grid.

property switchCategorySeries

switchCategorySeries?: boolean;

Switch Category / Series.

property type

type: 'rangeChartUpdate';

property useGroupColumnAsCategory

useGroupColumnAsCategory?: boolean;

Prefer using the auto group column as the category when grouping is active.

interface ValueFormatterParams

interface ValueFormatterParams<TData = any, TValue = any, TContext = any>
    extends BaseColDefOptionalDataParams<TData, TValue, TContext> {}

property value

value: TValue | null | undefined;

Value for the cell.

interface ValueGetterParams

interface ValueGetterParams<TData = any, TValue = any, TContext = any>
    extends BaseColDefOptionalDataParams<TData, TValue, TContext> {}

property getValue

getValue: (field: string) => any;

A utility method for getting other column values

interface ValueParam

interface ValueParam {}

property kind

kind: 'value';

property value

value: unknown;

interface ValueParserParams

interface ValueParserParams<TData = any, TValue = any, TContext = any>
    extends ChangedValueParams<TData, TValue | null | undefined, string, TContext> {}

interface ValueSetterParams

interface ValueSetterParams<TData = any, TValue = any, TContext = any>
    extends ChangedValueParams<
        TData,
        TValue | null | undefined,
        TValue | null | undefined,
        TContext
    > {}

interface ViewportChangedEvent

interface ViewportChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'viewportChanged', TData, TContext> {}

property firstRow

firstRow: number;

Index of the first rendered row

property lastRow

lastRow: number;

Index of the last rendered row

interface VirtualColumnsChangedEvent

interface VirtualColumnsChangedEvent<TData = any, TContext = any>
    extends AgGlobalEvent<'virtualColumnsChanged', TData, TContext> {}

property afterScroll

afterScroll: boolean;

interface VirtualRowRemovedEvent

interface VirtualRowRemovedEvent<TData = any, TContext = any>
    extends RowEvent<'virtualRowRemoved', TData, TContext> {}

Enums

enum CellRangeType

enum CellRangeType {
    VALUE = 0,
    DIMENSION = 1,
}

member DIMENSION

DIMENSION = 1

member VALUE

VALUE = 0

enum DragSourceType

enum DragSourceType {
    ToolPanel = 0,
    HeaderCell = 1,
    RowDrag = 2,
    ChartPanel = 3,
    AdvancedFilterBuilder = 4,
}

member AdvancedFilterBuilder

AdvancedFilterBuilder = 4

member ChartPanel

ChartPanel = 3

member HeaderCell

HeaderCell = 1

member RowDrag

RowDrag = 2

member ToolPanel

ToolPanel = 0

enum ServerSideTransactionResultStatus

enum ServerSideTransactionResultStatus {
    Applied = 'Applied',
    StoreNotFound = 'StoreNotFound',
    StoreLoading = 'StoreLoading',
    StoreWaitingToLoad = 'StoreWaitingToLoad',
    StoreLoadingFailed = 'StoreLoadingFailed',
    StoreWrongType = 'StoreWrongType',
    Cancelled = 'Cancelled',
    StoreNotStarted = 'StoreNotStarted',
}

member Applied

Applied = 'Applied'

Transaction was successfully applied

member Cancelled

Cancelled = 'Cancelled'

Transaction was cancelled, due to grid. Callback isApplyServerSideTransaction() returning false

member StoreLoading

StoreLoading = 'StoreLoading'

Store is loading, transaction not applied.

member StoreLoadingFailed

StoreLoadingFailed = 'StoreLoadingFailed'

Store load attempt failed, transaction not applied.

member StoreNotFound

StoreNotFound = 'StoreNotFound'

Store was not found, transaction not applied. Either invalid route, or the parent row has not yet been expanded.

member StoreNotStarted

StoreNotStarted = 'StoreNotStarted'

Store has not started yet, transaction not applied

member StoreWaitingToLoad

StoreWaitingToLoad = 'StoreWaitingToLoad'

Store is loading (as max loads exceeded), transaction not applied.

member StoreWrongType

StoreWrongType = 'StoreWrongType'

Store is type Partial, which doesn't accept transactions

Type Aliases

type AdvancedFilterModel

type AdvancedFilterModel = JoinAdvancedFilterModel | ColumnAdvancedFilterModel;

type AgEventListener

type AgEventListener<
    TData = any,
    TContext = any,
    TEventType extends AgEventType = AgEventType
> = (params: AgEventTypeParams<TData, TContext>[TEventType]) => void;

type AgEventType

type AgEventType = AgPublicEventType | AgInternalEventType;

type AgEventTypeParams

type AgEventTypeParams<TData = any, TContext = any> = BuildEventTypeMap<
    AgPublicEventType | AgInternalEventType,
    {
        columnEverythingChanged: ColumnEverythingChangedEvent<TData, TContext>;
        newColumnsLoaded: NewColumnsLoadedEvent<TData, TContext>;
        columnPivotModeChanged: ColumnPivotModeChangedEvent<TData, TContext>;
        pivotMaxColumnsExceeded: PivotMaxColumnsExceededEvent<TData, TContext>;
        columnRowGroupChanged: ColumnRowGroupChangedEvent<TData, TContext>;
        expandOrCollapseAll: ExpandOrCollapseAllEvent<TData, TContext>;
        columnPivotChanged: ColumnPivotChangedEvent<TData, TContext>;
        gridColumnsChanged: GridColumnsChangedEvent<TData, TContext>;
        columnValueChanged: ColumnValueChangedEvent<TData, TContext>;
        columnMoved: ColumnMovedEvent<TData, TContext>;
        columnVisible: ColumnVisibleEvent<TData, TContext>;
        columnPinned: ColumnPinnedEvent<TData, TContext>;
        columnGroupOpened: ColumnGroupOpenedEvent<TData, TContext>;
        columnResized: ColumnResizedEvent<TData, TContext>;
        displayedColumnsChanged: DisplayedColumnsChangedEvent<TData, TContext>;
        virtualColumnsChanged: VirtualColumnsChangedEvent<TData, TContext>;
        columnHeaderMouseOver: ColumnHeaderMouseOverEvent<TData, TContext>;
        columnHeaderMouseLeave: ColumnHeaderMouseLeaveEvent<TData, TContext>;
        columnHeaderClicked: ColumnHeaderClickedEvent<TData, TContext>;
        columnHeaderContextMenu: ColumnHeaderContextMenuEvent<TData, TContext>;
        asyncTransactionsFlushed: AsyncTransactionsFlushedEvent<TData, TContext>;
        rowGroupOpened: RowGroupOpenedEvent<TData, TContext>;
        rowDataUpdated: RowDataUpdatedEvent<TData, TContext>;
        pinnedRowDataChanged: PinnedRowDataChangedEvent<TData, TContext>;
        pinnedRowsChanged: PinnedRowsChangedEvent<TData, TContext>;
        rangeSelectionChanged: RangeSelectionChangedEvent<TData, TContext>;
        cellSelectionChanged: CellSelectionChangedEvent<TData, TContext>;
        chartCreated: ChartCreatedEvent<TData, TContext>;
        chartRangeSelectionChanged: ChartRangeSelectionChangedEvent<TData, TContext>;
        chartOptionsChanged: ChartOptionsChangedEvent<TData, TContext>;
        chartDestroyed: ChartDestroyedEvent<TData, TContext>;
        toolPanelVisibleChanged: ToolPanelVisibleChangedEvent<TData, TContext>;
        toolPanelSizeChanged: ToolPanelSizeChangedEvent<TData, TContext>;
        modelUpdated: ModelUpdatedEvent<TData, TContext>;
        cutStart: CutStartEvent<TData, TContext>;
        cutEnd: CutEndEvent<TData, TContext>;
        pasteStart: PasteStartEvent<TData, TContext>;
        pasteEnd: PasteEndEvent<TData, TContext>;
        fillStart: FillStartEvent<TData, TContext>;
        fillEnd: FillEndEvent<TData, TContext>;
        cellSelectionDeleteStart: CellSelectionDeleteStartEvent<TData, TContext>;
        cellSelectionDeleteEnd: CellSelectionDeleteEndEvent<TData, TContext>;
        rangeDeleteStart: RangeDeleteStartEvent<TData, TContext>;
        rangeDeleteEnd: RangeDeleteEndEvent<TData, TContext>;
        undoStarted: UndoStartedEvent<TData, TContext>;
        undoEnded: UndoEndedEvent<TData, TContext>;
        redoStarted: RedoStartedEvent<TData, TContext>;
        redoEnded: RedoEndedEvent<TData, TContext>;
        cellClicked: CellClickedEvent<TData, TContext>;
        cellDoubleClicked: CellDoubleClickedEvent<TData, TContext>;
        cellMouseDown: CellMouseDownEvent<TData, TContext>;
        cellContextMenu: CellContextMenuEvent<TData, TContext>;
        cellValueChanged: CellValueChangedEvent<TData, TContext>;
        cellEditRequest: CellEditRequestEvent<TData, TContext>;
        rowValueChanged: RowValueChangedEvent<TData, TContext>;
        headerFocused: HeaderFocusedEvent<TData, TContext>;
        cellFocused: CellFocusedEvent<TData, TContext>;
        rowSelected: RowSelectedEvent<TData, TContext>;
        selectionChanged: SelectionChangedEvent<TData, TContext>;
        tooltipShow: TooltipShowEvent<TData, TContext>;
        tooltipHide: TooltipHideEvent<TData, TContext>;
        cellKeyDown:
            | FullWidthCellKeyDownEvent<TData, TContext>
            | CellKeyDownEvent<TData, TContext>;
        cellMouseOver: CellMouseOverEvent<TData, TContext>;
        cellMouseOut: CellMouseOutEvent<TData, TContext>;
        filterChanged: FilterChangedEvent<TData, TContext>;
        filterModified: FilterModifiedEvent<TData, TContext>;
        filterUiChanged: FilterUiChangedEvent<TData, TContext>;
        filterOpened: FilterOpenedEvent<TData, TContext>;
        floatingFilterUiChanged: FloatingFilterUiChangedEvent<TData, TContext>;
        advancedFilterBuilderVisibleChanged: AdvancedFilterBuilderVisibleChangedEvent<
            TData,
            TContext
        >;
        sortChanged: SortChangedEvent<TData, TContext>;
        virtualRowRemoved: VirtualRowRemovedEvent<TData, TContext>;
        rowClicked: RowClickedEvent<TData, TContext>;
        rowDoubleClicked: RowDoubleClickedEvent<TData, TContext>;
        gridReady: GridReadyEvent<TData, TContext>;
        gridPreDestroyed: GridPreDestroyedEvent<TData, TContext>;
        gridSizeChanged: GridSizeChangedEvent<TData, TContext>;
        viewportChanged: ViewportChangedEvent<TData, TContext>;
        firstDataRendered: FirstDataRenderedEvent<TData, TContext>;
        dragStarted: DragStartedEvent<TData, TContext>;
        dragStopped: DragStoppedEvent<TData, TContext>;
        dragCancelled: DragCancelledEvent<TData, TContext>;
        rowEditingStarted: RowEditingStartedEvent<TData, TContext>;
        rowEditingStopped: RowEditingStoppedEvent<TData, TContext>;
        cellEditingStarted: CellEditingStartedEvent<TData, TContext>;
        cellEditingStopped: CellEditingStoppedEvent<TData, TContext>;
        bodyScroll: BodyScrollEvent<TData, TContext>;
        bodyScrollEnd: BodyScrollEndEvent<TData, TContext>;
        paginationChanged: PaginationChangedEvent<TData, TContext>;
        componentStateChanged: ComponentStateChangedEvent<TData, TContext>;
        storeRefreshed: StoreRefreshedEvent<TData, TContext>;
        stateUpdated: StateUpdatedEvent<TData, TContext>;
        columnMenuVisibleChanged: ColumnMenuVisibleChangedEvent<TData, TContext>;
        contextMenuVisibleChanged: ContextMenuVisibleChangedEvent<TData, TContext>;
        rowDragEnter: RowDragEnterEvent<TData, TContext>;
        rowDragMove: RowDragMoveEvent<TData, TContext>;
        rowDragLeave: RowDragLeaveEvent<TData, TContext>;
        rowDragEnd: RowDragEndEvent<TData, TContext>;
        rowDragCancel: RowDragCancelEvent<TData, TContext>;
        findChanged: FindChangedEvent<TData, TContext>;
        rowResizeStarted: RowResizeStartedEvent<TData, TContext>;
        rowResizeEnded: RowResizeEndedEvent<TData, TContext>;
        scrollbarWidthChanged: ScrollbarWidthChangedEvent<TData, TContext>;
        keyShortcutChangedCellStart: KeyShortcutChangedCellStartEvent<
            TData,
            TContext
        >;
        keyShortcutChangedCellEnd: KeyShortcutChangedCellEndEvent<TData, TContext>;
        pinnedHeightChanged: PinnedHeightChangedEvent<TData, TContext>;
        cellFocusCleared: CellFocusClearedEvent<TData, TContext>;
        fullWidthRowFocused: FullWidthRowFocusedEvent<TData, TContext>;
        checkboxChanged: CheckboxChangedEvent<TData, TContext>;
        heightScaleChanged: HeightScaleChangedEvent<TData, TContext>;
        suppressMovableColumns: SuppressMovableColumnsEvent<TData, TContext>;
        suppressMenuHide: SuppressMenuHideEvent<TData, TContext>;
        suppressFieldDotNotation: SuppressFieldDotNotationEvent<TData, TContext>;
        columnPanelItemDragStart: ColumnPanelItemDragStartEvent<TData, TContext>;
        columnPanelItemDragEnd: ColumnPanelItemDragEndEvent<TData, TContext>;
        bodyHeightChanged: BodyHeightChangedEvent<TData, TContext>;
        columnContainerWidthChanged: ColumnContainerWidthChangedEvent<
            TData,
            TContext
        >;
        displayedColumnsWidthChanged: DisplayedColumnsWidthChangedEvent<
            TData,
            TContext
        >;
        scrollVisibilityChanged: ScrollVisibilityChangedEvent<TData, TContext>;
        scrollGapChanged: ScrollOverflowChangedEvent<TData, TContext>;
        columnHoverChanged: ColumnHoverChangedEvent<TData, TContext>;
        flashCells: FlashCellsEvent<TData, TContext>;
        paginationPixelOffsetChanged: PaginationPixelOffsetChangedEvent<
            TData,
            TContext
        >;
        displayedRowsChanged: DisplayedRowsChangedEvent<TData, TContext>;
        leftPinnedWidthChanged: LeftPinnedWidthChangedEvent<TData, TContext>;
        rightPinnedWidthChanged: RightPinnedWidthChangedEvent<TData, TContext>;
        rowContainerHeightChanged: RowContainerHeightChangedEvent<TData, TContext>;
        headerHeightChanged: HeaderHeightChangedEvent<TData, TContext>;
        columnGroupHeaderHeightChanged: ColumnGroupHeaderHeightChangedEvent<
            TData,
            TContext
        >;
        columnHeaderHeightChanged: ColumnHeaderHeightChangedEvent<TData, TContext>;
        stylesChanged: StylesChangedEvent<TData, TContext>;
        storeUpdated: StoreUpdatedEvent<TData, TContext>;
        filterDestroyed: FilterDestroyedEvent<TData, TContext>;
        filterHandlerDestroyed: FilterHandlerDestroyedEvent<TData, TContext>;
        filterClosed: FilterClosedEvent<TData, TContext>;
        rowDataUpdateStarted: RowDataUpdateStartedEvent<TData, TContext>;
        rowCountReady: RowCountReadyEvent<TData, TContext>;
        advancedFilterEnabledChanged: AdvancedFilterEnabledChangedEvent<
            TData,
            TContext
        >;
        dataTypesInferred: DataTypesInferredEvent<TData, TContext>;
        fieldValueChanged: FieldValueChangedEvent<TData, TContext>;
        fieldPickerValueSelected: FieldPickerValueSelectedEvent<TData, TContext>;
        richSelectListRowSelected: RichSelectListRowSelectedEvent<TData, TContext>;
        sideBarUpdated: SideBarUpdatedEvent<TData, TContext>;
        alignedGridScroll: AlignedGridScrollEvent<TData, TContext>;
        alignedGridColumn: AlignedGridColumnEvent<TData, TContext>;
        gridOptionsChanged: GridOptionsChangedEvent<TData, TContext>;
        chartTitleEdit: ChartTitleEditEvent<TData, TContext>;
        recalculateRowBounds: RecalculateRowBoundsEvent<TData, TContext>;
        stickyTopOffsetChanged: StickyTopOffsetChangedEvent<TData, TContext>;
        overlayExclusiveChanged: AgEvent<'overlayExclusiveChanged'>;
        rowNodeDataChanged: RowNodeDataChangedEvent<TData, TContext>;
        columnsReset: ColumnsResetEvent<TData, TContext>;
        cellEditValuesChanged: CellEditValuesChangedEvent<TData, TContext>;
        filterSwitched: FilterSwitchedEvent<TData, TContext>;
        batchEditingStarted: BatchEditingStartedEvent<TData, TContext>;
        batchEditingStopped: BatchEditingStoppedEvent<TData, TContext>;
        bulkEditingStarted: BulkEditingStartedEvent<TData, TContext>;
        bulkEditingStopped: BulkEditingStoppedEvent<TData, TContext>;
        headerRowsChanged: AgEvent<'headerRowsChanged'>;
        rowExpansionStateChanged: AgEvent<'rowExpansionStateChanged'>;
        showRowGroupColsSetChanged: AgEvent<'showRowGroupColsSetChanged'>;
        rowDragVisibilityChanged: AgEvent<'rowDragVisibilityChanged'>;
    }
>;

type AgGlobalEventListener

type AgGlobalEventListener<
    TData = any,
    TContext = any,
    T extends AgEventType = AgEventType
> = (eventType: T, event: AgEventTypeParams<TData, TContext>[T]) => void;

type AggregationStatusPanelAggFunc

type AggregationStatusPanelAggFunc = 'count' | 'sum' | 'min' | 'max' | 'avg';

type AgModuleName

type AgModuleName =
    | 'AiToolkitModule'
    | 'AlignedGridsModule'
    | 'AllCommunityModule'
    | 'CellApiModule'
    | 'CellStyleModule'
    | 'CheckboxEditorModule'
    | 'ClientSideRowModelApiModule'
    | 'ClientSideRowModelModule'
    | 'ColumnApiModule'
    | 'ColumnAutoSizeModule'
    | 'ColumnHoverModule'
    | 'CsvExportModule'
    | 'CustomEditorModule'
    | 'CustomFilterModule'
    | 'DateEditorModule'
    | 'DateFilterModule'
    | 'DragAndDropModule'
    | 'EventApiModule'
    | 'ExternalFilterModule'
    | 'GridStateModule'
    | 'RowGroupingEditModule'
    | 'HighlightChangesModule'
    | 'InfiniteRowModelModule'
    | 'LargeTextEditorModule'
    | 'LocaleModule'
    | 'NumberEditorModule'
    | 'NumberFilterModule'
    | 'BigIntFilterModule'
    | 'PaginationModule'
    | 'PinnedRowModule'
    | 'QuickFilterModule'
    | 'RenderApiModule'
    | 'RowApiModule'
    | 'RowAutoHeightModule'
    | 'RowDragModule'
    | 'RowSelectionModule'
    | 'RowStyleModule'
    | 'ScrollApiModule'
    | 'SelectEditorModule'
    | 'TextEditorModule'
    | 'TextFilterModule'
    | 'TooltipModule'
    | 'UndoRedoEditModule'
    | 'ValidationModule'
    | 'ValueCacheModule'
    | 'CellSpanModule'
    | 'AdvancedFilterModule'
    | 'AllEnterpriseModule'
    | 'BatchEditModule'
    | 'CellSelectionModule'
    | 'ClipboardModule'
    | 'ColumnMenuModule'
    | 'ColumnsToolPanelModule'
    | 'ContextMenuModule'
    | 'ExcelExportModule'
    | 'FiltersToolPanelModule'
    | 'FindModule'
    | 'GridChartsModule'
    | 'IntegratedChartsModule'
    | 'GroupFilterModule'
    | 'MasterDetailModule'
    | 'MenuModule'
    | 'MultiFilterModule'
    | 'NewFiltersToolPanelModule'
    | 'PivotModule'
    | 'RangeSelectionModule'
    | 'RichSelectModule'
    | 'RowNumbersModule'
    | 'RowGroupingModule'
    | 'RowGroupingPanelModule'
    | 'ServerSideRowModelApiModule'
    | 'ServerSideRowModelModule'
    | 'SetFilterModule'
    | 'SideBarModule'
    | 'SparklinesModule'
    | 'StatusBarModule'
    | 'ToolbarModule'
    | 'TreeDataModule'
    | 'ViewportRowModelModule'
    | 'FormulaModule'
    | 'NotesModule';

The names of all publicly available AG Grid modules

type AgPublicEventType

type AgPublicEventType = (typeof _PUBLIC_EVENTS)[number];

type AlignedGrid

type AlignedGrid =
    | TypeOrNull<GridApi>
    | ApiRef
    | {
          current: ApiRef;
      };

Alias for the grid API or an object containing the grid API for linking Aligned Grids.

type AllEvents

type AllEvents<TData = any, TContext = any> = {
    [K in keyof AgEventTypeParams<TData, TContext>]: AgEventTypeParams<
        TData,
        TContext
    >[K];
}[keyof AgEventTypeParams];

Union Type of all AG Grid Events

type AllEventsWithoutGridCommon

type AllEventsWithoutGridCommon<TData = any, TContext = any> = {
    [K in keyof AgEventTypeParams<TData, TContext>]: WithoutGridCommon<
        AgEventTypeParams<TData, TContext>[K]
    >;
}[keyof AgEventTypeParams];

Internal Interface for AG Grid Events

type AlwaysPassFilter

type AlwaysPassFilter<TData = any> = (rowNode: IRowNode<TData>) => boolean;

type AutoGroupColumnDef

type AutoGroupColumnDef<TData = any, TValue = any> = Omit<
    ColDef<TData, TValue>,
    'colId'
>;

Configuration for the autoGroupColumnDef property. Equivalent to ColDef but without the colId as this is defined by the grid.

type AutoSizeStrategy

type AutoSizeStrategy =
    | SizeColumnsToFitGridStrategy
    | SizeColumnsToFitProvidedWidthStrategy
    | SizeColumnsToContentStrategy;

type BaseCellDataType

type BaseCellDataType =
    | 'text'
    | 'number'
    | 'bigint'
    | 'boolean'
    | 'date'
    | 'dateString'
    | 'object'
    | 'dateTime'
    | 'dateTimeString';

The pre-defined base data types.
'text' is type string.
'number' is type number.
'bigint' is type bigint.
'boolean' is type boolean.
'date' is type Date.
'dateString' is type string but represents a date.
'dateTime' is type Date.
'dateTimeString' is type string but represents a date with time.
object is any other type.

type BigIntFilterParams

type BigIntFilterParams<TData = any> = IBigIntFilterParams & IFilterParams<TData>;

Parameters provided by the grid to the init method of a BigIntFilter. Do not use in colDef.filterParams - see IBigIntFilterParams instead.

type BooleanAdvancedFilterModelType

type BooleanAdvancedFilterModelType = 'true' | 'false';

type BorderStyleValue

type BorderStyleValue =
    | 'none'
    | 'solid'
    | 'dotted'
    | 'dashed'
    | 'inset'
    | 'outset'
    | AnyString
    | {
          ref: string;
      };

A CSS line-style value e.g. "solid" or "dashed".
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/line-style

type BorderValue

type BorderValue =
    | string
    | boolean
    | {
          style?: BorderStyleValue;
          width?: LengthValue;
          color?: ColorValue;
      }
    | {
          ref: string;
      };

A CSS border value e.g. "solid 1px red". Alternatively an object containing optional properties:
- style -> a CSS border-style, default "solid" - width -> a width in pixels, default {ref: "borderWidth"} (and the default borderWidth is 1) - color -> a ColorValue as you would pass to any color param, default {ref: "borderColor"}
Or a reference: - {ref: "foo"} -> use the same value as the foo param (ref must be a valid param name)
Or boolean value - true -> {} (the default border style, equivalent to {style: "solid", width: 1, color: {ref: "borderColor"}) - false -> "none" (no border).
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/border

type ButtonStyleParams

type ButtonStyleParams = {
    /**
     * Text color of standard action buttons (e.g. "Reset" and "Apply")
     */
    buttonTextColor: ColorValue;
    /**
     * Font weight of text in standard action buttons (e.g. "Reset" and "Apply")
     */
    buttonFontWeight: FontWeightValue;
    /**
     * Background color of standard action buttons (e.g. "Reset" and "Apply")
     */
    buttonBackgroundColor: ColorValue;
    /**
     * Border around standard action buttons (e.g. "Reset" and "Apply")
     */
    buttonBorder: BorderValue;
    /**
     * Corner radius of standard action buttons (e.g. "Reset" and "Apply")
     */
    buttonBorderRadius: LengthValue;
    /**
     * Horizontal padding inside standard action buttons (e.g. "Reset" and "Apply")
     */
    buttonHorizontalPadding: LengthValue;
    /**
     * Vertical padding inside standard action buttons (e.g. "Reset" and "Apply")
     */
    buttonVerticalPadding: LengthValue;
    /**
     * Text color of standard action buttons (e.g. "Reset" and "Apply") when hovered
     */
    buttonHoverTextColor: ColorValue;
    /**
     * Background color of standard action buttons (e.g. "Reset" and "Apply") when hovered
     */
    buttonHoverBackgroundColor: ColorValue;
    /**
     * Border around standard action buttons (e.g. "Reset" and "Apply") when hovered. Only has an effect if a border is enabled with `buttonBorder`.
     */
    buttonHoverBorder: BorderValue;
    /**
     * Text color of standard action buttons (e.g. "Reset" and "Apply") when being clicked
     */
    buttonActiveTextColor: ColorValue;
    /**
     * Background color of standard action buttons (e.g. "Reset" and "Apply") when being clicked
     */
    buttonActiveBackgroundColor: ColorValue;
    /**
     * Border around standard action buttons (e.g. "Reset" and "Apply") when being clicked. Only has an effect if a border is enabled with `buttonBorder`.
     */
    buttonActiveBorder: BorderValue;
    /**
     * Text color of standard action buttons (e.g. "Reset" and "Apply") when disabled
     */
    buttonDisabledTextColor: ColorValue;
    /**
     * Background color of standard action buttons (e.g. "Reset" and "Apply") when disabled
     */
    buttonDisabledBackgroundColor: ColorValue;
    /**
     * Border around standard action buttons (e.g. "Reset" and "Apply") when disabled.
     */
    buttonDisabledBorder: BorderValue;
};

type CellClassFunc

type CellClassFunc<TData = any, TValue = any, TContext = any> = (
    cellClassParams: CellClassParams<TData, TValue, TContext>
) => string | string[] | null | undefined;

type CellEditorSelectorFunc

type CellEditorSelectorFunc<TData = any, TValue = any, TContext = any> = (
    params: ICellEditorParams<TData, TValue, TContext>
) => CellEditorSelectorResult | undefined;

type CellRendererSelectorFunc

type CellRendererSelectorFunc<TData = any, TValue = any, TContext = any> = (
    params: ICellRendererParams<TData, TValue, TContext>
) => CellRendererSelectorResult | undefined;

type CellStyleFunc

type CellStyleFunc<TData = any, TValue = any, TContext = any> = (
    cellClassParams: CellClassParams<TData, TValue, TContext>
) => CellStyle | null | undefined;

type CellValueResolveFrom

type CellValueResolveFrom = 'edit' | 'batch' | 'data';

Specifies how to resolve the cell value when edits are pending. - 'edit': Returns the current editing value, including live editor typing and pending batch values. This is the default value. - 'batch': Returns pending batch values but excludes live editor typing (useful for dependent calculations in valueGetters) - 'data': Returns the actual stored data value, ignoring all edit state

type ChartDataPanelGroup

type ChartDataPanelGroup =
    | 'categories'
    | 'series'
    | 'seriesChartType'
    | 'chartSpecific';

type ChartFormatPanelGroup

type ChartFormatPanelGroup =
    | 'chart'
    | 'titles'
    | 'legend'
    | 'axis'
    | 'horizontalAxis'
    | 'verticalAxis'
    | 'series';

type ChartModelType

type ChartModelType = 'range' | 'pivot';

type ChartParamsCellRange

type ChartParamsCellRange = Partial<
    Omit<CellRangeParams, 'rowStartPinned' | 'rowEndPinned'>
>;

type ChartToolbarMenuItemOptions

type ChartToolbarMenuItemOptions =
    | 'chartLink'
    | 'chartUnlink'
    | 'chartDownload'
    | 'chartMenu';

type ChartToolPanelMenuOptions

type ChartToolPanelMenuOptions = 'chartSettings' | 'chartData' | 'chartFormat';

type ChartToolPanelName

type ChartToolPanelName = 'settings' | 'data' | 'format';

type ChartType

type ChartType =
    | 'column'
    | 'groupedColumn'
    | 'stackedColumn'
    | 'normalizedColumn'
    | 'bar'
    | 'groupedBar'
    | 'stackedBar'
    | 'normalizedBar'
    | 'line'
    | 'stackedLine'
    | 'normalizedLine'
    | 'scatter'
    | 'bubble'
    | 'pie'
    | 'donut'
    | 'doughnut'
    | 'area'
    | 'stackedArea'
    | 'normalizedArea'
    | 'histogram'
    | 'radarLine'
    | 'radarArea'
    | 'nightingale'
    | 'radialColumn'
    | 'radialBar'
    | 'sunburst'
    | 'rangeBar'
    | 'rangeArea'
    | 'boxPlot'
    | 'treemap'
    | 'heatmap'
    | 'waterfall'
    | 'columnLineCombo'
    | 'areaColumnCombo'
    | 'customCombo'
    | 'funnel'
    | 'coneFunnel'
    | 'pyramid';

type ChartTypeExCombo

type ChartTypeExCombo = Exclude<ChartType, ComboChartType>;

type CheckboxLocation

type CheckboxLocation = 'selectionColumn' | 'autoGroupColumn';

type CheckboxSelectionCallback

type CheckboxSelectionCallback<TData = any, TValue = any, TContext = any> = (
    params: CheckboxSelectionCallbackParams<TData, TValue, TContext>
) => boolean;

type CheckboxStyleParams

type CheckboxStyleParams = {
    /**
     * Border radius for checkboxes
     */
    checkboxBorderRadius: LengthValue;
    /**
     * Border width for checkboxes
     */
    checkboxBorderWidth: LengthValue;
    /**
     * Background color of a checked checkbox
     */
    checkboxCheckedBackgroundColor: ColorValue;
    /**
     * Border color of a checked checkbox
     */
    checkboxCheckedBorderColor: ColorValue;
    /**
     * The color of the check mark on checked checkboxes.
     */
    checkboxCheckedShapeColor: ColorValue;
    /**
     * An image defining the shape of the check mark on checked checkboxes.
     */
    checkboxCheckedShapeImage: ImageValue;
    /**
     * Background color of an indeterminate checkbox
     */
    checkboxIndeterminateBackgroundColor: ColorValue;
    /**
     * Border color of an indeterminate checkbox
     */
    checkboxIndeterminateBorderColor: ColorValue;
    /**
     * The color of the dash mark on indeterminate checkboxes
     */
    checkboxIndeterminateShapeColor: ColorValue;
    /**
     * An image defining the shape of the dash mark on indeterminate checkboxes
     */
    checkboxIndeterminateShapeImage: ImageValue;
    /**
     * Background color of an unchecked checkbox
     */
    checkboxUncheckedBackgroundColor: ColorValue;
    /**
     * Border color of an unchecked checkbox
     */
    checkboxUncheckedBorderColor: ColorValue;
    /**
     * An image defining the shape of the mark on checked radio buttons
     */
    radioCheckedShapeImage: ImageValue;
};

type ClientSideRowModelStage

type ClientSideRowModelStage =
    | 'group'
    | 'filter'
    | 'sort'
    | 'map'
    | 'aggregate'
    | 'filter_aggregates'
    | 'pivot'
    | 'nothing';

type ClientSideRowModelStep

type ClientSideRowModelStep =
    | 'everything'
    | 'group'
    | 'filter'
    | 'sort'
    | 'map'
    | 'aggregate'
    | 'filter_aggregates'
    | 'pivot'
    | 'nothing';

type ColDefField

type ColDefField<TData = any, TValue = any> = TData extends any
    ? NestedFieldPaths<TData, TValue, []>
    : never;

Returns a union of all possible paths to nested fields in TData.

type ColKey

type ColKey<TData = any, TValue = any> =
    | string
    | ColDef<TData, TValue>
    | Column<TValue>;

Select a column via: - the string (colId) - the colDef object - the Column instance

type ColorSchemeValue

type ColorSchemeValue =
    | 'light'
    | 'dark'
    | 'inherit'
    | 'normal'
    | AnyString
    | {
          ref: string;
      };

A CSS color-scheme value, e.g. "light", "dark", or "inherit" to use the same setting as the parent application
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/color-scheme

type ColorValue

type ColorValue =
    | string
    | {
          /**
           * The name of the color parameter to reference
           */
          ref: string;
          /**
           * Enable color mixing. Provide a value between 0 and 1 determining the amount of the referenced color used in the mix.
           *
           * By default, the referenced color will be mixed with `transparent` so 0 = fully transparent and 1 = fully opaque.
           */
          mix?: number;
          /**
           * Provide a second color reference to mix with instead of `transparent`. This has no effect if `mix` is unspecified.
           */
          onto?: string;
      };

The 'brand color' for the grid, used wherever a non-neutral color is required. Selections, focus outlines and checkboxes use the accent color by default.

type ColSpanFunc

type ColSpanFunc<TData = any, TValue = any, TContext = any> = (
    params: ColSpanParams<TData, TValue, TContext>
) => number;

type ColTypeDef

type ColTypeDef<TData = any, TValue = any> = Omit<
    ColDef<TData, TValue>,
    'type' | 'cellDataType'
>;

Configuration options for reusable columns types in AG Grid. This includes all possible options from ColDef except the type and cellDataType fields.

type ColTypeDefs

type ColTypeDefs<TData = any, TValue = any> = {
    [key: string]: ColTypeDef<TData, TValue>;
};

type ColumnAdvancedFilterModel

type ColumnAdvancedFilterModel =
    | BooleanAdvancedFilterModel
    | ObjectAdvancedFilterModel
    | DateAdvancedFilterModel
    | DateStringAdvancedFilterModel
    | DateTimeAdvancedFilterModel
    | DateTimeStringAdvancedFilterModel
    | BigIntAdvancedFilterModel
    | NumberAdvancedFilterModel
    | TextAdvancedFilterModel;

Represents a single filter condition on a column

type ColumnEventType

type ColumnEventType =
    | 'sizeColumnsToFit'
    | 'autosizeColumns'
    | 'autosizeColumnHeaderHeight'
    | 'alignedGridChanged'
    | 'filterChanged'
    | 'filterDestroyed'
    | 'gridOptionsChanged'
    | 'gridInitializing'
    | 'toolPanelDragAndDrop'
    | 'toolPanelUi'
    | 'uiColumnMoved'
    | 'uiColumnResized'
    | 'uiColumnDragged'
    | 'uiColumnExpanded'
    | 'uiColumnSorted'
    | 'contextMenu'
    | 'columnMenu'
    | 'rowModelUpdated'
    | 'rowDataUpdated'
    | 'api'
    | 'flex'
    | 'pivotChart'
    | 'columnRowGroupChanged'
    | 'cellDataTypeInferred'
    | 'rowNumbersService'
    | 'viewportSizeFeature';

---------------

type ColumnGroupShowType

type ColumnGroupShowType = 'open' | 'closed';

type ColumnMenuTab

type ColumnMenuTab = 'filterMenuTab' | 'generalMenuTab' | 'columnsMenuTab';

type ColumnPinnedType

type ColumnPinnedType = 'left' | 'right' | boolean | null | undefined;

type ColumnToolPanelAction

type ColumnToolPanelAction = 'apply' | 'cancel';

type ComboChartType

type ComboChartType = 'columnLineCombo' | 'areaColumnCombo' | 'customCombo';

type Components

type Components = {
    [p: string]: any;
};

Map of custom components keyed by string

type ContainerType

type ContainerType =
    | 'columnMenu'
    | 'contextMenu'
    | 'toolPanel'
    | 'floatingFilter'
    | 'columnFilter'
    | 'newFiltersToolPanel';

type CoreDataTypeDefinition

type CoreDataTypeDefinition<TData = any, TValue = any, TContext = any> = Omit<
    DataTypeDefinition<TData, TValue, TContext>,
    'extendsDataType'
>;

Configuration options for pre-defined data types.

type CreateChartContainer

type CreateChartContainer<TData = any, TContext = any> = (
    params: ChartRefParams<TData, TContext>
) => void;

type CreateFilterHandlerFunc

type CreateFilterHandlerFunc<
    TData = any,
    TValue = any,
    TContext = any,
    TModel = any,
    TCustomParams = any
> = (
    params: CreateFilterHandlerFuncParams<TData, TValue, TContext>
) => FilterHandler<TData, TContext, TModel, TCustomParams>;

type CrossFilterChartType

type CrossFilterChartType =
    | 'column'
    | 'bar'
    | 'line'
    | 'scatter'
    | 'bubble'
    | 'pie'
    | 'donut'
    | 'doughnut'
    | 'area';

type CsvCustomContent

type CsvCustomContent = CsvCell[][] | string;

type CustomChartThemes

type CustomChartThemes = {
    [name: string]: AgChartTheme;
};

Map of custom chart themes

type DataTypeDefinition

type DataTypeDefinition<TData = any, TValue = any, TContext = any> =
    | TextDataTypeDefinition<TData, TContext>
    | NumberDataTypeDefinition<TData, TContext>
    | BigIntDataTypeDefinition<TData, TContext>
    | BooleanDataTypeDefinition<TData, TContext>
    | DateDataTypeDefinition<TData, TContext>
    | DateStringDataTypeDefinition<TData, TContext>
    | DateTimeDataTypeDefinition<TData, TContext>
    | DateTimeStringDataTypeDefinition<TData, TContext>
    | ObjectDataTypeDefinition<TData, TValue, TContext>;

Configuration options for a cell data type.

type DataTypeDefinitions

type DataTypeDefinitions<TData = any, TValue = any, TContext = any> = {
    [cellDataType: string]: DataTypeDefinition<TData, TValue, TContext>;
};

type DataTypeFormatValueFunc

type DataTypeFormatValueFunc = (params: {
    column: Column;
    node: IRowNode | null;
    value: any;
}) => string;

type DataValueFrom

type DataValueFrom = 'data' | 'data-raw' | 'value' | CellValueResolveFrom;

Specifies how to resolve the value returned by rowNode.getDataValue().
- 'data' (default) — Committed data, ignoring pending edits. For aggregation columns using avg or count, the raw IAggFuncResult wrapper is returned. - 'data-raw' — Same as 'data' but skips aggregation results (rowNode.aggData) and formula resolution. - 'value' — Same as 'data', but aggregation wrappers are resolved to their scalar value. - 'edit' — Live editor value if a cell is being edited, then pending batch value, then committed data. - 'batch' — Pending batch value (excludes live editor typing), then committed data.

type DateFilterParams

type DateFilterParams<TData = any> = IDateFilterParams & IFilterParams<TData>;

Parameters provided by the grid to the init method of a DateFilter. Do not use in colDef.filterParams - see IDateFilterParams instead.

type DefaultChartMenuItem

type DefaultChartMenuItem =
    | 'chartEdit'
    | 'chartAdvancedSettings'
    | 'chartUnlink'
    | 'chartLink'
    | 'chartDownload';

type DefaultMenuItem

type DefaultMenuItem =
    | 'pinSubMenu'
    | 'pinLeft'
    | 'pinRight'
    | 'pinRowSubMenu'
    | 'pinTop'
    | 'pinBottom'
    | 'unpinRow'
    | 'clearPinned'
    | 'valueAggSubMenu'
    | 'autoSizeThis'
    | 'autoSizeAll'
    | 'rowGroup'
    | 'rowUnGroup'
    | 'resetColumns'
    | 'expandAll'
    | 'contractAll'
    | 'copy'
    | 'copyWithHeaders'
    | 'copyWithGroupHeaders'
    | 'cut'
    | 'paste'
    | 'note'
    | 'export'
    | 'csvExport'
    | 'excelExport'
    | 'separator'
    | 'pivotChart'
    | 'chartRange'
    | 'columnFilter'
    | 'columnChooser'
    | 'sortAscending'
    | 'sortDescending'
    | 'sortAbsoluteAscending'
    | 'sortAbsoluteDescending'
    | 'sortUnSort';

type DndSourceCallback

type DndSourceCallback<TData = any, TValue = any, TContext = any> = (
    params: DndSourceCallbackParams<TData, TValue, TContext>
) => boolean;

type DndSourceOnRowDragFunc

type DndSourceOnRowDragFunc<TData = any, TContext = any> = (
    params: DndSourceOnRowDragParams<TData, TContext>
) => void;

type DoesExternalFilterPass

type DoesExternalFilterPass<TData = any> = (node: IRowNode<TData>) => boolean;

type DomLayoutType

type DomLayoutType = 'normal' | 'autoHeight' | 'print';

type DragAndDropIcon

type DragAndDropIcon =
    | 'pinned'
    | 'move'
    | 'left'
    | 'right'
    | 'group'
    | 'aggregate'
    | 'pivot'
    | 'notAllowed'
    | 'hide';

type DropIndicatorPosition

type DropIndicatorPosition = 'above' | 'inside' | 'below' | 'none';

type DurationValue

type DurationValue =
    | number
    | string
    | {
          ref: string;
      };

A CSS time value with second or millisecond units e.g. "0.3s" or "300ms". Alternatively:
- 0.4 -> "0.4s" (a plain JavaScript number is assumed to be a number of seconds. - {ref: "foo"} -> use the same value as the foo param (ref must be a valid param name)
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/animation-duration

type EditableCallback

type EditableCallback<TData = any, TValue = any, TContext = any> = (
    params: EditableCallbackParams<TData, TValue, TContext>
) => boolean;

type EditStrategyType

type EditStrategyType = 'singleCell' | 'fullRow';

type EditValidationCommitType

type EditValidationCommitType = 'revert' | 'block';

type EqualsFunc

type EqualsFunc<TValue = any> = (
    valueA: TValue | null | undefined,
    valueB: TValue | null | undefined
) => boolean;

type EventShowContextMenuParams

type EventShowContextMenuParams = (
    | MouseShowContextMenuParams
    | TouchShowContextMenuParam
) &
    ShowContextMenuParams;

type ExcelCustomMetadata

type ExcelCustomMetadata = Record<string, ExcelCustomMetadataValue>;

type ExcelCustomMetadataValue

type ExcelCustomMetadataValue = string | number | boolean;

type ExcelDataType

type ExcelDataType =
    | 'String'
    | 'Formula'
    | 'Number'
    | 'Boolean'
    | 'DateTime'
    | 'Error';

type ExcelFactoryMode

type ExcelFactoryMode = 'SINGLE_SHEET' | 'MULTI_SHEET';

type ExcelFreezeColumnsGetter

type ExcelFreezeColumnsGetter = (params: ExcelFreezeColumnsGetterParams) => boolean;

type ExcelFreezeRowsGetter

type ExcelFreezeRowsGetter = (params: ExcelFreezeRowsGetterParams) => boolean;

type ExcelHeaderFooter

type ExcelHeaderFooter = ExcelFooter | ExcelHeader | (ExcelFooter & ExcelHeader);

type ExcelOOXMLDataType

type ExcelOOXMLDataType =
    | 'str'
    | 's'
    | 'f'
    | 'inlineStr'
    | 'n'
    | 'b'
    | 'd'
    | 'e'
    | 'empty';

type ExcelSheetNameGetter

type ExcelSheetNameGetter = (params?: ExcelSheetNameGetterParams) => string;

type ExportFileNameGetter

type ExportFileNameGetter = (params?: ExportFileNameGetterParams) => string;

type FillOperation

type FillOperation<TData = any, TContext = any> = (
    params: FillOperationParams<TData, TContext>
) => any;

type FilterAction

type FilterAction = 'apply' | 'clear' | 'reset' | 'cancel';

type FilterChangedEventSourceType

type FilterChangedEventSourceType =
    | 'api'
    | 'quickFilter'
    | 'columnFilter'
    | 'advancedFilter';

type FilterDisplaySource

type FilterDisplaySource = 'init' | 'ui' | 'api' | 'colDef' | 'handler' | 'floating';

type FilterHandlers

type FilterHandlers<
    TData = any,
    TValue = any,
    TContext = any,
    TModel = any,
    TCustomParams = any
> = {
    [key: string]: CreateFilterHandlerFunc<
        TData,
        TValue,
        TContext,
        TModel,
        TCustomParams
    >;
};

type FilterHandlerSource

type FilterHandlerSource = 'init' | 'ui' | 'api' | 'colDef' | 'floating' | 'handler';

type FilterPanelFilterState

type FilterPanelFilterState = FilterPanelSummaryState | FilterPanelDetailState;

type FilterPlaceholderFunction

type FilterPlaceholderFunction = (
    params: IFilterPlaceholderFunctionParams
) => string;

type FilterRequestSource

type FilterRequestSource = 'COLUMN_MENU' | 'TOOLBAR' | 'NO_UI';

type FocusGridInnerElement

type FocusGridInnerElement<TData = any, TContext = any> = (
    params: FocusGridInnerElementParams<TData, TContext>
) => boolean;

type FontFamilyValue

type FontFamilyValue =
    | string
    | {
          googleFont: string;
      }
    | Array<
          | string
          | {
                googleFont: string;
            }
      >
    | {
          ref: string;
      };

A CSS font-family value consisting of a font name or comma-separated list of fonts in order of preference e.g. "Roboto, -apple-system, 'Segoe UI', sans-serif". Alternatively:
- ["Roboto", "-apple-system", "Segoe UI", "sans-serif"] -> an array of font names in order of preference - ["Dave's Font"] -> when passing an array, special characters in font names will automatically be escaped - {ref: "foo"} -> use the same value as foo which must be a valid font family param name
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/font-family

type FontWeightValue

type FontWeightValue =
    | 'normal'
    | 'bold'
    | AnyString
    | number
    | {
          ref: string;
      };

A CSS font-weight value e.g. 500 or "bold"
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/font-weight

type FooterValueGetterFunc

type FooterValueGetterFunc<TData = any, TValue = any> = (
    params: GroupCellRendererParams<TData, TValue>
) => any;

type FormulaFuncs

type FormulaFuncs = {
    [key: string]: {
        func: (params: FormulaFunctionParams) => any;
    };
};

A map of 'function name' to 'function' for custom functions that are used for formulas

type FormulaFunctionParams

type FormulaFunctionParams = {
    /** Row for this formula */
    row: IRowNode;
    /** Column for this formula */
    column: AgColumn;
    /** Top level params iterator only. */
    args: Iterable<FormulaParam>;
    /** Flattens all ranges and top level params */
    values: Iterable<unknown>;
};

type FormulaParam

type FormulaParam = ValueParam | RangeParam;

type FullWidthNotesDataSourceGetNoteParams

type FullWidthNotesDataSourceGetNoteParams =
    | NotesDataSourceNoteParams
    | NotesDataSourceFullWidthRowNoteParams;

type FullWidthNotesDataSourceSetNoteParams

type FullWidthNotesDataSourceSetNoteParams<TMetadata = any> =
    | NotesDataSourceSetNoteParams<TMetadata>
    | (NotesDataSourceFullWidthRowNoteParams & {
          /** Note to be saved. */
          note: Note<TMetadata> | undefined;
      });

type GetBusinessKeyForNode

type GetBusinessKeyForNode<TData = any> = (node: IRowNode<TData>) => string;

type GetChartMenuItems

type GetChartMenuItems<TData = any, TContext = any> = (
    params: GetChartMenuItemsParams<TData, TContext>
) => MenuCallbackReturn<DefaultChartMenuItem, TData, TContext>;

type GetChartToolbarItems

type GetChartToolbarItems<TData = any, TContext = any> = (
    params: GetChartToolbarItemsParams<TData, TContext>
) => ChartToolbarMenuItemOptions[];

type GetChildCount

type GetChildCount = (dataItem: any) => number;

type GetContextMenuItems

type GetContextMenuItems<TData = any, TContext = any> = (
    params: GetContextMenuItemsParams<TData, TContext>
) =>
    | MenuCallbackReturn<DefaultMenuItem, TData, TContext>
    | Promise<MenuCallbackReturn<DefaultMenuItem, TData, TContext>>;

type GetDataPath

type GetDataPath<TData = any> = (data: TData) => string[];

type GetDetailRowData

type GetDetailRowData<TData = any, TDetail = any> = (
    params: GetDetailRowDataParams<TData, TDetail>
) => void;

type GetDocument

type GetDocument = () => Document;

type GetFindMatches

type GetFindMatches<TData = any> = (params: GetFindMatchesParams<TData>) => number;

type GetFindTextFunc

type GetFindTextFunc<TData = any, TValue = any, TContext = any> = (
    params: GetFindTextParams<TData, TValue, TContext>
) => string | null;

type GetFullRowEditValidationErrors

type GetFullRowEditValidationErrors = (
    params: FullRowEditValidationParams
) => string[] | null;

type GetGroupRowAgg

type GetGroupRowAgg<TData = any, TContext = any> = (
    params: GetGroupRowAggParams<TData, TContext>
) => any;

type GetLocaleText

type GetLocaleText<TData = any, TContext = any> = (
    params: GetLocaleTextParams<TData, TContext>
) => string;

type GetMainMenuItems

type GetMainMenuItems<TData = any, TContext = any> = (
    params: GetMainMenuItemsParams<TData, TContext>
) => MenuCallbackReturn<DefaultMenuItem, TData, TContext>;

type GetNoteParams

type GetNoteParams = NoteParams | FullWidthRowNoteParams;

type GetQuickFilterText

type GetQuickFilterText<TData = any, TValue = any, TContext = any> = (
    params: GetQuickFilterTextParams<TData, TValue, TContext>
) => string;

type GetRowClass

type GetRowClass<TData = any, TContext = any> = (
    params: RowClassParams<TData, TContext>
) => string | string[] | undefined;

type GetRowHeight

type GetRowHeight<TData = any, TContext = any> = (
    params: RowHeightParams<TData, TContext>
) => number | undefined | null;

type GetRowIdFunc

type GetRowIdFunc<TData = any, TContext = any> = (
    params: GetRowIdParams<TData, TContext>
) => string;

type GetRowNodeIdFunc

type GetRowNodeIdFunc<TData = any> = (data: TData) => string;

type GetRowStyle

type GetRowStyle<TData = any, TContext = any> = (
    params: RowClassParams<TData, TContext>
) => RowStyle | undefined;

type GetServerSideGroupKey

type GetServerSideGroupKey = (dataItem: any) => string;

type GetServerSideGroupLevelParams

type GetServerSideGroupLevelParams<TData = any, TContext = any> = (
    params: GetServerSideGroupLevelParamsParams<TData, TContext>
) => ServerSideGroupLevelParams;

type GlobalGridOptionsMergeStrategy

type GlobalGridOptionsMergeStrategy = 'deep' | 'shallow';

When providing global grid options, specify how they should be merged with the grid options provided to individual grids. - deep will merge the global options into the provided options deeply, with provided options taking precedence. - shallow will merge the global options with the provided options shallowly, with provided options taking precedence. 'shallow'
Parameter gridOptions
global grid options

type GridContainerName

type GridContainerName = FocusableContainerName | 'external';

type GridOptionsWithDefaults

type GridOptionsWithDefaults = Required<
    Pick<PartialGridOptionsWithDefaults, GridOptionDefaultsKeys>
> &
    Omit<PartialGridOptionsWithDefaults, GridOptionDefaultsKeys>;

type GridStateKey

type GridStateKey = Exclude<
    keyof GridState,
    'version' | 'partialColumnState' | 'rangeSelection'
>;

type GroupCellRendererParams

type GroupCellRendererParams<TData = any, TValue = any> = IGroupCellRendererParams &
    ICellRendererParams<TData, TValue> &
    IGroupCellRendererFullRowParams;

Parameters provided by the grid to the init method of a agGroupCellRenderer. Do not use in colDef.cellRendererParams - see IGroupCellRendererParams instead.

type GroupCheckboxSelectionCallback

type GroupCheckboxSelectionCallback<TData = any, TValue = any> = (
    params: GroupCheckboxSelectionCallbackParams<TData, TValue>
) => boolean;

type GroupCheckboxSelectionCallbackParams

type GroupCheckboxSelectionCallbackParams<
    TData = any,
    TValue = any
> = ColumnFunctionCallbackParams<TData> & GroupCellRendererParams<TData, TValue>;

type GroupHierarchyConfig

type GroupHierarchyConfig = {
    [k: string]: ColDef;
};

type GroupHierarchyParts

type GroupHierarchyParts =
    | 'year'
    | 'quarter'
    | 'month'
    | 'formattedMonth'
    | 'day'
    | 'hour'
    | 'minute'
    | 'second';

type GroupRowEditableCallback

type GroupRowEditableCallback<TData = any, TValue = any, TContext = any> = (
    params: GroupRowEditableCallbackParams<TData, TValue, TContext>
) => boolean;

Callback that determines whether a group row cell is editable.
Returns
true to allow editing, false to prevent it.

type GroupRowValueSetterDistribution

type GroupRowValueSetterDistribution =
    | 'uniform'
    | 'percentage'
    | 'increment'
    | 'overwrite';

Strategy for distributing a group-level value edit across descendant rows.
- **'uniform'** — Divides the new value equally among all children. For sum, each child receives newValue / childCount. For avg, each child is set to newValue directly (so the average equals the edited value). - **'percentage'** — Scales each child proportionally, preserving relative weights. Falls back to 'uniform' when the current total is zero. - **'increment'** — Distributes only the difference (newValue − oldValue) among children. For sum, each child receives delta / childCount added to its current value. For avg, the full delta is added to every child. - **'overwrite'** — Writes newValue directly to every child.
Use false or null to suppress distribution entirely — no child values are modified and the cell is treated as not editable (overriding groupRowEditable).
Example 1
// Assign a strategy directly on the column definition colDef.groupRowValueSetter = { distribution: 'percentage' };

type GroupRowValueSetterDistributionEntry

type GroupRowValueSetterDistributionEntry<
    TData = any,
    TValue = any,
    TContext = any
> =
    | GroupRowValueSetterDistribution
    | GroupRowValueSetterDistributionOptions
    | GroupRowValueSetterFunc<TData, TValue, TContext>
    | boolean
    | null
    | undefined;

A value in the distribution record. Can be: - A GroupRowValueSetterDistribution strategy string (e.g. 'percentage'). - true — uses the built-in default for the aggFunc. Enables custom aggFuncs with 'overwrite'. Note: count/min/max/first/last are only enabled via explicit per-aggFunc record entries. Useful for overriding false/null from a parent in deep-merge scenarios. - false or null — suppresses distribution for this aggFunc and makes the cell not editable when that aggFunc is active. - undefined — inherits from the parent options (falls through to the default for that aggFunc). - A GroupRowValueSetterDistributionOptions object with strategy and per-aggFunc overrides. - A custom GroupRowValueSetterFunc callback for full control.
Example 1
distribution: { sum: 'percentage', // strategy string avg: { distribution: 'increment', precision: 0 }, // options object count: true, // enable with built-in default min: false, // suppress myCustomAgg: (params) => { ... }, // custom callback }

type GroupRowValueSetterDistributionRecord

type GroupRowValueSetterDistributionRecord<
    TData = any,
    TValue = any,
    TContext = any
> = Record<string, GroupRowValueSetterDistributionEntry<TData, TValue, TContext>>;

Maps aggregation function names (e.g. 'sum', 'avg', or a custom name) to distribution entries. Each entry can be a strategy string, an options object, a custom callback function, or false/null to suppress distribution for that aggFunc. Unmatched aggFuncs fall through to default, then to the built-in defaults.
Example 1
colDef.groupRowValueSetter = { distribution: { sum: 'percentage', avg: { distribution: 'increment' }, myCustomAgg: (params) => { ... }, count: false, }, };

type GroupRowValueSetterFunc

type GroupRowValueSetterFunc<TData = any, TValue = any, TContext = any> = (
    params: GroupRowValueSetterParams<TData, TValue, TContext>
) => void | boolean | undefined;

Custom callback for distributing a group row value edit to descendant rows.

Returns

true if at least one child value was changed, false otherwise. Returning void or undefined is treated as true.

Example 1

// Custom: set all children to the edited value
colDef.groupRowValueSetter = (params) => {
    let changed = false;
    for (const child of params.aggregatedChildren) {
        if (child.setDataValue(params.column, params.newValue, 'data')) {
            changed = true;
        }
    }
    return changed;
};

Example 2

// Use the built-in distributeGroupValue with custom options
import { distributeGroupValue } from 'ag-grid-enterprise';

colDef.groupRowValueSetter = (params) =>
    distributeGroupValue(params, { distribution: 'percentage' });

type GroupSelectionMode

type GroupSelectionMode = 'self' | 'descendants' | 'filteredDescendants';

Determines the behaviour when selecting a group row.
- When 'self', selects only the group row itself. - When 'descendants', selecting a group row selects all its child rows. - When 'filteredDescendants', selecting a group row selects all child rows that satisfy the currently active filter.

type HeaderCheckboxSelectionCallback

type HeaderCheckboxSelectionCallback<TData = any, TValue = any, TContext = any> = (
    params: HeaderCheckboxSelectionCallbackParams<TData, TValue, TContext>
) => boolean;

type HeaderClass

type HeaderClass<TData = any, TValue = any, TContext = any> =
    | string
    | string[]
    | ((
          params: HeaderClassParams<TData, TValue, TContext>
      ) => string | string[] | undefined);

type HeaderLocation

type HeaderLocation =
    | 'chart'
    | 'columnDrop'
    | 'columnToolPanel'
    | 'csv'
    | 'filterToolPanel'
    | 'groupFilter'
    | 'header'
    | 'model'
    | 'advancedFilter'
    | null;

type HeaderRowType

type HeaderRowType = 'group' | 'column' | 'filter';

type HeaderStyleFunc

type HeaderStyleFunc<TData = any, TValue = any, TContext = any> = (
    headerClassParams: HeaderClassParams<TData, TValue, TContext>
) => HeaderStyle | null | undefined;

type HeaderTooltipValueGetterFunc

type HeaderTooltipValueGetterFunc<TData = any, TValue = any, TContext = any> = (
    params: ITooltipParams<TData, TValue, TContext>
) => string | any;

type HeaderValueGetterFunc

type HeaderValueGetterFunc<TData = any, TValue = any, TContext = any> = (
    params: HeaderValueGetterParams<TData, TValue, TContext>
) => string;

type IAggFunc

type IAggFunc<TData = any, TValue = any, TContext = any> = (
    params: IAggFuncParams<TData, TValue, TContext>
) => any;

type IAggFuncs

type IAggFuncs<TData = any, TValue = any, TContext = any> = {
    [key: string]: IAggFunc<TData, TValue, TContext>;
};

type ICellRendererFunc

type ICellRendererFunc<TData = any> = (
    params: ICellRendererParams<TData>
) => HTMLElement | string;

type IconName

type IconName =
    | 'columnGroupOpened'
    | 'columnGroupClosed'
    | 'columnSelectClosed'
    | 'columnSelectOpen'
    | 'columnSelectIndeterminate'
    | 'accordionClosed'
    | 'accordionOpen'
    | 'accordionIndeterminate'
    | 'columnMovePin'
    | 'columnMoveHide'
    | 'columnMoveMove'
    | 'columnMoveLeft'
    | 'columnMoveRight'
    | 'columnMoveGroup'
    | 'columnMoveValue'
    | 'columnMovePivot'
    | 'dropNotAllowed'
    | 'groupContracted'
    | 'groupExpanded'
    | 'setFilterGroupClosed'
    | 'setFilterGroupOpen'
    | 'setFilterGroupIndeterminate'
    | 'setFilterLoading'
    | 'chart'
    | 'close'
    | 'cancel'
    | 'check'
    | 'first'
    | 'previous'
    | 'next'
    | 'last'
    | 'linked'
    | 'unlinked'
    | 'colorPicker'
    | 'groupLoading'
    | 'overlayLoading'
    | 'overlayExporting'
    | 'menu'
    | 'legacyMenu'
    | 'loadingMenuItems'
    | 'menuAlt'
    | 'filter'
    | 'filterActive'
    | 'filterAdd'
    | 'filterCardExpand'
    | 'filterCardCollapse'
    | 'filterCardEditing'
    | 'filterTab'
    | 'filtersToolPanel'
    | 'columns'
    | 'columnsToolPanel'
    | 'maximize'
    | 'minimize'
    | 'menuPin'
    | 'menuValue'
    | 'menuAddRowGroup'
    | 'menuRemoveRowGroup'
    | 'clipboardCopy'
    | 'clipboardCut'
    | 'clipboardPaste'
    | 'pivotPanel'
    | 'rowGroupPanel'
    | 'valuePanel'
    | 'columnDrag'
    | 'rowDrag'
    | 'rowPin'
    | 'rowPinTop'
    | 'rowPinBottom'
    | 'rowUnpin'
    | 'save'
    | 'csvExport'
    | 'excelExport'
    | 'smallDown'
    | 'selectOpen'
    | 'richSelectOpen'
    | 'richSelectRemove'
    | 'richSelectLoading'
    | 'smallLeft'
    | 'smallRight'
    | 'panelDelimiter'
    | 'panelDelimiterRtl'
    | 'subMenuOpen'
    | 'subMenuOpenRtl'
    | 'smallUp'
    | 'sortAscending'
    | 'sortDescending'
    | 'sortAbsoluteAscending'
    | 'sortAbsoluteDescending'
    | 'sortUnSort'
    | 'advancedFilterBuilder'
    | 'advancedFilterBuilderDrag'
    | 'advancedFilterBuilderInvalid'
    | 'advancedFilterBuilderMoveUp'
    | 'advancedFilterBuilderMoveDown'
    | 'advancedFilterBuilderAdd'
    | 'advancedFilterBuilderRemove'
    | 'advancedFilterBuilderSelectOpen'
    | 'chartsMenu'
    | 'chartsMenuEdit'
    | 'chartsMenuAdvancedSettings'
    | 'chartsMenuAdd'
    | 'chartsColorPicker'
    | 'chartsThemePrevious'
    | 'chartsThemeNext'
    | 'chartsDownload'
    | 'ensureColumnVisible'
    | 'checkboxChecked'
    | 'checkboxIndeterminate'
    | 'checkboxUnchecked'
    | 'radioButtonOn'
    | 'radioButtonOff'
    | 'search';

type Icons

type Icons = {
    [key: string]: ((...args: any[]) => any) | string;
};

type IDateComparatorFunc

type IDateComparatorFunc = (
    filterLocalDateAtMidnight: Date,
    cellValue: any
) => number;

type IEventListener

type IEventListener<TEventType extends string> = (
    params: AgEvent<TEventType>
) => void;

type IFilterType

type IFilterType = string | (new () => IFilterComp) | boolean;

type IFloatingFilterParentCallback

type IFloatingFilterParentCallback<P = InbuiltParentType> = (
    parentFilterInstance: P
) => void;

type IFloatingFilterType

type IFloatingFilterType = string | (new () => IFloatingFilterComp);

type ILoadingCellRendererSelectorFunc

type ILoadingCellRendererSelectorFunc<TData = any, TValue = any, TContext = any> = (
    params: ILoadingCellRendererParams<TData, TValue, TContext>
) => CellRendererSelectorResult | undefined;

type ImageValue

type ImageValue =
    | string
    | {
          /**
           * The URL of an image. data: URLs can be used embed assets.
           */
          url: string;
      }
    | {
          /**
           * The XML text of an SVG file
           */
          svg: string;
      }
    | {
          ref: string;
      };

A CSS image value e.g. "url(...image-url...)". Alternatively:
- {svg: "...XML source of SVG image..."} -> embed an SVG as a data: uri - {url: "https://..."} -> a URL to load an image asset from. Can be a HTTPS URL, or image assets such as PNGs can be converted to data: URLs - {ref: "foo"} -> use the same value as the foo param (ref must be a valid param name)
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/image

type InitialGroupOrderComparator

type InitialGroupOrderComparator<TData = any, TContext = any> = (
    params: InitialGroupOrderComparatorParams<TData, TContext>
) => number;

type InputStyleParams

type InputStyleParams = {
    /**
     * Background color for text inputs
     */
    inputBackgroundColor: ColorValue;
    /**
     * Border around text inputs (or underneath, if using the underlined input style)
     */
    inputBorder: BorderValue;
    /**
     * Corner radius of text inputs
     */
    inputBorderRadius: LengthValue;
    /**
     * Background color for disabled text inputs
     */
    inputDisabledBackgroundColor: ColorValue;
    /**
     * Border around disabled text inputs (or underneath, if using the underlined input style)
     */
    inputDisabledBorder: BorderValue;
    /**
     * Color of text within disabled text inputs
     */
    inputDisabledTextColor: ColorValue;
    /**
     * Background color for focussed text inputs
     */
    inputFocusBackgroundColor: ColorValue;
    /**
     * Border around focussed text inputs (or underneath, if using the underlined input style)
     */
    inputFocusBorder: BorderValue;
    /**
     * Shadow around focussed text inputs
     */
    inputFocusShadow: ShadowValue;
    /**
     * Color of text within focussed text inputs
     */
    inputFocusTextColor: ColorValue;
    /**
     * Minimum height of text inputs
     */
    inputHeight: LengthValue;
    /**
     * Background color for text inputs in an invalid state
     */
    inputInvalidBackgroundColor: ColorValue;
    /**
     * Border around text inputs in an invalid state (or underneath, if using the underlined input style)
     */
    inputInvalidBorder: BorderValue;
    /**
     * Color of text within text inputs in an invalid state
     */
    inputInvalidTextColor: ColorValue;
    /**
     * Padding at the start of text in text inputs
     */
    inputPaddingStart: LengthValue;
    /**
     * Color of text within text inputs
     */
    inputTextColor: ColorValue;
    /**
     * Color of placeholder text in empty inputs describing the purpose of the input e.g. "Search..."
     */
    inputPlaceholderTextColor: ColorValue;
    /**
     * Color of search icon within search text inputs
     */
    inputIconColor: ColorValue;
    /**
     * Border around buttons with attached dropdown menus (e.g. select fields)
     */
    pickerButtonBorder: BorderValue;
    /**
     * Border around buttons with attached dropdown menus (e.g. select fields) when focussed
     */
    pickerButtonFocusBorder: BorderValue;
    /**
     * Background color for buttons with attached dropdown menus (e.g. select fields)
     */
    pickerButtonBackgroundColor: ColorValue;
    /**
     * Background color for buttons with attached dropdown menus (e.g. select fields) when focussed
     */
    pickerButtonFocusBackgroundColor: ColorValue;
    /**
     * Border around dropdown menus attached to buttons (e.g. select fields)
     */
    pickerListBorder: BorderValue;
    /**
     * Background color for dropdown menus attached to buttons (e.g. select fields)
     */
    pickerListBackgroundColor: ColorValue;
    /**
     * Size of thumb (the draggable item) in color picker popup
     */
    colorPickerThumbSize: LengthValue;
    /**
     * Size of track in color picker popup
     */
    colorPickerTrackSize: LengthValue;
    /**
     * Border width of thumb (the draggable item) in color picker popup
     */
    colorPickerThumbBorderWidth: LengthValue;
    /**
     * Border radius of track in color picker popup
     */
    colorPickerTrackBorderRadius: LengthValue;
    /**
     * Border radius of selected/recent colors in color picker
     */
    colorPickerColorBorderRadius: LengthValue;
};

type IOverlayParams

type IOverlayParams<TData = any, TContext = any> =
    | ILoadingOverlayParams<TData, TContext>
    | IExportingOverlayParams<TData, TContext>
    | INoRowsOverlayParams<TData, TContext>
    | INoMatchingRowsOverlayParams<TData, TContext>;

type IsApplyServerSideTransaction

type IsApplyServerSideTransaction<TData = any, TContext = any> = (
    params: IsApplyServerSideTransactionParams<TData, TContext>
) => boolean;

type IsExternalFilterPresent

type IsExternalFilterPresent<TData = any, TContext = any> = (
    params: IsExternalFilterPresentParams<TData, TContext>
) => boolean;

type IsFullWidthRow

type IsFullWidthRow<TData = any, TContext = any> = (
    params: IsFullWidthRowParams<TData, TContext>
) => boolean;

type IsGroupOpenByDefault

type IsGroupOpenByDefault<TData = any, TContext = any> = (
    params: IsGroupOpenByDefaultParams<TData, TContext>
) => boolean;

type ISimpleFilterModelType

type ISimpleFilterModelType =
    | 'empty'
    | 'equals'
    | 'notEqual'
    | 'lessThan'
    | 'lessThanOrEqual'
    | 'greaterThan'
    | 'greaterThanOrEqual'
    | 'inRange'
    | 'contains'
    | 'notContains'
    | 'startsWith'
    | 'endsWith'
    | 'blank'
    | 'notBlank'
    | ISimpleFilterModelPresetType;

type IsRowFilterable

type IsRowFilterable<TData = any, TContext = any> = (
    params: GetGroupAggFilteringParams<TData, TContext>
) => boolean;

type IsRowMaster

type IsRowMaster<TData = any> = (dataItem: TData) => boolean;

type IsRowPinnable

type IsRowPinnable<TData = any> = (node: IRowNode<TData>) => boolean;

type IsRowPinned

type IsRowPinned<TData = any> = (node: IRowNode<TData>) => RowPinnedType;

type IsRowSelectable

type IsRowSelectable<TData = any> = (node: IRowNode<TData>) => boolean;

type IsRowValidDropPositionCallback

type IsRowValidDropPositionCallback<TData = any, TContext = any> = (
    params: IsRowValidDropPositionParams<TData, TContext>
) => IsRowValidDropPositionResult<TData> | null | boolean;

type IsServerSideGroup

type IsServerSideGroup = (dataItem: any) => boolean;

type IsServerSideGroupOpenByDefault

type IsServerSideGroupOpenByDefault<TData = any, TContext = any> = (
    params: IsServerSideGroupOpenByDefaultParams<TData, TContext>
) => boolean;

type JoinOperator

type JoinOperator = 'AND' | 'OR';

type KeyCreatorFunc

type KeyCreatorFunc<TData = any, TValue = any, TContext = any> = (
    params: KeyCreatorParams<TData, TValue, TContext>
) => string;

type LengthValue

type LengthValue =
    | number
    | string
    | {
          /**
           * An expression that can include param names and maths, e.g.
           * "spacing * 2". NOTE: In CSS the `-` character is valid in variable
           * names, so leave a space around it.
           */
          calc: string;
      }
    | {
          ref: string;
      };

A CSS dimension value with length units, e.g. "1px" or "2em". Alternatively:
- 4 -> "4px" (a plain JavaScript number will be given pixel units) - {ref: "foo"} -> use the same value as the foo param (ref must be a valid param name) - {calc: "foo + bar * 2"} -> Use a dynamically calculated expression. You can use param names like spacing and fontSize in the expression, as well as built-in CSS math functions like min(spacing, fontSize)

type LoadingCellRendererSelectorFunc

type LoadingCellRendererSelectorFunc<TData = any, TValue = any, TContext = any> = (
    params: ILoadingCellRendererParams<TData, TValue, TContext>
) => LoadingCellRendererSelectorResult | undefined;

type LocaleText

type LocaleText = {
    [key: string]: string;
};

Map of locale key to localized value

type ManagedGridOptionKey

type ManagedGridOptionKey = Exclude<keyof GridOptions, InitialGridOptionKey>;

type ManagedGridOptions

type ManagedGridOptions<TData = any> = {
    [K in ManagedGridOptionKey]?: GridOptions<TData>[K];
};

type MasterSelectionMode

type MasterSelectionMode = NonNullable<CommonRowSelectionOptions['masterSelects']>;

type MultiFilterParams

type MultiFilterParams<TData = any> = IMultiFilterParams & IFilterParams<TData>;

Parameters provided by the grid to the init method of a MultiFilter. Do not use in colDef.filterParams - see IMultiFilterParams instead.

type NavigateToNextCell

type NavigateToNextCell<TData = any, TContext = any> = (
    params: NavigateToNextCellParams<TData, TContext>
) => CellPosition | null;

type NavigateToNextHeader

type NavigateToNextHeader<TData = any, TContext = any> = (
    params: NavigateToNextHeaderParams<TData, TContext>
) => HeaderPosition | null;

type NestedFieldPaths

type NestedFieldPaths<TData = any, TValue = any, TDepth extends any[] = []> = {
    [TKey in StringOrNumKeys<TData>]: TData[TKey] extends
        | ((...args: any[]) => any)
        | undefined
        ? never
        : TData[TKey] extends any[] | undefined
        ? (TData[TKey] extends TValue ? `${TKey}` : never) | `${TKey}.${number}`
        :
              | (TData[TKey] extends TValue ? `${TKey}` : never)
              | NestedPath<TData[TKey], `${TKey}`, TValue, [...TDepth, any]>;
}[StringOrNumKeys<TData>];

Returns a union of all possible paths to nested fields in TData.

type NotesDataSourceGetNoteParams

type NotesDataSourceGetNoteParams = NotesDataSourceNoteParams;

type NumberFilterParams

type NumberFilterParams<TData = any> = INumberFilterParams & IFilterParams<TData>;

Parameters provided by the grid to the init method of a NumberFilter. Do not use in colDef.filterParams - see INumberFilterParams instead.

type OverlaySelectorFunc

type OverlaySelectorFunc<TData = any, TContext = any> = (
    params: IOverlayParams<TData, TContext>
) => OverlaySelectorResult | undefined;

type OverlayType

type OverlayType = 'loading' | 'noRows' | 'noMatchingRows' | 'exporting';

type PackageFileParams

type PackageFileParams<T> = T & {
    data: string[];
};

type PaginationNumberFormatter

type PaginationNumberFormatter<TData = any, TContext = any> = (
    params: PaginationNumberFormatterParams<TData, TContext>
) => string;

type PaginationPanel

type PaginationPanel = 'pageSize' | 'rowSummary' | 'pageSummary';

type Part

type Part<TParams = unknown> = {
    readonly feature?: string;
    readonly modeParams: Record<string, TParams>;
    readonly css?: string | (() => string);
};

A collection of CSS styles and default parameter values that can be added to a theme. Parts are created with the createPart helper function.

type PartialCellRange

type PartialCellRange = Omit<CellRange, 'startColumn'> &
    Partial<Pick<CellRange, 'startColumn'>>;

type PivotColumnGroupTotals

type PivotColumnGroupTotals = 'before' | 'after';

type PivotComparatorFunc

type PivotComparatorFunc = (valueA: string, valueB: string) => number;

type PivotRowTotals

type PivotRowTotals = 'before' | 'after';

type PostProcessPopup

type PostProcessPopup<TData = any, TContext = any> = (
    params: PostProcessPopupParams<TData, TContext>
) => void;

type PostSortRows

type PostSortRows<TData = any, TContext = any> = (
    params: PostSortRowsParams<TData, TContext>
) => void;

type ProcessCellForClipboard

type ProcessCellForClipboard<TData = any, TContext = any> = (
    params: ProcessCellForExportParams<TData, TContext>
) => any;

type ProcessCellFromClipboard

type ProcessCellFromClipboard<TData = any, TContext = any> = (
    params: ProcessCellForExportParams<TData, TContext>
) => any;

type ProcessDataFromClipboard

type ProcessDataFromClipboard<TData = any, TContext = any> = (
    params: ProcessDataFromClipboardParams<TData, TContext>
) => string[][] | null;

type ProcessGroupHeaderForClipboard

type ProcessGroupHeaderForClipboard<TData = any, TContext = any> = (
    params: ProcessGroupHeaderForExportParams<TData, TContext>
) => any;

type ProcessHeaderForClipboard

type ProcessHeaderForClipboard<TData = any, TContext = any> = (
    params: ProcessHeaderForExportParams<TData, TContext>
) => any;

type ProcessPivotResultColDef

type ProcessPivotResultColDef<TData = any, TValue = any> = (
    colDef: ColDef<TData, TValue>
) => void;

type ProcessPivotResultColGroupDef

type ProcessPivotResultColGroupDef<TData = any> = (
    colDef: ColGroupDef<TData>
) => void;

type ProcessRowPostCreate

type ProcessRowPostCreate<TData = any, TContext = any> = (
    params: ProcessRowParams<TData, TContext>
) => void;

type ProcessUnpinnedColumns

type ProcessUnpinnedColumns<TData = any, TContext = any> = (
    params: ProcessUnpinnedColumnsParams<TData, TContext>
) => Column[];

type PropertyChangedEvent

type PropertyChangedEvent = AgPropertyChangedEvent<GridOptionsWithDefaults>;

type PropertyValueChangedEvent

type PropertyValueChangedEvent<K extends keyof GridOptions> =
    AgPropertyValueChangedEvent<GridOptionsWithDefaults, K>;

type ProvidedFilterParams

type ProvidedFilterParams<TData = any> = IProvidedFilterParams &
    IFilterParams<TData>;

Parameters provided by the grid to the init method of a ProvidedFilter. Do not use in colDef.filterParams - see IProvidedFilterParams instead.

type QuickFilterMatcher

type QuickFilterMatcher = (
    quickFilterParts: string[],
    rowQuickFilterAggregateText: string
) => boolean;

type QuickFilterParser

type QuickFilterParser = (quickFilter: string) => string[];

type RefData

type RefData = {
    [p: string]: any;
};

type RichCellEditorValuesCallback

type RichCellEditorValuesCallback<TData = any, TValue = any> = (
    params: RichCellEditorValuesCallbackParams<TData, TValue>
) => TValue[] | Promise<TValue[]>;

type RichCellEditorValuesPageCallback

type RichCellEditorValuesPageCallback<TData = any, TValue = any> = (
    params: RichCellEditorValuesPageParams<TData, TValue>
) =>
    | RichCellEditorValuesPageResult<TValue>
    | Promise<RichCellEditorValuesPageResult<TValue>>;

type RichCellEditorValuesPageStartRowCallback

type RichCellEditorValuesPageStartRowCallback<TValue = any> = (
    value: TValue[] | TValue | null | undefined
) => number;

type RowDragCallback

type RowDragCallback<TData = any, TValue = any, TContext = any> = (
    params: RowDragCallbackParams<TData, TValue, TContext>
) => boolean;

type RowDragEventType

type RowDragEventType =
    | 'rowDragEnter'
    | 'rowDragLeave'
    | 'rowDragMove'
    | 'rowDragEnd'
    | 'rowDragCancel';

type RowDragTextFunc

type RowDragTextFunc = (params: IRowDragItem, dragItemCount: number) => string;

type RowDropTargetPosition

type RowDropTargetPosition = 'above' | 'inside' | 'below' | 'none';

type RowGroupingDisplayType

type RowGroupingDisplayType =
    | 'singleColumn'
    | 'multipleColumns'
    | 'groupRows'
    | 'custom';

type RowModelType

type RowModelType = 'infinite' | 'viewport' | 'clientSide' | 'serverSide';

type RowPinnedType

type RowPinnedType = 'top' | 'bottom' | null | undefined;

type RowSelectionMode

type RowSelectionMode = RowSelectionOptions['mode'];

type RowSelectionOptions

type RowSelectionOptions<TData = any, TValue = any, TContext = any> =
    | SingleRowSelectionOptions<TData, TValue, TContext>
    | MultiRowSelectionOptions<TData, TValue, TContext>;

type RowSpanFunc

type RowSpanFunc<TData = any, TValue = any, TContext = any> = (
    params: RowSpanParams<TData, TValue, TContext>
) => number;

type ScalarAdvancedFilterModelType

type ScalarAdvancedFilterModelType =
    | 'equals'
    | 'notEqual'
    | 'lessThan'
    | 'lessThanOrEqual'
    | 'greaterThan'
    | 'greaterThanOrEqual'
    | 'blank'
    | 'notBlank';

type ScalarFilterParams

type ScalarFilterParams<TData = any> = IScalarFilterParams & IFilterParams<TData>;

Deprecated
v34 Internal only. Use IScalarFilterParams

type ScaleValue

type ScaleValue =
    | number
    | {
          ref: 'string';
      };

A number without units.

type ScrollDirection

type ScrollDirection = 'horizontal' | 'vertical';

type SelectAllMode

type SelectAllMode = 'all' | 'filtered' | 'currentPage';

Determines how "select all" behaviour works.
- When 'all', selects all rows, regardless of filter and pagination settings. - When 'filtered', selects all rows that satisfy the currently active filter. - When 'currentPage', selects all rows that satisfy the currently active filter on the current page.

type SelectionColumnDef

type SelectionColumnDef = Pick<
    ColDef,
    | 'icons'
    | 'suppressNavigable'
    | 'suppressKeyboardEvent'
    | 'contextMenuItems'
    | 'context'
    | 'comparator'
    | 'onCellClicked'
    | 'onCellContextMenu'
    | 'onCellDoubleClicked'
    | 'onCellValueChanged'
    | 'headerTooltip'
    | 'headerTooltipValueGetter'
    | 'headerStyle'
    | 'headerClass'
    | 'headerComponent'
    | 'headerComponentParams'
    | 'headerName'
    | 'headerValueGetter'
    | 'mainMenuItems'
    | 'suppressHeaderContextMenu'
    | 'suppressHeaderMenuButton'
    | 'suppressHeaderKeyboardEvent'
    | 'pinned'
    | 'lockPinned'
    | 'lockPosition'
    | 'initialPinned'
    | 'cellAriaRole'
    | 'cellStyle'
    | 'cellClass'
    | 'cellClassRules'
    | 'cellRenderer'
    | 'cellRendererParams'
    | 'cellRendererSelector'
    | 'rowDrag'
    | 'rowDragText'
    | 'dndSource'
    | 'dndSourceOnRowDrag'
    | 'sortable'
    | 'sort'
    | 'initialSort'
    | 'sortIndex'
    | 'initialSortIndex'
    | 'sortingOrder'
    | 'unSortIcon'
    | 'tooltipField'
    | 'tooltipValueGetter'
    | 'tooltipComponent'
    | 'tooltipComponentParams'
    | 'tooltipComponentSelector'
    | 'width'
    | 'initialWidth'
    | 'maxWidth'
    | 'minWidth'
    | 'flex'
    | 'initialFlex'
    | 'resizable'
    | 'suppressSizeToFit'
    | 'suppressAutoSize'
    | 'suppressMovable'
>;

Subset of ColDef allowing for customisation of the Selection column, currently used for checkbox selection

type SelectionEventSourceType

type SelectionEventSourceType =
    | 'api'
    | 'apiSelectAll'
    | 'apiSelectAllFiltered'
    | 'apiSelectAllCurrentPage'
    | 'checkboxSelected'
    | 'rowClicked'
    | 'rowDataChanged'
    | 'rowGroupChanged'
    | 'selectableChanged'
    | 'spaceKey'
    | 'keyboardSelectAll'
    | 'uiSelectAll'
    | 'uiSelectAllFiltered'
    | 'uiSelectAllCurrentPage'
    | 'masterDetail'
    | 'gridInitializing';

- api - from API method - apiSelectAll - from API methods selectAll/deselectAll - apiSelectAllFiltered - from API methods selectAllFiltered/deselectAllFiltered - apiSelectAllCurrentPage - from API methods selectAllOnCurrentPage/deselectAllOnCurrentPage - checkboxSelected - row selection checkbox clicked - rowClicked - row clicked when row selection enabled - rowDataChanged - row data updated which triggered selection updates - rowGroupChanged - grouping changed which updated the selection - selectableChanged- selectable status of row has changed when rowSelection.groupSelects is 'descendants' or 'filteredDescendants' - spaceKey - space key pressed on row - keyboardSelectAll - select all via keyboard shortcut (CTRL+A) - uiSelectAll - select all in header clicked - uiSelectAllFiltered - select all in header clicked when rowSelection.selectAll = 'filtered' - uiSelectAllCurrentPage - select all in header clicked when rowSelection.selectAll = 'currentPage' - masterDetail - Syncing selection state between master row and detail grid - 'gridInitializing' - set as part of initial state while the grid is initializing

type SendToClipboard

type SendToClipboard<TData = any, TContext = any> = (
    params: SendToClipboardParams<TData, TContext>
) => void;

type SeriesGroupType

type SeriesGroupType = 'grouped' | 'stacked' | 'normalized';

type SetFilterModelValue

type SetFilterModelValue = (string | null)[];

type SetFilterParams

type SetFilterParams<TData = any, V = string> = ISetFilterParams<TData, V> &
    IFilterParams<TData>;

Parameters provided by the grid to the init method of a SetFilter. Do not use in colDef.filterParams - see ISetFilterParams instead.

type SetFilterValues

type SetFilterValues<TData = any, V = string> =
    | SetFilterValuesFunc<TData, V>
    | (V | null)[];

Parameter TData
type of data row
Parameter V
type of value in the Set Filter

type SetFilterValuesFunc

type SetFilterValuesFunc<TData = any, V = string> = (
    params: SetFilterValuesFuncParams<TData, V>
) => void;

Parameter TData
type of data row
Parameter V
type of value in the Set Filter

type SetNoteParams

type SetNoteParams<TMetadata = any> = GetNoteParams & {
    /** Note to be saved. */
    note: Note<TMetadata> | undefined;
};

type ShadowValue

type ShadowValue =
    | string
    | false
    | ShadowValueParams
    | ShadowValueParams[]
    | {
          ref: string;
      };

A CSS box shadow value e.g. "10px 5px 5px red;". Alternatively an object or array of objects containing optional properties:
- offsetX -> number of pixels to move the shadow to the right, or a negative value to move left, default 0 - offsetY -> number of pixels to move the shadow downwards, or a negative value to move up, default 0 - radius -> softness of the shadow. 0 = hard edge, 10 = 10px wide blur - spread -> size of the shadow. 0 = same size as the shadow-casting element. 10 = 10px wider in all directions. - color -> color of the shadow e.g. "red". Default {ref: "foregroundColor"} - inset -> whether shadow is inset, default false
Or a reference: - {ref: "foo"} -> use the same value as the foo param (ref must be a valid param name)
See Also
- https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow

type ShadowValueParams

type ShadowValueParams = {
    /**
     * Positive values move the shadow to the right, negative values move left
     *
     * @default 0
     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
     */
    offsetX?: LengthValue;
    /**
     * Positive values move the shadow downwards, negative values move up
     *
     * @default 0
     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
     */
    offsetY?: LengthValue;
    /**
     * Softness of the shadow. 0 = hard edge, 10 = 10px wide blur.
     *
     * @default 0
     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
     */
    radius?: LengthValue;
    /**
     * Size of the shadow. 0 = same size as the shadow-casting element. 10 = 10px wider in all directions.
     *
     * @default 0
     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
     */
    spread?: LengthValue;
    /**
     * Shadow color. Can accept any value that is valid for a color parameter, e.g. 'red' or {ref: 'accentColor'}
     *
     * @default {ref: 'foregroundColor'}
     */
    color?: ColorValue;
    /**
     * Whether shadow is inset (an inner shadow instead of an outer shadow).
     *
     * @default false
     * @see https://developer.mozilla.org/en-US/docs/Web/CSS/box-shadow
     */
    inset?: boolean;
};

type SimpleFilterParams

type SimpleFilterParams<TData = any> = ISimpleFilterParams & IFilterParams<TData>;

Parameters provided by the grid to the init method of a SimpleFilter. Do not use in colDef.filterParams - see ISimpleFilterParams instead.

type SortComparatorFn

type SortComparatorFn<TData = any, TValue = any> = (
    valueA: TValue | null | undefined,
    valueB: TValue | null | undefined,
    nodeA: IRowNode<TData>,
    nodeB: IRowNode<TData>,
    isDescending: boolean
) => number;

type SortDef

type SortDef = {
    type: SortType;
    direction: SortDirection;
};

type SortDirection

type SortDirection = 'asc' | 'desc' | null;

type SortType

type SortType = 'absolute' | 'default';

type SpanRowsFunc

type SpanRowsFunc<TData = any, TValue = any, TContext = any> = (
    params: SpanRowsParams<TData, TValue, TContext>
) => boolean;

type StatusBar

type StatusBar = {
    statusPanels: StatusPanelDef[];
};

type StructuredSchemaColumnParams

type StructuredSchemaColumnParams = {
    description?: string;
    includeSetValues?: boolean;
};

type StructuredSchemaFeature

type StructuredSchemaFeature =
    | 'aggregation'
    | 'filter'
    | 'sort'
    | 'pivot'
    | 'columnVisibility'
    | 'columnSizing'
    | 'rowGroup';

type StructuredSchemaParams

type StructuredSchemaParams = {
    exclude?: StructuredSchemaFeature[];
    columns?: Record<string, StructuredSchemaColumnParams>;
};

type StyleMaterialParams

type StyleMaterialParams = {
    primaryColor: ColorValue;
};

type SuppressHeaderKeyboardEventFunc

type SuppressHeaderKeyboardEventFunc<TData = any, TValue = any, TContext = any> = (
    params: SuppressHeaderKeyboardEventParams<TData, TValue, TContext>
) => boolean;

type SuppressKeyboardEventFunc

type SuppressKeyboardEventFunc<TData = any, TValue = any, TContext = any> = (
    params: SuppressKeyboardEventParams<TData, TValue, TContext>
) => boolean;

type SuppressNavigableCallback

type SuppressNavigableCallback<TData = any, TValue = any, TContext = any> = (
    params: SuppressNavigableCallbackParams<TData, TValue, TContext>
) => boolean;

type SuppressNoteActionsCallback

type SuppressNoteActionsCallback<TData = any, TValue = any, TContext = any> = (
    params: SuppressNoteActionsCallbackParams<TData, TValue, TContext>
) => boolean;

type SuppressPasteCallback

type SuppressPasteCallback<TData = any, TValue = any, TContext = any> = (
    params: SuppressPasteCallbackParams<TData, TValue, TContext>
) => boolean;

type TabStyleParams

type TabStyleParams = {
    /**
     * Background color of tabs
     */
    tabBackgroundColor: ColorValue;
    /**
     * Background color of the container for tabs
     */
    tabBarBackgroundColor: ColorValue;
    /**
     * Border below the container for tabs
     */
    tabBarBorder: BorderValue;
    /**
     * Padding at the left and right of the container for tabs
     */
    tabBarHorizontalPadding: LengthValue;
    /**
     * Padding at the top of the container for tabs
     */
    tabBarTopPadding: LengthValue;
    /**
     * Padding at the bottom of the container for tabs
     */
    tabBottomPadding: LengthValue;
    /**
     * Padding inside the top and bottom sides of the container for tabs
     */
    tabHorizontalPadding: LengthValue;
    /**
     * Background color of tabs when hovered over
     */
    tabHoverBackgroundColor: ColorValue;
    /**
     * Color of text within tabs when hovered over
     */
    tabHoverTextColor: ColorValue;
    /**
     * Background color of selected tabs
     */
    tabSelectedBackgroundColor: ColorValue;
    /**
     * Color of the border around selected tabs
     */
    tabSelectedBorderColor: ColorValue;
    /**
     * Width of the border around selected tabs
     */
    tabSelectedBorderWidth: LengthValue;
    /**
     * Color of text within the selected tabs
     */
    tabSelectedTextColor: ColorValue;
    /**
     * Color of line drawn under selected tabs
     */
    tabSelectedUnderlineColor: ColorValue;
    /**
     * Duration in seconds of the fade in/out transition for the line drawn under selected tabs
     */
    tabSelectedUnderlineTransitionDuration: DurationValue;
    /**
     * Width of line drawn under selected tabs
     */
    tabSelectedUnderlineWidth: LengthValue;
    /**
     * Spacing between tabs
     */
    tabSpacing: LengthValue;
    /**
     * Color of text within tabs
     */
    tabTextColor: ColorValue;
    /**
     * Padding at the top of the container for tabs
     */
    tabTopPadding: LengthValue;
};

type TabToNextCell

type TabToNextCell<TData = any, TContext = any> = (
    params: TabToNextCellParams<TData, TContext>
) => CellPosition | boolean;

type TabToNextGridContainer

type TabToNextGridContainer<TData = any, TContext = any> = (
    params: TabToNextGridContainerParams<TData, TContext>
) => TabToNextGridContainerTarget | boolean | undefined;

type TabToNextGridContainerTarget

type TabToNextGridContainerTarget =
    | CellPosition
    | HeaderPosition
    | FocusableContainerName;

type TabToNextHeader

type TabToNextHeader<TData = any, TContext = any> = (
    params: TabToNextHeaderParams<TData, TContext>
) => HeaderPosition | boolean;

type TextAdvancedFilterModelType

type TextAdvancedFilterModelType =
    | 'equals'
    | 'notEqual'
    | 'contains'
    | 'notContains'
    | 'startsWith'
    | 'endsWith'
    | 'blank'
    | 'notBlank';

type TextFilterParams

type TextFilterParams<TData = any> = ITextFilterParams & IFilterParams<TData>;

Parameters provided by the grid to the init method of a TextFilter. Do not use in colDef.filterParams - see ITextFilterParams instead.

type TextFormatter

type TextFormatter = (from?: string | null) => string | null;

type TextMatcher

type TextMatcher = (params: TextMatcherParams) => boolean;

type Theme

type Theme<TParams = unknown> = {
    /**
     * Return a new theme that uses an theme part. The part will replace any
     * existing part of the same feature
     *
     * @param part a part, or a no-arg function that returns a part
     */
    withPart<TPartParams>(
        part: Part<TPartParams> | (() => Part<TPartParams>)
    ): Theme<TParams & TPartParams>;
    /**
     * Return a new theme removes any existing part with a feature.
     *
     * @param feature the name of the part to remove, e.g. 'checkboxStyle'
     */
    withoutPart(feature: string): Theme<TParams>;
    /**
     * Return a new theme with different default values for the specified
     * params.
     *
     * @param defaults an object containing params e.g. {spacing: 10}
     */
    withParams(defaults: Partial<TParams>, mode?: string): Theme<TParams>;
};

type ThemeDefaultParams

type ThemeDefaultParams = CoreParams &
    ButtonStyleParams &
    CheckboxStyleParams &
    TabStyleParams &
    InputStyleParams &
    BatchEditStyleParams &
    FormulaStyleParams &
    NoteStyleParams;

type Toolbar = {
    /** Default alignment for items in the toolbar. Defaults to `'left'`. Item-level `alignment` takes precedence. */
    alignment?: 'left' | 'right';
    /** Items to render in the toolbar. Each entry is either a shorthand string identifier or a full item definition object. */
    items: (ToolbarItemDef | ToolbarItemShorthand)[];
};

Configure the [Quick Access Toolbar](https://ag-grid.com/javascript-data-grid/toolbar/)

type ToolbarItemComponent

type ToolbarItemComponent<T> = ToolbarItemShorthand | T;

A component reference for a toolbar item. Either a shorthand string identifier, a component class (AG Grid / Angular / React class component), or a component function (React functional component).

type ToolbarItemDef

type ToolbarItemDef<TData = any, TContext = any, TParams = any, TCustom = any> =
    | ToolbarButtonItemDef<TData, TContext>
    | ToolbarBuiltInItemDef
    | ToolbarMenuBuiltInItemDef<TData, TContext>
    | ToolbarCustomItemDef<TParams, TCustom>;

A toolbar item definition. One of the following variants: - ToolbarButtonItemDef — action button shorthand (label/icon/action) - ToolbarBuiltInItemDef — reference to a built-in component or 'separator' - ToolbarMenuBuiltInItemDef — reference to the agMenuToolbarItem dropdown menu button - ToolbarCustomItemDef — reference to a custom component

type ToolbarItemShorthand

type ToolbarItemShorthand = ToolbarItemComponentName | 'separator' | (string & {});

Shorthand string identifiers that can be used in Toolbar.items or on a toolbar item's toolbarItem. Includes the provided toolbar item components and 'separator'.

type ToolPanelClass

type ToolPanelClass<TData = any, TValue = any, TContext = any> =
    | string
    | string[]
    | ((
          params: ToolPanelClassParams<TData, TValue, TContext>
      ) => string | string[] | undefined);

type TooltipLocation

type TooltipLocation =
    | 'advancedFilter'
    | 'cell'
    | 'cellEditor'
    | 'cellFormula'
    | 'columnToolPanelColumn'
    | 'columnToolPanelColumnGroup'
    | 'filterToolPanelColumnGroup'
    | 'fullWidthRow'
    | 'fullRowEditor'
    | 'header'
    | 'headerGroup'
    | 'menu'
    | 'pivotColumnsList'
    | 'rowGroupColumnsList'
    | 'setFilterValue'
    | 'valueColumnsList'
    | 'UNKNOWN';

type TooltipValueGetterFunc

type TooltipValueGetterFunc<TData = any, TValue = any, TContext = any> = (
    params: ITooltipParams<TData, TValue, TContext>
) => string | any;

type TotalValueGetterFunc

type TotalValueGetterFunc<TData = any, TValue = any> = (
    params: GroupCellRendererParams<TData, TValue>
) => any;

type TouchListenerEvent

type TouchListenerEvent = 'tap' | 'doubleTap' | 'longTap';

type TreeDataDisplayType

type TreeDataDisplayType = 'auto' | 'custom';

type UpdateChartParams

type UpdateChartParams =
    | UpdateRangeChartParams
    | UpdatePivotChartParams
    | UpdateCrossFilterChartParams;

type UseGroupFooter

type UseGroupFooter<TData = any, TContext = any> = (
    params: GetGroupIncludeFooterParams<TData, TContext>
) => boolean;

type UseGroupTotalRow

type UseGroupTotalRow<TData = any, TContext = any> = (
    params: GetGroupIncludeTotalRowParams<TData, TContext>
) => 'top' | 'bottom' | undefined;

type ValueFormatterFunc

type ValueFormatterFunc<TData = any, TValue = any, TContext = any> = (
    params: ValueFormatterParams<TData, TValue, TContext>
) => string;

type ValueFormatterLiteFunc

type ValueFormatterLiteFunc<TData, TValue, TContext = any> = (
    params: ValueFormatterLiteParams<TData, TValue, TContext>
) => string;

type ValueFormatterLiteParams

type ValueFormatterLiteParams<TData, TValue, TContext = any> = Omit<
    ValueFormatterParams<TData, TValue, TContext>,
    'data' | 'node'
>;

type ValueGetterFunc

type ValueGetterFunc<TData = any, TValue = any, TContext = any> = (
    params: ValueGetterParams<TData, TValue, TContext>
) => TValue | null | undefined;

type ValueParserFunc

type ValueParserFunc<TData = any, TValue = any, TContext = any> = (
    params: ValueParserParams<TData, TValue, TContext>
) => TValue | null | undefined;

type ValueParserLiteFunc

type ValueParserLiteFunc<TData, TValue, TContext = any> = (
    params: ValueParserLiteParams<TData, TValue, TContext>
) => TValue | null | undefined;

type ValueParserLiteParams

type ValueParserLiteParams<TData, TValue, TContext = any> = Omit<
    ValueParserParams<TData, TValue, TContext>,
    'data' | 'node' | 'oldValue'
>;

type ValueSetterFunc

type ValueSetterFunc<TData = any, TValue = any, TContext = any> = (
    params: ValueSetterParams<TData, TValue, TContext>
) => boolean;

type WithoutGridCommon

type WithoutGridCommon<T> = Omit<T, keyof AgGridCommon<any, any>>;

Enables types safe create of the given type without the need to set the common grid properties that will be merged with the object in a centralised location.

type WithParamTypes

type WithParamTypes<T> = {
    [K in keyof T]: K extends string
        ? ParamTypeForLowercaseKey<Lowercase<K>>
        : LengthValue;
};

Namespaces

namespace *.css

module '*.css' {}

variable css

const css: string;

Package Files (199)

Dependencies (1)

ag-charts-types

Dev Dependencies (4)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ag-grid-community.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ag-grid-community)

HTML

<a href="https://www.jsdocs.io/package/ag-grid-community"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 seconds ago.
Package analyzed in 21006 ms.
Missing or incorrect documentation? Open an issue for this package.

ag-grid-community

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable agTestIdFor

variable AlignedGridsModule

variable AllCommunityModule

variable BigIntFilterModule

variable buttonStyleAlpine

variable buttonStyleBalham

variable buttonStyleBase

variable buttonStyleQuartz

variable CellApiModule

variable CellSpanModule

variable CellStyleModule

variable CheckboxEditorModule

variable checkboxStyleDefault

variable ClientSideRowModelApiModule

variable ClientSideRowModelModule

variable colorSchemeDark

variable colorSchemeDarkBlue

variable colorSchemeDarkWarm

variable colorSchemeLight

variable colorSchemeLightCold

variable colorSchemeLightWarm

variable colorSchemeVariable

variable ColumnApiModule

variable ColumnAutoSizeModule

variable columnDropStyleBordered

variable columnDropStylePlain

variable ColumnHoverModule

variable CsvExportModule

variable CustomEditorModule

variable CustomFilterModule

variable DateEditorModule

variable DateFilterModule

variable DETAIL_ROW_ID_PREFIX

variable DragAndDropModule

variable EventApiModule

variable ExternalFilterModule

variable GRAND_TOTAL_ROW_ID

variable GridStateModule

variable GROUP_AUTO_COLUMN_ID

variable GROUP_HIERARCHY_COLUMN_ID_PREFIX

variable GROUP_TOTAL_ROW_ID_PREFIX

variable HighlightChangesModule

variable iconSetAlpine

variable iconSetBalham

variable iconSetMaterial

variable iconSetQuartzBold

variable iconSetQuartzLight

variable iconSetQuartzRegular

variable InfiniteRowModelModule

variable inputStyleBase

variable inputStyleBordered

variable inputStyleUnderlined

variable KeyCode

variable LargeTextEditorModule

variable LocaleModule

variable NumberEditorModule

variable NumberFilterModule

variable PaginationModule

variable PinnedRowModule

variable QuickFilterModule

variable RenderApiModule

variable ROOT_NODE_ID

variable ROW_NUMBERS_COLUMN_ID

variable RowApiModule

variable RowAutoHeightModule

variable RowDragModule

variable RowSelectionModule

variable RowStyleModule