ag-grid-angular

  • Version 33.1.1
  • Published
  • 924 kB
  • 2 dependencies
  • MIT license

Install

npm i ag-grid-angular
yarn add ag-grid-angular
pnpm add ag-grid-angular

Overview

AG Grid Angular Component

Index

Classes

Interfaces

Classes

class AgGridAngular

class AgGridAngular<TData = any, TColDef extends ColDef<TData> = ColDef<any>>
implements AfterViewInit, OnChanges, OnDestroy {}

    constructor

    constructor(
    elementDef: ElementRef,
    _viewContainerRef: ViewContainerRef,
    _angularFrameworkOverrides: AngularFrameworkOverrides,
    _frameworkCompWrapper: AngularFrameworkComponentWrapper
    );

      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 advancedFilterBuilderParams

      advancedFilterBuilderParams: any;
      • Customise the parameters passed to the Advanced Filter Builder.

      property advancedFilterBuilderVisibleChanged

      advancedFilterBuilderVisibleChanged: EventEmitter<
      AdvancedFilterBuilderVisibleChangedEvent<TData>
      >;
      • Advanced Filter Builder visibility has changed (opened or closed).

      property advancedFilterParent

      advancedFilterParent: HTMLElement;
      • 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.

      property aggFuncs

      aggFuncs: { [key: string]: IAggFunc<TData> };
      • A map of 'function name' to 'function' for custom aggregation functions.

      property aggregateOnlyChangedColumns

      aggregateOnlyChangedColumns: boolean;
      • When using change detection, only the updated column will be re-aggregated. false

      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.

      property allowContextMenuWithControlKey

      allowContextMenuWithControlKey: boolean;
      • Allows context menu to show, even when Ctrl key is held down. false

      property allowDragFromColumnsToolPanel

      allowDragFromColumnsToolPanel: boolean;
      • Allow reordering and pinning columns by dragging columns from the Columns Tool Panel to the grid. false

      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

      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: (rowNode: IRowNode<TData>) => boolean;
      • 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.

      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 animateRows

      animateRows: boolean;
      • Set to false to disable Row Animation which is enabled by default. true

      property api

      api: GridApi<TData>;
      • Grid Api available after onGridReady event has fired.

      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

      property asyncTransactionsFlushed

      asyncTransactionsFlushed: EventEmitter<AsyncTransactionsFlushedEvent<TData>>;
      • Async transactions have been applied. Contains a list of all transaction results.

      property asyncTransactionWaitMillis

      asyncTransactionWaitMillis: number;
      • How many milliseconds to wait before executing a batch of async transactions.

      property autoGroupColumnDef

      autoGroupColumnDef: any;
      • 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.

      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: any;
      • 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.

      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.

      property bodyScroll

      bodyScroll: EventEmitter<BodyScrollEvent<TData>>;
      • The body was scrolled horizontally or vertically.

      property bodyScrollEnd

      bodyScrollEnd: EventEmitter<BodyScrollEndEvent<TData>>;
      • Main body of the grid has stopped scrolling, either horizontally or vertically.

      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

      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

      property cacheQuickFilter

      cacheQuickFilter: boolean;
      • Set to true to turn on the Quick Filter cache, used to improve performance when using the Quick Filter. false

      property cellClicked

      cellClicked: EventEmitter<CellClickedEvent<TData>>;
      • Cell is clicked.

      property cellContextMenu

      cellContextMenu: EventEmitter<CellContextMenuEvent<TData>>;
      • Cell is right clicked.

      property cellDoubleClicked

      cellDoubleClicked: EventEmitter<CellDoubleClickedEvent<TData>>;
      • Cell is double clicked.

      property cellEditingStarted

      cellEditingStarted: EventEmitter<CellEditingStartedEvent<TData>>;
      • Editing a cell has started.

      property cellEditingStopped

      cellEditingStopped: EventEmitter<CellEditingStoppedEvent<TData>>;
      • Editing a cell has stopped.

      property cellEditRequest

      cellEditRequest: EventEmitter<CellEditRequestEvent<TData>>;
      • Value has changed after editing. Only fires when readOnlyEdit=true.

      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 cellFocused

      cellFocused: EventEmitter<CellFocusedEvent<TData>>;
      • Cell is focused.

      property cellKeyDown

      cellKeyDown: EventEmitter<any>;
      • DOM event keyDown happened on a cell.

      property cellMouseDown

      cellMouseDown: EventEmitter<CellMouseDownEvent<TData>>;
      • Mouse down on cell.

      property cellMouseOut

      cellMouseOut: EventEmitter<CellMouseOutEvent<TData>>;
      • Mouse left cell.

      property cellMouseOver

      cellMouseOver: EventEmitter<CellMouseOverEvent<TData>>;
      • Mouse entered cell.

      property cellSelection

      cellSelection: any;
      • Configure cell selection

      property cellSelectionChanged

      cellSelectionChanged: EventEmitter<CellSelectionChangedEvent<TData>>;
      • A change to cell selection has occurred.

      property cellSelectionDeleteEnd

      cellSelectionDeleteEnd: EventEmitter<CellSelectionDeleteEndEvent<TData>>;
      • Cell selection delete operation (cell clear) has ended.

      property cellSelectionDeleteStart

      cellSelectionDeleteStart: EventEmitter<CellSelectionDeleteStartEvent<TData>>;
      • Cell selection delete operation (cell clear) has started.

      property cellValueChanged

      cellValueChanged: EventEmitter<CellValueChangedEvent<TData>>;
      • Value has changed after editing (this event will not fire if editing was cancelled, eg ESC was pressed) or if cell value has changed as a result of cut, paste, cell clear (pressing Delete key), fill handle, copy range down, undo and redo.

      property chartCreated

      chartCreated: EventEmitter<ChartCreatedEvent<TData>>;
      • A chart has been created.

      property chartDestroyed

      chartDestroyed: EventEmitter<ChartDestroyedEvent<TData>>;
      • A chart has been destroyed.

      property chartMenuItems

      chartMenuItems: any;
      • Get chart menu items. Only applies when using AG Charts Enterprise.

      property chartOptionsChanged

      chartOptionsChanged: EventEmitter<ChartOptionsChangedEvent<TData>>;
      • Formatting changes have been made by users through the Customize Panel.

      property chartRangeSelectionChanged

      chartRangeSelectionChanged: EventEmitter<ChartRangeSelectionChangedEvent<TData>>;
      • The data range for the chart has been changed.

      property chartThemeOverrides

      chartThemeOverrides: any;
      • Chart theme overrides applied to all themes.

      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'];

      property chartToolPanelsDef

      chartToolPanelsDef: any;
      • 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.

      property clipboardDelimiter

      clipboardDelimiter: string;
      • Specify the delimiter to use when copying to clipboard. '\t'

      property colResizeDefault

      colResizeDefault: string;
      • Set to 'shift' to have shift-resize as the default resize operation (same as user holding down Shift while resizing).

      property columnDefs

      columnDefs: any[];
      • Array of Column / Column Group definitions.

      property columnEverythingChanged

      columnEverythingChanged: EventEmitter<ColumnEverythingChangedEvent<TData>>;
      • Deprecated

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

      property columnGroupOpened

      columnGroupOpened: EventEmitter<ColumnGroupOpenedEvent<TData>>;
      • A column group was opened / closed.

      property columnHeaderClicked

      columnHeaderClicked: EventEmitter<ColumnHeaderClickedEvent<TData>>;
      • A click is performed on a column header.

      property columnHeaderContextMenu

      columnHeaderContextMenu: EventEmitter<ColumnHeaderContextMenuEvent<TData>>;
      • A context menu action, such as right-click or context menu key press, is performed on a column header.

      property columnHeaderMouseLeave

      columnHeaderMouseLeave: EventEmitter<ColumnHeaderMouseLeaveEvent<TData>>;
      • A mouse cursor is moved out of a column header.

      property columnHeaderMouseOver

      columnHeaderMouseOver: EventEmitter<ColumnHeaderMouseOverEvent<TData>>;
      • A mouse cursor is initially moved over a column header.

      property columnHoverHighlight

      columnHoverHighlight: boolean;
      • Set to true to highlight columns by adding the ag-column-hover CSS class. false

      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 columnMenuVisibleChanged

      columnMenuVisibleChanged: EventEmitter<ColumnMenuVisibleChangedEvent<TData>>;
      • The column menu visibility has changed. Fires twice if switching between tabs - once with the old tab and once with the new tab.

      property columnMoved

      columnMoved: EventEmitter<ColumnMovedEvent<TData>>;
      • A column was moved.

      property columnPinned

      columnPinned: EventEmitter<ColumnPinnedEvent<TData>>;
      • A column, or group of columns, was pinned / unpinned.

      property columnPivotChanged

      columnPivotChanged: EventEmitter<ColumnPivotChangedEvent<TData>>;
      • A pivot column was added, removed or order changed.

      property columnPivotModeChanged

      columnPivotModeChanged: EventEmitter<ColumnPivotModeChangedEvent<TData>>;
      • The pivot mode flag was changed.

      property columnResized

      columnResized: EventEmitter<ColumnResizedEvent<TData>>;
      • A column was resized.

      property columnRowGroupChanged

      columnRowGroupChanged: EventEmitter<ColumnRowGroupChangedEvent<TData>>;
      • A row group column was added, removed or reordered.

      property columnTypes

      columnTypes: { [key: string]: ColTypeDef<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 columnValueChanged

      columnValueChanged: EventEmitter<ColumnValueChangedEvent<TData>>;
      • A value column was added or removed.

      property columnVisible

      columnVisible: EventEmitter<ColumnVisibleEvent<TData>>;
      • A column, or group of columns, was hidden / shown.

      property components

      components: { [p: string]: any };
      • A map of component names to components.

      property componentStateChanged

      componentStateChanged: EventEmitter<ComponentStateChangedEvent<TData>>;
      • 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.

      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 contextMenuVisibleChanged

      contextMenuVisibleChanged: EventEmitter<ContextMenuVisibleChangedEvent<TData>>;
      • The context menu visibility has changed (opened or closed).

      property copyGroupHeadersToClipboard

      copyGroupHeadersToClipboard: boolean;
      • Set to true to also include group headers when copying to clipboard using Ctrl + C clipboard. false

      property copyHeadersToClipboard

      copyHeadersToClipboard: boolean;
      • Set to true to also include headers when copying to clipboard using Ctrl + C clipboard. false

      property createChartContainer

      createChartContainer: (params: ChartRefParams<TData>) => void;
      • Callback to enable displaying the chart in an alternative chart container.

      property customChartThemes

      customChartThemes: { [name: string]: AgChartTheme };
      • A map containing custom chart themes.

      property cutEnd

      cutEnd: EventEmitter<CutEndEvent<TData>>;
      • Cut operation has ended.

      property cutStart

      cutStart: EventEmitter<CutStartEvent<TData>>;
      • Cut operation has started.

      property datasource

      datasource: any;
      • Provide the datasource for infinite scrolling.

      property dataTypeDefinitions

      dataTypeDefinitions: { [cellDataType: string]: DataTypeDefinition<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' 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. false

      property defaultColDef

      defaultColDef: any;
      • A default column definition. Items defined in the actual column definitions get precedence.

      property defaultColGroupDef

      defaultColGroupDef: any;
      • 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: any;
      • A default configuration object used to export to CSV.

      property defaultExcelExportParams

      defaultExcelExportParams: any;
      • A default configuration object used to export to Excel.

      property deltaSort

      deltaSort: boolean;
      • When enabled, sorts only the rows added/updated by a transaction. 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.

      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.

      property detailRowAutoHeight

      detailRowAutoHeight: boolean;
      • Set to true to have the detail grid dynamically change it's height to fit it's rows.

      property detailRowHeight

      detailRowHeight: number;
      • Set fixed height in pixels for each detail row.

      property displayedColumnsChanged

      displayedColumnsChanged: EventEmitter<DisplayedColumnsChangedEvent<TData>>;
      • The list of displayed columns changed. This can result from columns open / close, column move, pivot, group, etc.

      property doesExternalFilterPass

      doesExternalFilterPass: (node: IRowNode<TData>) => boolean;
      • Should return true if external filter passes, otherwise false.

      property domLayout

      domLayout: any;
      • Switch between layout options: normal, autoHeight, print. 'normal'

      property dragAndDropImageComponent

      dragAndDropImageComponent: any;
      • Provide a custom drag and drop image component.

      property dragAndDropImageComponentParams

      dragAndDropImageComponentParams: any;
      • Customise the parameters provided to the Drag and Drop Image Component.

      property dragCancelled

      dragCancelled: EventEmitter<DragCancelledEvent<TData>>;
      • 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.

      property dragStarted

      dragStarted: EventEmitter<DragStartedEvent<TData>>;
      • 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.

      property dragStopped

      dragStopped: EventEmitter<DragStoppedEvent<TData>>;
      • 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.

      property editType

      editType: string;
      • Set to 'fullRow' to enable Full Row Editing. Otherwise leave blank to edit one cell at a time.

      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

      property enableBrowserTooltips

      enableBrowserTooltips: boolean;
      • Set to true to use the browser's default tooltip instead of using the grid's Tooltip Component. false

      property enableCellEditingOnBackspace

      enableCellEditingOnBackspace: boolean;
      • Forces Cell Editing to start when backspace is pressed. This is only relevant for MacOS users.

      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

      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

      property enableFillHandle

      enableFillHandle: boolean;
      • Set to true to enable the Fill Handle. false

        Deprecated

        v32.2 Use cellSelection.handle instead

      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

      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

      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

      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

      property excelStyles

      excelStyles: ExcelStyle[];
      • A list (array) of Excel styles to be used when exporting to Excel with styles.

      property excludeChildrenWhenTreeDataFiltering

      excludeChildrenWhenTreeDataFiltering: boolean;
      • Set to true to override the default tree data filtering behaviour to instead exclude child nodes from filter results. false

      property expandOrCollapseAll

      expandOrCollapseAll: EventEmitter<ExpandOrCollapseAllEvent<TData>>;
      • Fired when calling either of the API methods expandAll() or collapseAll().

      property fillEnd

      fillEnd: EventEmitter<FillEndEvent<TData>>;
      • Fill operation has ended.

      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: (params: FillOperationParams<TData>) => any;
      • 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 fillStart

      fillStart: EventEmitter<FillStartEvent<TData>>;
      • Fill operation has started.

      property filterChanged

      filterChanged: EventEmitter<FilterChangedEvent<TData>>;
      • Filter has been modified and applied.

      property filterModified

      filterModified: EventEmitter<FilterModifiedEvent<TData>>;
      • Filter was modified but not applied. Used when filters have 'Apply' buttons.

      property filterOpened

      filterOpened: EventEmitter<FilterOpenedEvent<TData>>;
      • Filter has been opened.

      property firstDataRendered

      firstDataRendered: EventEmitter<FirstDataRenderedEvent<TData>>;
      • Fired the first time data is rendered into the grid. Use this event if you want to auto resize columns based on their contents

      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: (params: FocusGridInnerElementParams<TData>) => boolean;
      • 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 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

      property getBusinessKeyForNode

      getBusinessKeyForNode: (node: IRowNode<TData>) => string;
      • 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: any;
      • Callback to be used to customise the chart toolbar items.

      property getChildCount

      getChildCount: (dataItem: any) => number;
      • Allows setting the child count for a group row.

      property getContextMenuItems

      getContextMenuItems: any;
      • For customising the context menu.

      property getDataPath

      getDataPath: any;
      • Callback to be used when working with Tree Data when treeData = true.

      property getDocument

      getDocument: () => Document;
      • 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 getGroupRowAgg

      getGroupRowAgg: (params: GetGroupRowAggParams<TData>) => any;
      • Callback to use when you need access to more then the current column for aggregation.

      property getLocaleText

      getLocaleText: (params: GetLocaleTextParams<TData>) => string;
      • A callback for localising text within the grid.

      property getMainMenuItems

      getMainMenuItems: any;
      • For customising the main 'column header' menu.

      property getRowClass

      getRowClass: (params: RowClassParams<TData>) => string | string[] | undefined;
      • 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.

      property getRowHeight

      getRowHeight: (params: RowHeightParams<TData>) => number | undefined | null;
      • 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: any;
      • 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: (params: RowClassParams<TData>) => RowStyle | undefined;
      • 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.

      property getServerSideGroupKey

      getServerSideGroupKey: any;
      • SSRM Tree Data: Allows specifying group keys.

      property getServerSideGroupLevelParams

      getServerSideGroupLevelParams: (
      params: GetServerSideGroupLevelParamsParams
      ) => ServerSideGroupLevelParams;
      • Allows providing different params for different levels of grouping.

      property grandTotalRow

      grandTotalRow: 'top' | 'bottom';
      • 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.

      property gridColumnsChanged

      gridColumnsChanged: EventEmitter<GridColumnsChangedEvent<TData>>;
      • The list of grid columns changed.

      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 gridOptions

      gridOptions: any;
      • Provided an initial gridOptions configuration to the component. If a property is specified in both gridOptions and via component binding the component binding takes precedence.

      property gridReady

      gridReady: EventEmitter<GridReadyEvent<TData>>;
      • The grid has initialised and is ready for most api calls, but may not be fully rendered yet

      property gridSizeChanged

      gridSizeChanged: EventEmitter<GridSizeChangedEvent<TData>>;
      • The size of the grid div has changed. In other words, the grid was resized.

      property groupAggFiltering

      groupAggFiltering: any;
      • Set to determine whether filters should be applied on aggregated group values. false

      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

      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

      property groupDisplayType

      groupDisplayType: any;
      • 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.

      property groupHeaderHeight

      groupHeaderHeight: number;
      • The height in pixels for the rows containing header column groups. If not specified, it uses headerHeight.

      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

      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

      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

      property groupMaintainOrder

      groupMaintainOrder: boolean;
      • When true, preserves the current group order when sorting on non-group columns. false

      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.

      property groupRowRendererParams

      groupRowRendererParams: any;
      • Customise the parameters provided to the groupRowRenderer component.

      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

      property groupTotalRow

      groupTotalRow: any;
      • 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.

      property headerFocused

      headerFocused: EventEmitter<HeaderFocusedEvent<TData>>;
      • Header is focused.

      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 icons

      icons: { [key: string]: string | ((...args: any[]) => any) };
      • 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

      property includeHiddenColumnsInQuickFilter

      includeHiddenColumnsInQuickFilter: boolean;
      • Hidden columns are excluded from the Quick Filter by default. To include hidden columns, set to true. false

      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

      property initialGroupOrderComparator

      initialGroupOrderComparator: (
      params: InitialGroupOrderComparatorParams<TData>
      ) => number;
      • Allows default sorting of groups.

      property initialState

      initialState: any;
      • Initial state for the grid. Only read once on initialization. Can be used in conjunction with api.getState() to save and restore grid state.

      property isApplyServerSideTransaction

      isApplyServerSideTransaction: any;
      • Allows cancelling transactions.

      property isExternalFilterPresent

      isExternalFilterPresent: (
      params: IsExternalFilterPresentParams<TData>
      ) => boolean;
      • Grid calls this method to know if an external filter is present.

      property isFullWidthRow

      isFullWidthRow: (params: IsFullWidthRowParams<TData>) => boolean;
      • Tells the grid if this row should be rendered as full width.

      property isGroupOpenByDefault

      isGroupOpenByDefault: (params: IsGroupOpenByDefaultParams<TData>) => boolean;
      • (Client-side Row Model only) Allows groups to be open by default.

      property isRowMaster

      isRowMaster: any;
      • 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.

      property isRowSelectable

      isRowSelectable: any;
      • 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 isServerSideGroup

      isServerSideGroup: any;
      • SSRM Tree Data: Allows specifying which rows are expandable.

      property isServerSideGroupOpenByDefault

      isServerSideGroupOpenByDefault: (
      params: IsServerSideGroupOpenByDefaultParams
      ) => boolean;
      • Allows groups to be open by default.

      property keepDetailRows

      keepDetailRows: boolean;
      • Set to true to keep detail rows for when they are displayed again. false

      property keepDetailRowsCount

      keepDetailRowsCount: number;
      • Sets the number of details rows to keep. 10

      property loading

      loading: boolean;
      • Show or hide the loading overlay.

      property loadingCellRenderer

      loadingCellRenderer: any;
      • Provide your own loading cell renderer to use when data is loading via a DataSource. 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: any;
      • Callback to select which loading cell renderer to be used when data is loading via a DataSource.

      property loadingOverlayComponent

      loadingOverlayComponent: any;
      • Provide a custom loading overlay component.

      property loadingOverlayComponentParams

      loadingOverlayComponentParams: any;
      • Customise the parameters provided to the loading overlay component.

      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: { [key: string]: string };
      • A map of key->value pairs for localising text within the grid.

      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

      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.

      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

      property modelUpdated

      modelUpdated: EventEmitter<ModelUpdatedEvent<TData>>;
      • Displayed rows have changed. Triggered after sort, filter or tree expand / collapse events.

      property modules

      modules: Module[];
      • Used to register AG Grid Modules directly with this instance of the grid. See [Providing Modules To Individual Grids](https://www.ag-grid.com/angular-data-grid/modules/#providing-modules-to-individual-grids) for more information.

      property multiSortKey

      multiSortKey: string;
      • Set to 'ctrl' to have multi sorting by clicking work using the Ctrl (or Command ⌘ for Mac) key.

      property navigateToNextCell

      navigateToNextCell: (
      params: NavigateToNextCellParams<TData>
      ) => CellPosition | null;
      • 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: (
      params: NavigateToNextHeaderParams<TData>
      ) => HeaderPosition | null;
      • 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 newColumnsLoaded

      newColumnsLoaded: EventEmitter<NewColumnsLoadedEvent<TData>>;
      • User set new columns.

      property ngAcceptInputType_accentedSort

      static ngAcceptInputType_accentedSort: {};

        property ngAcceptInputType_aggregateOnlyChangedColumns

        static ngAcceptInputType_aggregateOnlyChangedColumns: {};

          property ngAcceptInputType_allowContextMenuWithControlKey

          static ngAcceptInputType_allowContextMenuWithControlKey: {};

            property ngAcceptInputType_allowDragFromColumnsToolPanel

            static ngAcceptInputType_allowDragFromColumnsToolPanel: {};

              property ngAcceptInputType_allowShowChangeAfterFilter

              static ngAcceptInputType_allowShowChangeAfterFilter: {};

                property ngAcceptInputType_alwaysAggregateAtRootLevel

                static ngAcceptInputType_alwaysAggregateAtRootLevel: {};

                  property ngAcceptInputType_alwaysMultiSort

                  static ngAcceptInputType_alwaysMultiSort: {};

                    property ngAcceptInputType_alwaysShowHorizontalScroll

                    static ngAcceptInputType_alwaysShowHorizontalScroll: {};

                      property ngAcceptInputType_alwaysShowVerticalScroll

                      static ngAcceptInputType_alwaysShowVerticalScroll: {};

                        property ngAcceptInputType_animateRows

                        static ngAcceptInputType_animateRows: {};

                          property ngAcceptInputType_applyQuickFilterBeforePivotOrAgg

                          static ngAcceptInputType_applyQuickFilterBeforePivotOrAgg: {};

                            property ngAcceptInputType_cacheQuickFilter

                            static ngAcceptInputType_cacheQuickFilter: {};

                              property ngAcceptInputType_columnHoverHighlight

                              static ngAcceptInputType_columnHoverHighlight: {};

                                property ngAcceptInputType_copyGroupHeadersToClipboard

                                static ngAcceptInputType_copyGroupHeadersToClipboard: {};

                                  property ngAcceptInputType_copyHeadersToClipboard

                                  static ngAcceptInputType_copyHeadersToClipboard: {};

                                    property ngAcceptInputType_debounceVerticalScrollbar

                                    static ngAcceptInputType_debounceVerticalScrollbar: {};

                                      property ngAcceptInputType_debug

                                      static ngAcceptInputType_debug: {};

                                        property ngAcceptInputType_deltaSort

                                        static ngAcceptInputType_deltaSort: {};

                                          property ngAcceptInputType_detailRowAutoHeight

                                          static ngAcceptInputType_detailRowAutoHeight: {};

                                            property ngAcceptInputType_embedFullWidthRows

                                            static ngAcceptInputType_embedFullWidthRows: {};

                                              property ngAcceptInputType_enableAdvancedFilter

                                              static ngAcceptInputType_enableAdvancedFilter: {};

                                                property ngAcceptInputType_enableBrowserTooltips

                                                static ngAcceptInputType_enableBrowserTooltips: {};

                                                  property ngAcceptInputType_enableCellEditingOnBackspace

                                                  static ngAcceptInputType_enableCellEditingOnBackspace: {};

                                                    property ngAcceptInputType_enableCellExpressions

                                                    static ngAcceptInputType_enableCellExpressions: {};

                                                      property ngAcceptInputType_enableCellSpan

                                                      static ngAcceptInputType_enableCellSpan: {};

                                                        property ngAcceptInputType_enableCellTextSelection

                                                        static ngAcceptInputType_enableCellTextSelection: {};

                                                          property ngAcceptInputType_enableCharts

                                                          static ngAcceptInputType_enableCharts: {};

                                                            property ngAcceptInputType_enableFillHandle

                                                            static ngAcceptInputType_enableFillHandle: {};

                                                              property ngAcceptInputType_enableGroupEdit

                                                              static ngAcceptInputType_enableGroupEdit: {};

                                                                property ngAcceptInputType_enableRangeHandle

                                                                static ngAcceptInputType_enableRangeHandle: {};

                                                                  property ngAcceptInputType_enableRangeSelection

                                                                  static ngAcceptInputType_enableRangeSelection: {};

                                                                    property ngAcceptInputType_enableRtl

                                                                    static ngAcceptInputType_enableRtl: {};

                                                                      property ngAcceptInputType_enableStrictPivotColumnOrder

                                                                      static ngAcceptInputType_enableStrictPivotColumnOrder: {};

                                                                        property ngAcceptInputType_ensureDomOrder

                                                                        static ngAcceptInputType_ensureDomOrder: {};

                                                                          property ngAcceptInputType_enterNavigatesVertically

                                                                          static ngAcceptInputType_enterNavigatesVertically: {};

                                                                            property ngAcceptInputType_enterNavigatesVerticallyAfterEdit

                                                                            static ngAcceptInputType_enterNavigatesVerticallyAfterEdit: {};

                                                                              property ngAcceptInputType_excludeChildrenWhenTreeDataFiltering

                                                                              static ngAcceptInputType_excludeChildrenWhenTreeDataFiltering: {};

                                                                                property ngAcceptInputType_functionsReadOnly

                                                                                static ngAcceptInputType_functionsReadOnly: {};

                                                                                  property ngAcceptInputType_groupAllowUnbalanced

                                                                                  static ngAcceptInputType_groupAllowUnbalanced: {};

                                                                                    property ngAcceptInputType_groupHideOpenParents

                                                                                    static ngAcceptInputType_groupHideOpenParents: {};

                                                                                      property ngAcceptInputType_groupMaintainOrder

                                                                                      static ngAcceptInputType_groupMaintainOrder: {};

                                                                                        property ngAcceptInputType_groupRemoveLowestSingleChildren

                                                                                        static ngAcceptInputType_groupRemoveLowestSingleChildren: {};

                                                                                          property ngAcceptInputType_groupRemoveSingleChildren

                                                                                          static ngAcceptInputType_groupRemoveSingleChildren: {};

                                                                                            property ngAcceptInputType_groupSelectsChildren

                                                                                            static ngAcceptInputType_groupSelectsChildren: {};

                                                                                              property ngAcceptInputType_groupSelectsFiltered

                                                                                              static ngAcceptInputType_groupSelectsFiltered: {};

                                                                                                property ngAcceptInputType_groupSuppressBlankHeader

                                                                                                static ngAcceptInputType_groupSuppressBlankHeader: {};

                                                                                                  property ngAcceptInputType_includeHiddenColumnsInAdvancedFilter

                                                                                                  static ngAcceptInputType_includeHiddenColumnsInAdvancedFilter: {};

                                                                                                    property ngAcceptInputType_includeHiddenColumnsInQuickFilter

                                                                                                    static ngAcceptInputType_includeHiddenColumnsInQuickFilter: {};

                                                                                                      property ngAcceptInputType_keepDetailRows

                                                                                                      static ngAcceptInputType_keepDetailRows: {};

                                                                                                        property ngAcceptInputType_loading

                                                                                                        static ngAcceptInputType_loading: {};

                                                                                                          property ngAcceptInputType_loadThemeGoogleFonts

                                                                                                          static ngAcceptInputType_loadThemeGoogleFonts: {};

                                                                                                            property ngAcceptInputType_maintainColumnOrder

                                                                                                            static ngAcceptInputType_maintainColumnOrder: {};

                                                                                                              property ngAcceptInputType_masterDetail

                                                                                                              static ngAcceptInputType_masterDetail: {};

                                                                                                                property ngAcceptInputType_paginateChildRows

                                                                                                                static ngAcceptInputType_paginateChildRows: {};

                                                                                                                  property ngAcceptInputType_pagination

                                                                                                                  static ngAcceptInputType_pagination: {};

                                                                                                                    property ngAcceptInputType_paginationAutoPageSize

                                                                                                                    static ngAcceptInputType_paginationAutoPageSize: {};

                                                                                                                      property ngAcceptInputType_pivotMode

                                                                                                                      static ngAcceptInputType_pivotMode: {};

                                                                                                                        property ngAcceptInputType_pivotSuppressAutoColumn

                                                                                                                        static ngAcceptInputType_pivotSuppressAutoColumn: {};

                                                                                                                          property ngAcceptInputType_preventDefaultOnContextMenu

                                                                                                                          static ngAcceptInputType_preventDefaultOnContextMenu: {};

                                                                                                                            property ngAcceptInputType_purgeClosedRowNodes

                                                                                                                            static ngAcceptInputType_purgeClosedRowNodes: {};

                                                                                                                              property ngAcceptInputType_readOnlyEdit

                                                                                                                              static ngAcceptInputType_readOnlyEdit: {};

                                                                                                                                property ngAcceptInputType_removePivotHeaderRowWhenSingleValueColumn

                                                                                                                                static ngAcceptInputType_removePivotHeaderRowWhenSingleValueColumn: {};

                                                                                                                                  property ngAcceptInputType_resetRowDataOnUpdate

                                                                                                                                  static ngAcceptInputType_resetRowDataOnUpdate: {};

                                                                                                                                    property ngAcceptInputType_rowDragEntireRow

                                                                                                                                    static ngAcceptInputType_rowDragEntireRow: {};

                                                                                                                                      property ngAcceptInputType_rowDragManaged

                                                                                                                                      static ngAcceptInputType_rowDragManaged: {};

                                                                                                                                        property ngAcceptInputType_rowDragMultiRow

                                                                                                                                        static ngAcceptInputType_rowDragMultiRow: {};

                                                                                                                                          property ngAcceptInputType_rowGroupPanelSuppressSort

                                                                                                                                          static ngAcceptInputType_rowGroupPanelSuppressSort: {};

                                                                                                                                            property ngAcceptInputType_rowMultiSelectWithClick

                                                                                                                                            static ngAcceptInputType_rowMultiSelectWithClick: {};

                                                                                                                                              property ngAcceptInputType_serverSideEnableClientSideSort

                                                                                                                                              static ngAcceptInputType_serverSideEnableClientSideSort: {};

                                                                                                                                                property ngAcceptInputType_serverSideOnlyRefreshFilteredGroups

                                                                                                                                                static ngAcceptInputType_serverSideOnlyRefreshFilteredGroups: {};

                                                                                                                                                  property ngAcceptInputType_serverSideSortAllLevels

                                                                                                                                                  static ngAcceptInputType_serverSideSortAllLevels: {};

                                                                                                                                                    property ngAcceptInputType_showOpenedGroup

                                                                                                                                                    static ngAcceptInputType_showOpenedGroup: {};

                                                                                                                                                      property ngAcceptInputType_singleClickEdit

                                                                                                                                                      static ngAcceptInputType_singleClickEdit: {};

                                                                                                                                                        property ngAcceptInputType_skipHeaderOnAutoSize

                                                                                                                                                        static ngAcceptInputType_skipHeaderOnAutoSize: {};

                                                                                                                                                          property ngAcceptInputType_stopEditingWhenCellsLoseFocus

                                                                                                                                                          static ngAcceptInputType_stopEditingWhenCellsLoseFocus: {};

                                                                                                                                                            property ngAcceptInputType_suppressAdvancedFilterEval

                                                                                                                                                            static ngAcceptInputType_suppressAdvancedFilterEval: {};

                                                                                                                                                              property ngAcceptInputType_suppressAggFilteredOnly

                                                                                                                                                              static ngAcceptInputType_suppressAggFilteredOnly: {};

                                                                                                                                                                property ngAcceptInputType_suppressAggFuncInHeader

                                                                                                                                                                static ngAcceptInputType_suppressAggFuncInHeader: {};

                                                                                                                                                                  property ngAcceptInputType_suppressAnimationFrame

                                                                                                                                                                  static ngAcceptInputType_suppressAnimationFrame: {};

                                                                                                                                                                    property ngAcceptInputType_suppressAutoSize

                                                                                                                                                                    static ngAcceptInputType_suppressAutoSize: {};

                                                                                                                                                                      property ngAcceptInputType_suppressBrowserResizeObserver

                                                                                                                                                                      static ngAcceptInputType_suppressBrowserResizeObserver: {};

                                                                                                                                                                        property ngAcceptInputType_suppressCellFocus

                                                                                                                                                                        static ngAcceptInputType_suppressCellFocus: {};

                                                                                                                                                                          property ngAcceptInputType_suppressChangeDetection

                                                                                                                                                                          static ngAcceptInputType_suppressChangeDetection: {};

                                                                                                                                                                            property ngAcceptInputType_suppressClearOnFillReduction

                                                                                                                                                                            static ngAcceptInputType_suppressClearOnFillReduction: {};

                                                                                                                                                                              property ngAcceptInputType_suppressClickEdit

                                                                                                                                                                              static ngAcceptInputType_suppressClickEdit: {};

                                                                                                                                                                                property ngAcceptInputType_suppressClipboardApi

                                                                                                                                                                                static ngAcceptInputType_suppressClipboardApi: {};

                                                                                                                                                                                  property ngAcceptInputType_suppressClipboardPaste

                                                                                                                                                                                  static ngAcceptInputType_suppressClipboardPaste: {};

                                                                                                                                                                                    property ngAcceptInputType_suppressColumnMoveAnimation

                                                                                                                                                                                    static ngAcceptInputType_suppressColumnMoveAnimation: {};

                                                                                                                                                                                      property ngAcceptInputType_suppressColumnVirtualisation

                                                                                                                                                                                      static ngAcceptInputType_suppressColumnVirtualisation: {};

                                                                                                                                                                                        property ngAcceptInputType_suppressContextMenu

                                                                                                                                                                                        static ngAcceptInputType_suppressContextMenu: {};

                                                                                                                                                                                          property ngAcceptInputType_suppressCopyRowsToClipboard

                                                                                                                                                                                          static ngAcceptInputType_suppressCopyRowsToClipboard: {};

                                                                                                                                                                                            property ngAcceptInputType_suppressCopySingleCellRanges

                                                                                                                                                                                            static ngAcceptInputType_suppressCopySingleCellRanges: {};

                                                                                                                                                                                              property ngAcceptInputType_suppressCsvExport

                                                                                                                                                                                              static ngAcceptInputType_suppressCsvExport: {};

                                                                                                                                                                                                property ngAcceptInputType_suppressCutToClipboard

                                                                                                                                                                                                static ngAcceptInputType_suppressCutToClipboard: {};

                                                                                                                                                                                                  property ngAcceptInputType_suppressDragLeaveHidesColumns

                                                                                                                                                                                                  static ngAcceptInputType_suppressDragLeaveHidesColumns: {};

                                                                                                                                                                                                    property ngAcceptInputType_suppressExcelExport

                                                                                                                                                                                                    static ngAcceptInputType_suppressExcelExport: {};

                                                                                                                                                                                                      property ngAcceptInputType_suppressExpandablePivotGroups

                                                                                                                                                                                                      static ngAcceptInputType_suppressExpandablePivotGroups: {};

                                                                                                                                                                                                        property ngAcceptInputType_suppressFieldDotNotation

                                                                                                                                                                                                        static ngAcceptInputType_suppressFieldDotNotation: {};

                                                                                                                                                                                                          property ngAcceptInputType_suppressFocusAfterRefresh

                                                                                                                                                                                                          static ngAcceptInputType_suppressFocusAfterRefresh: {};

                                                                                                                                                                                                            property ngAcceptInputType_suppressGroupRowsSticky

                                                                                                                                                                                                            static ngAcceptInputType_suppressGroupRowsSticky: {};

                                                                                                                                                                                                              property ngAcceptInputType_suppressHeaderFocus

                                                                                                                                                                                                              static ngAcceptInputType_suppressHeaderFocus: {};

                                                                                                                                                                                                                property ngAcceptInputType_suppressHorizontalScroll

                                                                                                                                                                                                                static ngAcceptInputType_suppressHorizontalScroll: {};

                                                                                                                                                                                                                  property ngAcceptInputType_suppressLastEmptyLineOnPaste

                                                                                                                                                                                                                  static ngAcceptInputType_suppressLastEmptyLineOnPaste: {};

                                                                                                                                                                                                                    property ngAcceptInputType_suppressLoadingOverlay

                                                                                                                                                                                                                    static ngAcceptInputType_suppressLoadingOverlay: {};

                                                                                                                                                                                                                      property ngAcceptInputType_suppressMaintainUnsortedOrder

                                                                                                                                                                                                                      static ngAcceptInputType_suppressMaintainUnsortedOrder: {};

                                                                                                                                                                                                                        property ngAcceptInputType_suppressMakeColumnVisibleAfterUnGroup

                                                                                                                                                                                                                        static ngAcceptInputType_suppressMakeColumnVisibleAfterUnGroup: {};

                                                                                                                                                                                                                          property ngAcceptInputType_suppressMaxRenderedRowRestriction

                                                                                                                                                                                                                          static ngAcceptInputType_suppressMaxRenderedRowRestriction: {};

                                                                                                                                                                                                                            property ngAcceptInputType_suppressMenuHide

                                                                                                                                                                                                                            static ngAcceptInputType_suppressMenuHide: {};

                                                                                                                                                                                                                              property ngAcceptInputType_suppressMiddleClickScrolls

                                                                                                                                                                                                                              static ngAcceptInputType_suppressMiddleClickScrolls: {};

                                                                                                                                                                                                                                property ngAcceptInputType_suppressModelUpdateAfterUpdateTransaction

                                                                                                                                                                                                                                static ngAcceptInputType_suppressModelUpdateAfterUpdateTransaction: {};

                                                                                                                                                                                                                                  property ngAcceptInputType_suppressMovableColumns

                                                                                                                                                                                                                                  static ngAcceptInputType_suppressMovableColumns: {};

                                                                                                                                                                                                                                    property ngAcceptInputType_suppressMoveWhenColumnDragging

                                                                                                                                                                                                                                    static ngAcceptInputType_suppressMoveWhenColumnDragging: {};

                                                                                                                                                                                                                                      property ngAcceptInputType_suppressMoveWhenRowDragging

                                                                                                                                                                                                                                      static ngAcceptInputType_suppressMoveWhenRowDragging: {};

                                                                                                                                                                                                                                        property ngAcceptInputType_suppressMultiRangeSelection

                                                                                                                                                                                                                                        static ngAcceptInputType_suppressMultiRangeSelection: {};

                                                                                                                                                                                                                                          property ngAcceptInputType_suppressMultiSort

                                                                                                                                                                                                                                          static ngAcceptInputType_suppressMultiSort: {};

                                                                                                                                                                                                                                            property ngAcceptInputType_suppressNoRowsOverlay

                                                                                                                                                                                                                                            static ngAcceptInputType_suppressNoRowsOverlay: {};

                                                                                                                                                                                                                                              property ngAcceptInputType_suppressPaginationPanel

                                                                                                                                                                                                                                              static ngAcceptInputType_suppressPaginationPanel: {};

                                                                                                                                                                                                                                                property ngAcceptInputType_suppressPreventDefaultOnMouseWheel

                                                                                                                                                                                                                                                static ngAcceptInputType_suppressPreventDefaultOnMouseWheel: {};

                                                                                                                                                                                                                                                  property ngAcceptInputType_suppressPropertyNamesCheck

                                                                                                                                                                                                                                                  static ngAcceptInputType_suppressPropertyNamesCheck: {};

                                                                                                                                                                                                                                                    property ngAcceptInputType_suppressRowClickSelection

                                                                                                                                                                                                                                                    static ngAcceptInputType_suppressRowClickSelection: {};

                                                                                                                                                                                                                                                      property ngAcceptInputType_suppressRowDeselection

                                                                                                                                                                                                                                                      static ngAcceptInputType_suppressRowDeselection: {};

                                                                                                                                                                                                                                                        property ngAcceptInputType_suppressRowDrag

                                                                                                                                                                                                                                                        static ngAcceptInputType_suppressRowDrag: {};

                                                                                                                                                                                                                                                          property ngAcceptInputType_suppressRowGroupHidesColumns

                                                                                                                                                                                                                                                          static ngAcceptInputType_suppressRowGroupHidesColumns: {};

                                                                                                                                                                                                                                                            property ngAcceptInputType_suppressRowHoverHighlight

                                                                                                                                                                                                                                                            static ngAcceptInputType_suppressRowHoverHighlight: {};

                                                                                                                                                                                                                                                              property ngAcceptInputType_suppressRowTransform

                                                                                                                                                                                                                                                              static ngAcceptInputType_suppressRowTransform: {};

                                                                                                                                                                                                                                                                property ngAcceptInputType_suppressRowVirtualisation

                                                                                                                                                                                                                                                                static ngAcceptInputType_suppressRowVirtualisation: {};

                                                                                                                                                                                                                                                                  property ngAcceptInputType_suppressScrollOnNewData

                                                                                                                                                                                                                                                                  static ngAcceptInputType_suppressScrollOnNewData: {};

                                                                                                                                                                                                                                                                    property ngAcceptInputType_suppressScrollWhenPopupsAreOpen

                                                                                                                                                                                                                                                                    static ngAcceptInputType_suppressScrollWhenPopupsAreOpen: {};

                                                                                                                                                                                                                                                                      property ngAcceptInputType_suppressServerSideFullWidthLoadingRow

                                                                                                                                                                                                                                                                      static ngAcceptInputType_suppressServerSideFullWidthLoadingRow: {};

                                                                                                                                                                                                                                                                        property ngAcceptInputType_suppressSetFilterByDefault

                                                                                                                                                                                                                                                                        static ngAcceptInputType_suppressSetFilterByDefault: {};

                                                                                                                                                                                                                                                                          property ngAcceptInputType_suppressTouch

                                                                                                                                                                                                                                                                          static ngAcceptInputType_suppressTouch: {};

                                                                                                                                                                                                                                                                            property ngAcceptInputType_tooltipInteraction

                                                                                                                                                                                                                                                                            static ngAcceptInputType_tooltipInteraction: {};

                                                                                                                                                                                                                                                                              property ngAcceptInputType_tooltipMouseTrack

                                                                                                                                                                                                                                                                              static ngAcceptInputType_tooltipMouseTrack: {};

                                                                                                                                                                                                                                                                                property ngAcceptInputType_treeData

                                                                                                                                                                                                                                                                                static ngAcceptInputType_treeData: {};

                                                                                                                                                                                                                                                                                  property ngAcceptInputType_undoRedoCellEditing

                                                                                                                                                                                                                                                                                  static ngAcceptInputType_undoRedoCellEditing: {};

                                                                                                                                                                                                                                                                                    property ngAcceptInputType_unSortIcon

                                                                                                                                                                                                                                                                                    static ngAcceptInputType_unSortIcon: {};

                                                                                                                                                                                                                                                                                      property ngAcceptInputType_valueCache

                                                                                                                                                                                                                                                                                      static ngAcceptInputType_valueCache: {};

                                                                                                                                                                                                                                                                                        property ngAcceptInputType_valueCacheNeverExpires

                                                                                                                                                                                                                                                                                        static ngAcceptInputType_valueCacheNeverExpires: {};

                                                                                                                                                                                                                                                                                          property noRowsOverlayComponent

                                                                                                                                                                                                                                                                                          noRowsOverlayComponent: any;
                                                                                                                                                                                                                                                                                          • Provide a custom no-rows overlay component.

                                                                                                                                                                                                                                                                                          property noRowsOverlayComponentParams

                                                                                                                                                                                                                                                                                          noRowsOverlayComponentParams: any;
                                                                                                                                                                                                                                                                                          • Customise the parameters provided to the no-rows overlay component.

                                                                                                                                                                                                                                                                                          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.

                                                                                                                                                                                                                                                                                          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.

                                                                                                                                                                                                                                                                                          property ɵcmp

                                                                                                                                                                                                                                                                                          static ɵcmp: i0.ɵɵComponentDeclaration<
                                                                                                                                                                                                                                                                                          AgGridAngular<any, any>,
                                                                                                                                                                                                                                                                                          'ag-grid-angular',
                                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                          gridOptions: { alias: 'gridOptions'; required: false };
                                                                                                                                                                                                                                                                                          modules: { alias: 'modules'; required: false };
                                                                                                                                                                                                                                                                                          statusBar: { alias: 'statusBar'; required: false };
                                                                                                                                                                                                                                                                                          sideBar: { alias: 'sideBar'; required: false };
                                                                                                                                                                                                                                                                                          suppressContextMenu: { alias: 'suppressContextMenu'; required: false };
                                                                                                                                                                                                                                                                                          preventDefaultOnContextMenu: {
                                                                                                                                                                                                                                                                                          alias: 'preventDefaultOnContextMenu';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          allowContextMenuWithControlKey: {
                                                                                                                                                                                                                                                                                          alias: 'allowContextMenuWithControlKey';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          columnMenu: { alias: 'columnMenu'; required: false };
                                                                                                                                                                                                                                                                                          suppressMenuHide: { alias: 'suppressMenuHide'; required: false };
                                                                                                                                                                                                                                                                                          enableBrowserTooltips: {
                                                                                                                                                                                                                                                                                          alias: 'enableBrowserTooltips';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          tooltipTrigger: { alias: 'tooltipTrigger'; required: false };
                                                                                                                                                                                                                                                                                          tooltipShowDelay: { alias: 'tooltipShowDelay'; required: false };
                                                                                                                                                                                                                                                                                          tooltipHideDelay: { alias: 'tooltipHideDelay'; required: false };
                                                                                                                                                                                                                                                                                          tooltipMouseTrack: { alias: 'tooltipMouseTrack'; required: false };
                                                                                                                                                                                                                                                                                          tooltipShowMode: { alias: 'tooltipShowMode'; required: false };
                                                                                                                                                                                                                                                                                          tooltipInteraction: { alias: 'tooltipInteraction'; required: false };
                                                                                                                                                                                                                                                                                          popupParent: { alias: 'popupParent'; required: false };
                                                                                                                                                                                                                                                                                          copyHeadersToClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'copyHeadersToClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          copyGroupHeadersToClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'copyGroupHeadersToClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          clipboardDelimiter: { alias: 'clipboardDelimiter'; required: false };
                                                                                                                                                                                                                                                                                          suppressCopyRowsToClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'suppressCopyRowsToClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressCopySingleCellRanges: {
                                                                                                                                                                                                                                                                                          alias: 'suppressCopySingleCellRanges';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressLastEmptyLineOnPaste: {
                                                                                                                                                                                                                                                                                          alias: 'suppressLastEmptyLineOnPaste';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressClipboardPaste: {
                                                                                                                                                                                                                                                                                          alias: 'suppressClipboardPaste';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressClipboardApi: { alias: 'suppressClipboardApi'; required: false };
                                                                                                                                                                                                                                                                                          suppressCutToClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'suppressCutToClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          columnDefs: { alias: 'columnDefs'; required: false };
                                                                                                                                                                                                                                                                                          defaultColDef: { alias: 'defaultColDef'; required: false };
                                                                                                                                                                                                                                                                                          defaultColGroupDef: { alias: 'defaultColGroupDef'; required: false };
                                                                                                                                                                                                                                                                                          columnTypes: { alias: 'columnTypes'; required: false };
                                                                                                                                                                                                                                                                                          dataTypeDefinitions: { alias: 'dataTypeDefinitions'; required: false };
                                                                                                                                                                                                                                                                                          maintainColumnOrder: { alias: 'maintainColumnOrder'; required: false };
                                                                                                                                                                                                                                                                                          enableStrictPivotColumnOrder: {
                                                                                                                                                                                                                                                                                          alias: 'enableStrictPivotColumnOrder';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressFieldDotNotation: {
                                                                                                                                                                                                                                                                                          alias: 'suppressFieldDotNotation';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          headerHeight: { alias: 'headerHeight'; required: false };
                                                                                                                                                                                                                                                                                          groupHeaderHeight: { alias: 'groupHeaderHeight'; required: false };
                                                                                                                                                                                                                                                                                          floatingFiltersHeight: {
                                                                                                                                                                                                                                                                                          alias: 'floatingFiltersHeight';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          pivotHeaderHeight: { alias: 'pivotHeaderHeight'; required: false };
                                                                                                                                                                                                                                                                                          pivotGroupHeaderHeight: {
                                                                                                                                                                                                                                                                                          alias: 'pivotGroupHeaderHeight';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          allowDragFromColumnsToolPanel: {
                                                                                                                                                                                                                                                                                          alias: 'allowDragFromColumnsToolPanel';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressMovableColumns: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMovableColumns';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressColumnMoveAnimation: {
                                                                                                                                                                                                                                                                                          alias: 'suppressColumnMoveAnimation';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressMoveWhenColumnDragging: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMoveWhenColumnDragging';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressDragLeaveHidesColumns: {
                                                                                                                                                                                                                                                                                          alias: 'suppressDragLeaveHidesColumns';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressGroupChangesColumnVisibility: {
                                                                                                                                                                                                                                                                                          alias: 'suppressGroupChangesColumnVisibility';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressMakeColumnVisibleAfterUnGroup: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMakeColumnVisibleAfterUnGroup';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressRowGroupHidesColumns: {
                                                                                                                                                                                                                                                                                          alias: 'suppressRowGroupHidesColumns';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          colResizeDefault: { alias: 'colResizeDefault'; required: false };
                                                                                                                                                                                                                                                                                          suppressAutoSize: { alias: 'suppressAutoSize'; required: false };
                                                                                                                                                                                                                                                                                          autoSizePadding: { alias: 'autoSizePadding'; required: false };
                                                                                                                                                                                                                                                                                          skipHeaderOnAutoSize: { alias: 'skipHeaderOnAutoSize'; required: false };
                                                                                                                                                                                                                                                                                          autoSizeStrategy: { alias: 'autoSizeStrategy'; required: false };
                                                                                                                                                                                                                                                                                          components: { alias: 'components'; required: false };
                                                                                                                                                                                                                                                                                          editType: { alias: 'editType'; required: false };
                                                                                                                                                                                                                                                                                          singleClickEdit: { alias: 'singleClickEdit'; required: false };
                                                                                                                                                                                                                                                                                          suppressClickEdit: { alias: 'suppressClickEdit'; required: false };
                                                                                                                                                                                                                                                                                          readOnlyEdit: { alias: 'readOnlyEdit'; required: false };
                                                                                                                                                                                                                                                                                          stopEditingWhenCellsLoseFocus: {
                                                                                                                                                                                                                                                                                          alias: 'stopEditingWhenCellsLoseFocus';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enterNavigatesVertically: {
                                                                                                                                                                                                                                                                                          alias: 'enterNavigatesVertically';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enterNavigatesVerticallyAfterEdit: {
                                                                                                                                                                                                                                                                                          alias: 'enterNavigatesVerticallyAfterEdit';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enableCellEditingOnBackspace: {
                                                                                                                                                                                                                                                                                          alias: 'enableCellEditingOnBackspace';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          undoRedoCellEditing: { alias: 'undoRedoCellEditing'; required: false };
                                                                                                                                                                                                                                                                                          undoRedoCellEditingLimit: {
                                                                                                                                                                                                                                                                                          alias: 'undoRedoCellEditingLimit';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          defaultCsvExportParams: {
                                                                                                                                                                                                                                                                                          alias: 'defaultCsvExportParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressCsvExport: { alias: 'suppressCsvExport'; required: false };
                                                                                                                                                                                                                                                                                          defaultExcelExportParams: {
                                                                                                                                                                                                                                                                                          alias: 'defaultExcelExportParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressExcelExport: { alias: 'suppressExcelExport'; required: false };
                                                                                                                                                                                                                                                                                          excelStyles: { alias: 'excelStyles'; required: false };
                                                                                                                                                                                                                                                                                          quickFilterText: { alias: 'quickFilterText'; required: false };
                                                                                                                                                                                                                                                                                          cacheQuickFilter: { alias: 'cacheQuickFilter'; required: false };
                                                                                                                                                                                                                                                                                          includeHiddenColumnsInQuickFilter: {
                                                                                                                                                                                                                                                                                          alias: 'includeHiddenColumnsInQuickFilter';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          quickFilterParser: { alias: 'quickFilterParser'; required: false };
                                                                                                                                                                                                                                                                                          quickFilterMatcher: { alias: 'quickFilterMatcher'; required: false };
                                                                                                                                                                                                                                                                                          applyQuickFilterBeforePivotOrAgg: {
                                                                                                                                                                                                                                                                                          alias: 'applyQuickFilterBeforePivotOrAgg';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          excludeChildrenWhenTreeDataFiltering: {
                                                                                                                                                                                                                                                                                          alias: 'excludeChildrenWhenTreeDataFiltering';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enableAdvancedFilter: { alias: 'enableAdvancedFilter'; required: false };
                                                                                                                                                                                                                                                                                          alwaysPassFilter: { alias: 'alwaysPassFilter'; required: false };
                                                                                                                                                                                                                                                                                          includeHiddenColumnsInAdvancedFilter: {
                                                                                                                                                                                                                                                                                          alias: 'includeHiddenColumnsInAdvancedFilter';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          advancedFilterParent: { alias: 'advancedFilterParent'; required: false };
                                                                                                                                                                                                                                                                                          advancedFilterBuilderParams: {
                                                                                                                                                                                                                                                                                          alias: 'advancedFilterBuilderParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressAdvancedFilterEval: {
                                                                                                                                                                                                                                                                                          alias: 'suppressAdvancedFilterEval';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressSetFilterByDefault: {
                                                                                                                                                                                                                                                                                          alias: 'suppressSetFilterByDefault';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enableCharts: { alias: 'enableCharts'; required: false };
                                                                                                                                                                                                                                                                                          chartThemes: { alias: 'chartThemes'; required: false };
                                                                                                                                                                                                                                                                                          customChartThemes: { alias: 'customChartThemes'; required: false };
                                                                                                                                                                                                                                                                                          chartThemeOverrides: { alias: 'chartThemeOverrides'; required: false };
                                                                                                                                                                                                                                                                                          chartToolPanelsDef: { alias: 'chartToolPanelsDef'; required: false };
                                                                                                                                                                                                                                                                                          chartMenuItems: { alias: 'chartMenuItems'; required: false };
                                                                                                                                                                                                                                                                                          loadingCellRenderer: { alias: 'loadingCellRenderer'; required: false };
                                                                                                                                                                                                                                                                                          loadingCellRendererParams: {
                                                                                                                                                                                                                                                                                          alias: 'loadingCellRendererParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          loadingCellRendererSelector: {
                                                                                                                                                                                                                                                                                          alias: 'loadingCellRendererSelector';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          localeText: { alias: 'localeText'; required: false };
                                                                                                                                                                                                                                                                                          masterDetail: { alias: 'masterDetail'; required: false };
                                                                                                                                                                                                                                                                                          keepDetailRows: { alias: 'keepDetailRows'; required: false };
                                                                                                                                                                                                                                                                                          keepDetailRowsCount: { alias: 'keepDetailRowsCount'; required: false };
                                                                                                                                                                                                                                                                                          detailCellRenderer: { alias: 'detailCellRenderer'; required: false };
                                                                                                                                                                                                                                                                                          detailCellRendererParams: {
                                                                                                                                                                                                                                                                                          alias: 'detailCellRendererParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          detailRowHeight: { alias: 'detailRowHeight'; required: false };
                                                                                                                                                                                                                                                                                          detailRowAutoHeight: { alias: 'detailRowAutoHeight'; required: false };
                                                                                                                                                                                                                                                                                          context: { alias: 'context'; required: false };
                                                                                                                                                                                                                                                                                          dragAndDropImageComponent: {
                                                                                                                                                                                                                                                                                          alias: 'dragAndDropImageComponent';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          dragAndDropImageComponentParams: {
                                                                                                                                                                                                                                                                                          alias: 'dragAndDropImageComponentParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          alignedGrids: { alias: 'alignedGrids'; required: false };
                                                                                                                                                                                                                                                                                          tabIndex: { alias: 'tabIndex'; required: false };
                                                                                                                                                                                                                                                                                          rowBuffer: { alias: 'rowBuffer'; required: false };
                                                                                                                                                                                                                                                                                          valueCache: { alias: 'valueCache'; required: false };
                                                                                                                                                                                                                                                                                          valueCacheNeverExpires: {
                                                                                                                                                                                                                                                                                          alias: 'valueCacheNeverExpires';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enableCellExpressions: {
                                                                                                                                                                                                                                                                                          alias: 'enableCellExpressions';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressTouch: { alias: 'suppressTouch'; required: false };
                                                                                                                                                                                                                                                                                          suppressFocusAfterRefresh: {
                                                                                                                                                                                                                                                                                          alias: 'suppressFocusAfterRefresh';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressBrowserResizeObserver: {
                                                                                                                                                                                                                                                                                          alias: 'suppressBrowserResizeObserver';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressPropertyNamesCheck: {
                                                                                                                                                                                                                                                                                          alias: 'suppressPropertyNamesCheck';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressChangeDetection: {
                                                                                                                                                                                                                                                                                          alias: 'suppressChangeDetection';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          debug: { alias: 'debug'; required: false };
                                                                                                                                                                                                                                                                                          loading: { alias: 'loading'; required: false };
                                                                                                                                                                                                                                                                                          overlayLoadingTemplate: {
                                                                                                                                                                                                                                                                                          alias: 'overlayLoadingTemplate';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          loadingOverlayComponent: {
                                                                                                                                                                                                                                                                                          alias: 'loadingOverlayComponent';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          loadingOverlayComponentParams: {
                                                                                                                                                                                                                                                                                          alias: 'loadingOverlayComponentParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressLoadingOverlay: {
                                                                                                                                                                                                                                                                                          alias: 'suppressLoadingOverlay';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          overlayNoRowsTemplate: {
                                                                                                                                                                                                                                                                                          alias: 'overlayNoRowsTemplate';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          noRowsOverlayComponent: {
                                                                                                                                                                                                                                                                                          alias: 'noRowsOverlayComponent';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          noRowsOverlayComponentParams: {
                                                                                                                                                                                                                                                                                          alias: 'noRowsOverlayComponentParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressNoRowsOverlay: {
                                                                                                                                                                                                                                                                                          alias: 'suppressNoRowsOverlay';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          pagination: { alias: 'pagination'; required: false };
                                                                                                                                                                                                                                                                                          paginationPageSize: { alias: 'paginationPageSize'; required: false };
                                                                                                                                                                                                                                                                                          paginationPageSizeSelector: {
                                                                                                                                                                                                                                                                                          alias: 'paginationPageSizeSelector';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          paginationAutoPageSize: {
                                                                                                                                                                                                                                                                                          alias: 'paginationAutoPageSize';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          paginateChildRows: { alias: 'paginateChildRows'; required: false };
                                                                                                                                                                                                                                                                                          suppressPaginationPanel: {
                                                                                                                                                                                                                                                                                          alias: 'suppressPaginationPanel';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          pivotMode: { alias: 'pivotMode'; required: false };
                                                                                                                                                                                                                                                                                          pivotPanelShow: { alias: 'pivotPanelShow'; required: false };
                                                                                                                                                                                                                                                                                          pivotMaxGeneratedColumns: {
                                                                                                                                                                                                                                                                                          alias: 'pivotMaxGeneratedColumns';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          pivotDefaultExpanded: { alias: 'pivotDefaultExpanded'; required: false };
                                                                                                                                                                                                                                                                                          pivotColumnGroupTotals: {
                                                                                                                                                                                                                                                                                          alias: 'pivotColumnGroupTotals';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          pivotRowTotals: { alias: 'pivotRowTotals'; required: false };
                                                                                                                                                                                                                                                                                          pivotSuppressAutoColumn: {
                                                                                                                                                                                                                                                                                          alias: 'pivotSuppressAutoColumn';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressExpandablePivotGroups: {
                                                                                                                                                                                                                                                                                          alias: 'suppressExpandablePivotGroups';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          functionsReadOnly: { alias: 'functionsReadOnly'; required: false };
                                                                                                                                                                                                                                                                                          aggFuncs: { alias: 'aggFuncs'; required: false };
                                                                                                                                                                                                                                                                                          suppressAggFuncInHeader: {
                                                                                                                                                                                                                                                                                          alias: 'suppressAggFuncInHeader';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          alwaysAggregateAtRootLevel: {
                                                                                                                                                                                                                                                                                          alias: 'alwaysAggregateAtRootLevel';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          aggregateOnlyChangedColumns: {
                                                                                                                                                                                                                                                                                          alias: 'aggregateOnlyChangedColumns';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressAggFilteredOnly: {
                                                                                                                                                                                                                                                                                          alias: 'suppressAggFilteredOnly';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          removePivotHeaderRowWhenSingleValueColumn: {
                                                                                                                                                                                                                                                                                          alias: 'removePivotHeaderRowWhenSingleValueColumn';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          animateRows: { alias: 'animateRows'; required: false };
                                                                                                                                                                                                                                                                                          cellFlashDuration: { alias: 'cellFlashDuration'; required: false };
                                                                                                                                                                                                                                                                                          cellFadeDuration: { alias: 'cellFadeDuration'; required: false };
                                                                                                                                                                                                                                                                                          allowShowChangeAfterFilter: {
                                                                                                                                                                                                                                                                                          alias: 'allowShowChangeAfterFilter';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          domLayout: { alias: 'domLayout'; required: false };
                                                                                                                                                                                                                                                                                          ensureDomOrder: { alias: 'ensureDomOrder'; required: false };
                                                                                                                                                                                                                                                                                          enableCellSpan: { alias: 'enableCellSpan'; required: false };
                                                                                                                                                                                                                                                                                          enableRtl: { alias: 'enableRtl'; required: false };
                                                                                                                                                                                                                                                                                          suppressColumnVirtualisation: {
                                                                                                                                                                                                                                                                                          alias: 'suppressColumnVirtualisation';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressMaxRenderedRowRestriction: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMaxRenderedRowRestriction';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressRowVirtualisation: {
                                                                                                                                                                                                                                                                                          alias: 'suppressRowVirtualisation';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          rowDragManaged: { alias: 'rowDragManaged'; required: false };
                                                                                                                                                                                                                                                                                          suppressRowDrag: { alias: 'suppressRowDrag'; required: false };
                                                                                                                                                                                                                                                                                          suppressMoveWhenRowDragging: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMoveWhenRowDragging';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          rowDragEntireRow: { alias: 'rowDragEntireRow'; required: false };
                                                                                                                                                                                                                                                                                          rowDragMultiRow: { alias: 'rowDragMultiRow'; required: false };
                                                                                                                                                                                                                                                                                          rowDragText: { alias: 'rowDragText'; required: false };
                                                                                                                                                                                                                                                                                          fullWidthCellRenderer: {
                                                                                                                                                                                                                                                                                          alias: 'fullWidthCellRenderer';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          fullWidthCellRendererParams: {
                                                                                                                                                                                                                                                                                          alias: 'fullWidthCellRendererParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          embedFullWidthRows: { alias: 'embedFullWidthRows'; required: false };
                                                                                                                                                                                                                                                                                          groupDisplayType: { alias: 'groupDisplayType'; required: false };
                                                                                                                                                                                                                                                                                          groupDefaultExpanded: { alias: 'groupDefaultExpanded'; required: false };
                                                                                                                                                                                                                                                                                          autoGroupColumnDef: { alias: 'autoGroupColumnDef'; required: false };
                                                                                                                                                                                                                                                                                          groupMaintainOrder: { alias: 'groupMaintainOrder'; required: false };
                                                                                                                                                                                                                                                                                          groupSelectsChildren: { alias: 'groupSelectsChildren'; required: false };
                                                                                                                                                                                                                                                                                          groupLockGroupColumns: {
                                                                                                                                                                                                                                                                                          alias: 'groupLockGroupColumns';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          groupAggFiltering: { alias: 'groupAggFiltering'; required: false };
                                                                                                                                                                                                                                                                                          groupTotalRow: { alias: 'groupTotalRow'; required: false };
                                                                                                                                                                                                                                                                                          grandTotalRow: { alias: 'grandTotalRow'; required: false };
                                                                                                                                                                                                                                                                                          suppressStickyTotalRow: {
                                                                                                                                                                                                                                                                                          alias: 'suppressStickyTotalRow';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          groupSuppressBlankHeader: {
                                                                                                                                                                                                                                                                                          alias: 'groupSuppressBlankHeader';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          groupSelectsFiltered: { alias: 'groupSelectsFiltered'; required: false };
                                                                                                                                                                                                                                                                                          showOpenedGroup: { alias: 'showOpenedGroup'; required: false };
                                                                                                                                                                                                                                                                                          groupHideParentOfSingleChild: {
                                                                                                                                                                                                                                                                                          alias: 'groupHideParentOfSingleChild';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          groupRemoveSingleChildren: {
                                                                                                                                                                                                                                                                                          alias: 'groupRemoveSingleChildren';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          groupRemoveLowestSingleChildren: {
                                                                                                                                                                                                                                                                                          alias: 'groupRemoveLowestSingleChildren';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          groupHideOpenParents: { alias: 'groupHideOpenParents'; required: false };
                                                                                                                                                                                                                                                                                          groupAllowUnbalanced: { alias: 'groupAllowUnbalanced'; required: false };
                                                                                                                                                                                                                                                                                          rowGroupPanelShow: { alias: 'rowGroupPanelShow'; required: false };
                                                                                                                                                                                                                                                                                          groupRowRenderer: { alias: 'groupRowRenderer'; required: false };
                                                                                                                                                                                                                                                                                          groupRowRendererParams: {
                                                                                                                                                                                                                                                                                          alias: 'groupRowRendererParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          treeData: { alias: 'treeData'; required: false };
                                                                                                                                                                                                                                                                                          treeDataChildrenField: {
                                                                                                                                                                                                                                                                                          alias: 'treeDataChildrenField';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          rowGroupPanelSuppressSort: {
                                                                                                                                                                                                                                                                                          alias: 'rowGroupPanelSuppressSort';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressGroupRowsSticky: {
                                                                                                                                                                                                                                                                                          alias: 'suppressGroupRowsSticky';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          pinnedTopRowData: { alias: 'pinnedTopRowData'; required: false };
                                                                                                                                                                                                                                                                                          pinnedBottomRowData: { alias: 'pinnedBottomRowData'; required: false };
                                                                                                                                                                                                                                                                                          rowModelType: { alias: 'rowModelType'; required: false };
                                                                                                                                                                                                                                                                                          rowData: { alias: 'rowData'; required: false };
                                                                                                                                                                                                                                                                                          asyncTransactionWaitMillis: {
                                                                                                                                                                                                                                                                                          alias: 'asyncTransactionWaitMillis';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressModelUpdateAfterUpdateTransaction: {
                                                                                                                                                                                                                                                                                          alias: 'suppressModelUpdateAfterUpdateTransaction';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          datasource: { alias: 'datasource'; required: false };
                                                                                                                                                                                                                                                                                          cacheOverflowSize: { alias: 'cacheOverflowSize'; required: false };
                                                                                                                                                                                                                                                                                          infiniteInitialRowCount: {
                                                                                                                                                                                                                                                                                          alias: 'infiniteInitialRowCount';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          serverSideInitialRowCount: {
                                                                                                                                                                                                                                                                                          alias: 'serverSideInitialRowCount';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressServerSideFullWidthLoadingRow: {
                                                                                                                                                                                                                                                                                          alias: 'suppressServerSideFullWidthLoadingRow';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          cacheBlockSize: { alias: 'cacheBlockSize'; required: false };
                                                                                                                                                                                                                                                                                          maxBlocksInCache: { alias: 'maxBlocksInCache'; required: false };
                                                                                                                                                                                                                                                                                          maxConcurrentDatasourceRequests: {
                                                                                                                                                                                                                                                                                          alias: 'maxConcurrentDatasourceRequests';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          blockLoadDebounceMillis: {
                                                                                                                                                                                                                                                                                          alias: 'blockLoadDebounceMillis';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          purgeClosedRowNodes: { alias: 'purgeClosedRowNodes'; required: false };
                                                                                                                                                                                                                                                                                          serverSideDatasource: { alias: 'serverSideDatasource'; required: false };
                                                                                                                                                                                                                                                                                          serverSideSortAllLevels: {
                                                                                                                                                                                                                                                                                          alias: 'serverSideSortAllLevels';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          serverSideEnableClientSideSort: {
                                                                                                                                                                                                                                                                                          alias: 'serverSideEnableClientSideSort';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          serverSideOnlyRefreshFilteredGroups: {
                                                                                                                                                                                                                                                                                          alias: 'serverSideOnlyRefreshFilteredGroups';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          serverSidePivotResultFieldSeparator: {
                                                                                                                                                                                                                                                                                          alias: 'serverSidePivotResultFieldSeparator';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          viewportDatasource: { alias: 'viewportDatasource'; required: false };
                                                                                                                                                                                                                                                                                          viewportRowModelPageSize: {
                                                                                                                                                                                                                                                                                          alias: 'viewportRowModelPageSize';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          viewportRowModelBufferSize: {
                                                                                                                                                                                                                                                                                          alias: 'viewportRowModelBufferSize';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          alwaysShowHorizontalScroll: {
                                                                                                                                                                                                                                                                                          alias: 'alwaysShowHorizontalScroll';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          alwaysShowVerticalScroll: {
                                                                                                                                                                                                                                                                                          alias: 'alwaysShowVerticalScroll';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          debounceVerticalScrollbar: {
                                                                                                                                                                                                                                                                                          alias: 'debounceVerticalScrollbar';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressHorizontalScroll: {
                                                                                                                                                                                                                                                                                          alias: 'suppressHorizontalScroll';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressScrollOnNewData: {
                                                                                                                                                                                                                                                                                          alias: 'suppressScrollOnNewData';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressScrollWhenPopupsAreOpen: {
                                                                                                                                                                                                                                                                                          alias: 'suppressScrollWhenPopupsAreOpen';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressAnimationFrame: {
                                                                                                                                                                                                                                                                                          alias: 'suppressAnimationFrame';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressMiddleClickScrolls: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMiddleClickScrolls';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressPreventDefaultOnMouseWheel: {
                                                                                                                                                                                                                                                                                          alias: 'suppressPreventDefaultOnMouseWheel';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          scrollbarWidth: { alias: 'scrollbarWidth'; required: false };
                                                                                                                                                                                                                                                                                          rowSelection: { alias: 'rowSelection'; required: false };
                                                                                                                                                                                                                                                                                          cellSelection: { alias: 'cellSelection'; required: false };
                                                                                                                                                                                                                                                                                          rowMultiSelectWithClick: {
                                                                                                                                                                                                                                                                                          alias: 'rowMultiSelectWithClick';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressRowDeselection: {
                                                                                                                                                                                                                                                                                          alias: 'suppressRowDeselection';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressRowClickSelection: {
                                                                                                                                                                                                                                                                                          alias: 'suppressRowClickSelection';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressCellFocus: { alias: 'suppressCellFocus'; required: false };
                                                                                                                                                                                                                                                                                          suppressHeaderFocus: { alias: 'suppressHeaderFocus'; required: false };
                                                                                                                                                                                                                                                                                          selectionColumnDef: { alias: 'selectionColumnDef'; required: false };
                                                                                                                                                                                                                                                                                          rowNumbers: { alias: 'rowNumbers'; required: false };
                                                                                                                                                                                                                                                                                          suppressMultiRangeSelection: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMultiRangeSelection';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enableCellTextSelection: {
                                                                                                                                                                                                                                                                                          alias: 'enableCellTextSelection';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          enableRangeSelection: { alias: 'enableRangeSelection'; required: false };
                                                                                                                                                                                                                                                                                          enableRangeHandle: { alias: 'enableRangeHandle'; required: false };
                                                                                                                                                                                                                                                                                          enableFillHandle: { alias: 'enableFillHandle'; required: false };
                                                                                                                                                                                                                                                                                          fillHandleDirection: { alias: 'fillHandleDirection'; required: false };
                                                                                                                                                                                                                                                                                          suppressClearOnFillReduction: {
                                                                                                                                                                                                                                                                                          alias: 'suppressClearOnFillReduction';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          sortingOrder: { alias: 'sortingOrder'; required: false };
                                                                                                                                                                                                                                                                                          accentedSort: { alias: 'accentedSort'; required: false };
                                                                                                                                                                                                                                                                                          unSortIcon: { alias: 'unSortIcon'; required: false };
                                                                                                                                                                                                                                                                                          suppressMultiSort: { alias: 'suppressMultiSort'; required: false };
                                                                                                                                                                                                                                                                                          alwaysMultiSort: { alias: 'alwaysMultiSort'; required: false };
                                                                                                                                                                                                                                                                                          multiSortKey: { alias: 'multiSortKey'; required: false };
                                                                                                                                                                                                                                                                                          suppressMaintainUnsortedOrder: {
                                                                                                                                                                                                                                                                                          alias: 'suppressMaintainUnsortedOrder';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          icons: { alias: 'icons'; required: false };
                                                                                                                                                                                                                                                                                          rowHeight: { alias: 'rowHeight'; required: false };
                                                                                                                                                                                                                                                                                          rowStyle: { alias: 'rowStyle'; required: false };
                                                                                                                                                                                                                                                                                          rowClass: { alias: 'rowClass'; required: false };
                                                                                                                                                                                                                                                                                          rowClassRules: { alias: 'rowClassRules'; required: false };
                                                                                                                                                                                                                                                                                          suppressRowHoverHighlight: {
                                                                                                                                                                                                                                                                                          alias: 'suppressRowHoverHighlight';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          suppressRowTransform: { alias: 'suppressRowTransform'; required: false };
                                                                                                                                                                                                                                                                                          columnHoverHighlight: { alias: 'columnHoverHighlight'; required: false };
                                                                                                                                                                                                                                                                                          gridId: { alias: 'gridId'; required: false };
                                                                                                                                                                                                                                                                                          deltaSort: { alias: 'deltaSort'; required: false };
                                                                                                                                                                                                                                                                                          treeDataDisplayType: { alias: 'treeDataDisplayType'; required: false };
                                                                                                                                                                                                                                                                                          enableGroupEdit: { alias: 'enableGroupEdit'; required: false };
                                                                                                                                                                                                                                                                                          initialState: { alias: 'initialState'; required: false };
                                                                                                                                                                                                                                                                                          theme: { alias: 'theme'; required: false };
                                                                                                                                                                                                                                                                                          loadThemeGoogleFonts: { alias: 'loadThemeGoogleFonts'; required: false };
                                                                                                                                                                                                                                                                                          themeCssLayer: { alias: 'themeCssLayer'; required: false };
                                                                                                                                                                                                                                                                                          themeStyleContainer: { alias: 'themeStyleContainer'; required: false };
                                                                                                                                                                                                                                                                                          getContextMenuItems: { alias: 'getContextMenuItems'; required: false };
                                                                                                                                                                                                                                                                                          getMainMenuItems: { alias: 'getMainMenuItems'; required: false };
                                                                                                                                                                                                                                                                                          postProcessPopup: { alias: 'postProcessPopup'; required: false };
                                                                                                                                                                                                                                                                                          processUnpinnedColumns: {
                                                                                                                                                                                                                                                                                          alias: 'processUnpinnedColumns';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          processCellForClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'processCellForClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          processHeaderForClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'processHeaderForClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          processGroupHeaderForClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'processGroupHeaderForClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          processCellFromClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'processCellFromClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          sendToClipboard: { alias: 'sendToClipboard'; required: false };
                                                                                                                                                                                                                                                                                          processDataFromClipboard: {
                                                                                                                                                                                                                                                                                          alias: 'processDataFromClipboard';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          isExternalFilterPresent: {
                                                                                                                                                                                                                                                                                          alias: 'isExternalFilterPresent';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          doesExternalFilterPass: {
                                                                                                                                                                                                                                                                                          alias: 'doesExternalFilterPass';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          getChartToolbarItems: { alias: 'getChartToolbarItems'; required: false };
                                                                                                                                                                                                                                                                                          createChartContainer: { alias: 'createChartContainer'; required: false };
                                                                                                                                                                                                                                                                                          focusGridInnerElement: {
                                                                                                                                                                                                                                                                                          alias: 'focusGridInnerElement';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          navigateToNextHeader: { alias: 'navigateToNextHeader'; required: false };
                                                                                                                                                                                                                                                                                          tabToNextHeader: { alias: 'tabToNextHeader'; required: false };
                                                                                                                                                                                                                                                                                          navigateToNextCell: { alias: 'navigateToNextCell'; required: false };
                                                                                                                                                                                                                                                                                          tabToNextCell: { alias: 'tabToNextCell'; required: false };
                                                                                                                                                                                                                                                                                          getLocaleText: { alias: 'getLocaleText'; required: false };
                                                                                                                                                                                                                                                                                          getDocument: { alias: 'getDocument'; required: false };
                                                                                                                                                                                                                                                                                          paginationNumberFormatter: {
                                                                                                                                                                                                                                                                                          alias: 'paginationNumberFormatter';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          getGroupRowAgg: { alias: 'getGroupRowAgg'; required: false };
                                                                                                                                                                                                                                                                                          isGroupOpenByDefault: { alias: 'isGroupOpenByDefault'; required: false };
                                                                                                                                                                                                                                                                                          initialGroupOrderComparator: {
                                                                                                                                                                                                                                                                                          alias: 'initialGroupOrderComparator';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          processPivotResultColDef: {
                                                                                                                                                                                                                                                                                          alias: 'processPivotResultColDef';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          processPivotResultColGroupDef: {
                                                                                                                                                                                                                                                                                          alias: 'processPivotResultColGroupDef';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          getDataPath: { alias: 'getDataPath'; required: false };
                                                                                                                                                                                                                                                                                          getChildCount: { alias: 'getChildCount'; required: false };
                                                                                                                                                                                                                                                                                          getServerSideGroupLevelParams: {
                                                                                                                                                                                                                                                                                          alias: 'getServerSideGroupLevelParams';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          isServerSideGroupOpenByDefault: {
                                                                                                                                                                                                                                                                                          alias: 'isServerSideGroupOpenByDefault';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          isApplyServerSideTransaction: {
                                                                                                                                                                                                                                                                                          alias: 'isApplyServerSideTransaction';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          isServerSideGroup: { alias: 'isServerSideGroup'; required: false };
                                                                                                                                                                                                                                                                                          getServerSideGroupKey: {
                                                                                                                                                                                                                                                                                          alias: 'getServerSideGroupKey';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          getBusinessKeyForNode: {
                                                                                                                                                                                                                                                                                          alias: 'getBusinessKeyForNode';
                                                                                                                                                                                                                                                                                          required: false;
                                                                                                                                                                                                                                                                                          };
                                                                                                                                                                                                                                                                                          getRowId: { alias: 'getRowId'; required: false };
                                                                                                                                                                                                                                                                                          resetRowDataOnUpdate: { alias: 'resetRowDataOnUpdate'; required: false };
                                                                                                                                                                                                                                                                                          processRowPostCreate: { alias: 'processRowPostCreate'; required: false };
                                                                                                                                                                                                                                                                                          isRowSelectable: { alias: 'isRowSelectable'; required: false };
                                                                                                                                                                                                                                                                                          isRowMaster: { alias: 'isRowMaster'; required: false };
                                                                                                                                                                                                                                                                                          fillOperation: { alias: 'fillOperation'; required: false };
                                                                                                                                                                                                                                                                                          postSortRows: { alias: 'postSortRows'; required: false };
                                                                                                                                                                                                                                                                                          getRowStyle: { alias: 'getRowStyle'; required: false };
                                                                                                                                                                                                                                                                                          getRowClass: { alias: 'getRowClass'; required: false };
                                                                                                                                                                                                                                                                                          getRowHeight: { alias: 'getRowHeight'; required: false };
                                                                                                                                                                                                                                                                                          isFullWidthRow: { alias: 'isFullWidthRow'; required: false };
                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                          toolPanelVisibleChanged: 'toolPanelVisibleChanged';
                                                                                                                                                                                                                                                                                          toolPanelSizeChanged: 'toolPanelSizeChanged';
                                                                                                                                                                                                                                                                                          columnMenuVisibleChanged: 'columnMenuVisibleChanged';
                                                                                                                                                                                                                                                                                          contextMenuVisibleChanged: 'contextMenuVisibleChanged';
                                                                                                                                                                                                                                                                                          cutStart: 'cutStart';
                                                                                                                                                                                                                                                                                          cutEnd: 'cutEnd';
                                                                                                                                                                                                                                                                                          pasteStart: 'pasteStart';
                                                                                                                                                                                                                                                                                          pasteEnd: 'pasteEnd';
                                                                                                                                                                                                                                                                                          columnVisible: 'columnVisible';
                                                                                                                                                                                                                                                                                          columnPinned: 'columnPinned';
                                                                                                                                                                                                                                                                                          columnResized: 'columnResized';
                                                                                                                                                                                                                                                                                          columnMoved: 'columnMoved';
                                                                                                                                                                                                                                                                                          columnValueChanged: 'columnValueChanged';
                                                                                                                                                                                                                                                                                          columnPivotModeChanged: 'columnPivotModeChanged';
                                                                                                                                                                                                                                                                                          columnPivotChanged: 'columnPivotChanged';
                                                                                                                                                                                                                                                                                          columnGroupOpened: 'columnGroupOpened';
                                                                                                                                                                                                                                                                                          newColumnsLoaded: 'newColumnsLoaded';
                                                                                                                                                                                                                                                                                          gridColumnsChanged: 'gridColumnsChanged';
                                                                                                                                                                                                                                                                                          displayedColumnsChanged: 'displayedColumnsChanged';
                                                                                                                                                                                                                                                                                          virtualColumnsChanged: 'virtualColumnsChanged';
                                                                                                                                                                                                                                                                                          columnEverythingChanged: 'columnEverythingChanged';
                                                                                                                                                                                                                                                                                          columnHeaderMouseOver: 'columnHeaderMouseOver';
                                                                                                                                                                                                                                                                                          columnHeaderMouseLeave: 'columnHeaderMouseLeave';
                                                                                                                                                                                                                                                                                          columnHeaderClicked: 'columnHeaderClicked';
                                                                                                                                                                                                                                                                                          columnHeaderContextMenu: 'columnHeaderContextMenu';
                                                                                                                                                                                                                                                                                          componentStateChanged: 'componentStateChanged';
                                                                                                                                                                                                                                                                                          cellValueChanged: 'cellValueChanged';
                                                                                                                                                                                                                                                                                          cellEditRequest: 'cellEditRequest';
                                                                                                                                                                                                                                                                                          rowValueChanged: 'rowValueChanged';
                                                                                                                                                                                                                                                                                          cellEditingStarted: 'cellEditingStarted';
                                                                                                                                                                                                                                                                                          cellEditingStopped: 'cellEditingStopped';
                                                                                                                                                                                                                                                                                          rowEditingStarted: 'rowEditingStarted';
                                                                                                                                                                                                                                                                                          rowEditingStopped: 'rowEditingStopped';
                                                                                                                                                                                                                                                                                          undoStarted: 'undoStarted';
                                                                                                                                                                                                                                                                                          undoEnded: 'undoEnded';
                                                                                                                                                                                                                                                                                          redoStarted: 'redoStarted';
                                                                                                                                                                                                                                                                                          redoEnded: 'redoEnded';
                                                                                                                                                                                                                                                                                          cellSelectionDeleteStart: 'cellSelectionDeleteStart';
                                                                                                                                                                                                                                                                                          cellSelectionDeleteEnd: 'cellSelectionDeleteEnd';
                                                                                                                                                                                                                                                                                          rangeDeleteStart: 'rangeDeleteStart';
                                                                                                                                                                                                                                                                                          rangeDeleteEnd: 'rangeDeleteEnd';
                                                                                                                                                                                                                                                                                          fillStart: 'fillStart';
                                                                                                                                                                                                                                                                                          fillEnd: 'fillEnd';
                                                                                                                                                                                                                                                                                          filterOpened: 'filterOpened';
                                                                                                                                                                                                                                                                                          filterChanged: 'filterChanged';
                                                                                                                                                                                                                                                                                          filterModified: 'filterModified';
                                                                                                                                                                                                                                                                                          advancedFilterBuilderVisibleChanged: 'advancedFilterBuilderVisibleChanged';
                                                                                                                                                                                                                                                                                          chartCreated: 'chartCreated';
                                                                                                                                                                                                                                                                                          chartRangeSelectionChanged: 'chartRangeSelectionChanged';
                                                                                                                                                                                                                                                                                          chartOptionsChanged: 'chartOptionsChanged';
                                                                                                                                                                                                                                                                                          chartDestroyed: 'chartDestroyed';
                                                                                                                                                                                                                                                                                          cellKeyDown: 'cellKeyDown';
                                                                                                                                                                                                                                                                                          gridReady: 'gridReady';
                                                                                                                                                                                                                                                                                          firstDataRendered: 'firstDataRendered';
                                                                                                                                                                                                                                                                                          gridSizeChanged: 'gridSizeChanged';
                                                                                                                                                                                                                                                                                          modelUpdated: 'modelUpdated';
                                                                                                                                                                                                                                                                                          virtualRowRemoved: 'virtualRowRemoved';
                                                                                                                                                                                                                                                                                          viewportChanged: 'viewportChanged';
                                                                                                                                                                                                                                                                                          bodyScroll: 'bodyScroll';
                                                                                                                                                                                                                                                                                          bodyScrollEnd: 'bodyScrollEnd';
                                                                                                                                                                                                                                                                                          dragStarted: 'dragStarted';
                                                                                                                                                                                                                                                                                          dragStopped: 'dragStopped';
                                                                                                                                                                                                                                                                                          dragCancelled: 'dragCancelled';
                                                                                                                                                                                                                                                                                          stateUpdated: 'stateUpdated';
                                                                                                                                                                                                                                                                                          paginationChanged: 'paginationChanged';
                                                                                                                                                                                                                                                                                          rowDragEnter: 'rowDragEnter';
                                                                                                                                                                                                                                                                                          rowDragMove: 'rowDragMove';
                                                                                                                                                                                                                                                                                          rowDragLeave: 'rowDragLeave';
                                                                                                                                                                                                                                                                                          rowDragEnd: 'rowDragEnd';
                                                                                                                                                                                                                                                                                          rowDragCancel: 'rowDragCancel';
                                                                                                                                                                                                                                                                                          columnRowGroupChanged: 'columnRowGroupChanged';
                                                                                                                                                                                                                                                                                          rowGroupOpened: 'rowGroupOpened';
                                                                                                                                                                                                                                                                                          expandOrCollapseAll: 'expandOrCollapseAll';
                                                                                                                                                                                                                                                                                          pivotMaxColumnsExceeded: 'pivotMaxColumnsExceeded';
                                                                                                                                                                                                                                                                                          pinnedRowDataChanged: 'pinnedRowDataChanged';
                                                                                                                                                                                                                                                                                          rowDataUpdated: 'rowDataUpdated';
                                                                                                                                                                                                                                                                                          asyncTransactionsFlushed: 'asyncTransactionsFlushed';
                                                                                                                                                                                                                                                                                          storeRefreshed: 'storeRefreshed';
                                                                                                                                                                                                                                                                                          headerFocused: 'headerFocused';
                                                                                                                                                                                                                                                                                          cellClicked: 'cellClicked';
                                                                                                                                                                                                                                                                                          cellDoubleClicked: 'cellDoubleClicked';
                                                                                                                                                                                                                                                                                          cellFocused: 'cellFocused';
                                                                                                                                                                                                                                                                                          cellMouseOver: 'cellMouseOver';
                                                                                                                                                                                                                                                                                          cellMouseOut: 'cellMouseOut';
                                                                                                                                                                                                                                                                                          cellMouseDown: 'cellMouseDown';
                                                                                                                                                                                                                                                                                          rowClicked: 'rowClicked';
                                                                                                                                                                                                                                                                                          rowDoubleClicked: 'rowDoubleClicked';
                                                                                                                                                                                                                                                                                          rowSelected: 'rowSelected';
                                                                                                                                                                                                                                                                                          selectionChanged: 'selectionChanged';
                                                                                                                                                                                                                                                                                          cellContextMenu: 'cellContextMenu';
                                                                                                                                                                                                                                                                                          rangeSelectionChanged: 'rangeSelectionChanged';
                                                                                                                                                                                                                                                                                          cellSelectionChanged: 'cellSelectionChanged';
                                                                                                                                                                                                                                                                                          tooltipShow: 'tooltipShow';
                                                                                                                                                                                                                                                                                          tooltipHide: 'tooltipHide';
                                                                                                                                                                                                                                                                                          sortChanged: 'sortChanged';
                                                                                                                                                                                                                                                                                          },
                                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                                          never,
                                                                                                                                                                                                                                                                                          true,
                                                                                                                                                                                                                                                                                          never
                                                                                                                                                                                                                                                                                          >;

                                                                                                                                                                                                                                                                                            property ɵfac

                                                                                                                                                                                                                                                                                            static ɵfac: i0.ɵɵFactoryDeclaration<AgGridAngular<any, any>, never>;

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property pagination

                                                                                                                                                                                                                                                                                              pagination: boolean;
                                                                                                                                                                                                                                                                                              • Set whether pagination is enabled. false

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property paginationChanged

                                                                                                                                                                                                                                                                                              paginationChanged: EventEmitter<PaginationChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property paginationNumberFormatter

                                                                                                                                                                                                                                                                                              paginationNumberFormatter: (
                                                                                                                                                                                                                                                                                              params: PaginationNumberFormatterParams<TData>
                                                                                                                                                                                                                                                                                              ) => string;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property paginationPageSize

                                                                                                                                                                                                                                                                                              paginationPageSize: number;
                                                                                                                                                                                                                                                                                              • How many rows to load per page. If paginationAutoPageSize is specified, this property is ignored. 100

                                                                                                                                                                                                                                                                                              property paginationPageSizeSelector

                                                                                                                                                                                                                                                                                              paginationPageSizeSelector: boolean | number[];
                                                                                                                                                                                                                                                                                              • 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

                                                                                                                                                                                                                                                                                              property pasteEnd

                                                                                                                                                                                                                                                                                              pasteEnd: EventEmitter<PasteEndEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Paste operation has ended.

                                                                                                                                                                                                                                                                                              property pasteStart

                                                                                                                                                                                                                                                                                              pasteStart: EventEmitter<PasteStartEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Paste operation has started.

                                                                                                                                                                                                                                                                                              property pinnedBottomRowData

                                                                                                                                                                                                                                                                                              pinnedBottomRowData: any[];
                                                                                                                                                                                                                                                                                              • Data to be displayed as pinned bottom rows in the grid.

                                                                                                                                                                                                                                                                                              property pinnedRowDataChanged

                                                                                                                                                                                                                                                                                              pinnedRowDataChanged: EventEmitter<PinnedRowDataChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • The client has set new pinned row data into the grid.

                                                                                                                                                                                                                                                                                              property pinnedTopRowData

                                                                                                                                                                                                                                                                                              pinnedTopRowData: any[];
                                                                                                                                                                                                                                                                                              • Data to be displayed as pinned top rows in the grid.

                                                                                                                                                                                                                                                                                              property pivotColumnGroupTotals

                                                                                                                                                                                                                                                                                              pivotColumnGroupTotals: 'before' | 'after';
                                                                                                                                                                                                                                                                                              • When set and the grid is in pivot mode, automatically calculated totals will appear within the Pivot Column Groups, in the position specified.

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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 pivotMaxColumnsExceeded

                                                                                                                                                                                                                                                                                              pivotMaxColumnsExceeded: EventEmitter<PivotMaxColumnsExceededEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Exceeded the pivotMaxGeneratedColumns limit when generating columns.

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property pivotMode

                                                                                                                                                                                                                                                                                              pivotMode: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to enable pivot mode. false

                                                                                                                                                                                                                                                                                              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'

                                                                                                                                                                                                                                                                                              property pivotRowTotals

                                                                                                                                                                                                                                                                                              pivotRowTotals: 'before' | 'after';
                                                                                                                                                                                                                                                                                              • When set and the grid is in pivot mode, automatically calculated totals will appear for each value column in the position specified.

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property popupParent

                                                                                                                                                                                                                                                                                              popupParent: HTMLElement;
                                                                                                                                                                                                                                                                                              • DOM element to use as the popup parent for grid popups (context menu, column menu etc).

                                                                                                                                                                                                                                                                                              property postProcessPopup

                                                                                                                                                                                                                                                                                              postProcessPopup: (params: PostProcessPopupParams<TData>) => void;
                                                                                                                                                                                                                                                                                              • 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: (params: PostSortRowsParams<TData>) => void;
                                                                                                                                                                                                                                                                                              • Callback to perform additional sorting after the grid has sorted the rows.

                                                                                                                                                                                                                                                                                              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: (params: ProcessCellForExportParams<TData>) => any;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property processCellFromClipboard

                                                                                                                                                                                                                                                                                              processCellFromClipboard: (params: ProcessCellForExportParams<TData>) => any;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property processDataFromClipboard

                                                                                                                                                                                                                                                                                              processDataFromClipboard: (
                                                                                                                                                                                                                                                                                              params: ProcessDataFromClipboardParams<TData>
                                                                                                                                                                                                                                                                                              ) => string[][] | null;
                                                                                                                                                                                                                                                                                              • Allows complete control of the paste operation, including cancelling the operation (so nothing happens) or replacing the data with other data.

                                                                                                                                                                                                                                                                                              property processGroupHeaderForClipboard

                                                                                                                                                                                                                                                                                              processGroupHeaderForClipboard: (
                                                                                                                                                                                                                                                                                              params: ProcessGroupHeaderForExportParams<TData>
                                                                                                                                                                                                                                                                                              ) => any;
                                                                                                                                                                                                                                                                                              • Allows you to process group header values for the clipboard.

                                                                                                                                                                                                                                                                                              property processHeaderForClipboard

                                                                                                                                                                                                                                                                                              processHeaderForClipboard: (params: ProcessHeaderForExportParams<TData>) => any;
                                                                                                                                                                                                                                                                                              • Allows you to process header values for the clipboard.

                                                                                                                                                                                                                                                                                              property processPivotResultColDef

                                                                                                                                                                                                                                                                                              processPivotResultColDef: (colDef: ColDef<TData>) => void;
                                                                                                                                                                                                                                                                                              • Callback for the mutation of the generated pivot result column definitions

                                                                                                                                                                                                                                                                                              property processPivotResultColGroupDef

                                                                                                                                                                                                                                                                                              processPivotResultColGroupDef: (colGroupDef: ColGroupDef<TData>) => void;
                                                                                                                                                                                                                                                                                              • Callback for the mutation of the generated pivot result column group definitions

                                                                                                                                                                                                                                                                                              property processRowPostCreate

                                                                                                                                                                                                                                                                                              processRowPostCreate: (params: ProcessRowParams<TData>) => void;
                                                                                                                                                                                                                                                                                              • Callback fired after the row is rendered into the DOM. Should not be used to initiate side effects.

                                                                                                                                                                                                                                                                                              property processUnpinnedColumns

                                                                                                                                                                                                                                                                                              processUnpinnedColumns: (
                                                                                                                                                                                                                                                                                              params: ProcessUnpinnedColumnsParams<TData>
                                                                                                                                                                                                                                                                                              ) => Column[];
                                                                                                                                                                                                                                                                                              • 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

                                                                                                                                                                                                                                                                                              property quickFilterMatcher

                                                                                                                                                                                                                                                                                              quickFilterMatcher: (
                                                                                                                                                                                                                                                                                              quickFilterParts: string[],
                                                                                                                                                                                                                                                                                              rowQuickFilterAggregateText: string
                                                                                                                                                                                                                                                                                              ) => boolean;
                                                                                                                                                                                                                                                                                              • Changes the matching logic for whether a row passes the Quick Filter.

                                                                                                                                                                                                                                                                                              property quickFilterParser

                                                                                                                                                                                                                                                                                              quickFilterParser: (quickFilter: string) => string[];
                                                                                                                                                                                                                                                                                              • Changes how the Quick Filter splits the Quick Filter text into search terms.

                                                                                                                                                                                                                                                                                              property quickFilterText

                                                                                                                                                                                                                                                                                              quickFilterText: string;
                                                                                                                                                                                                                                                                                              • Rows are filtered using this text as a Quick Filter. Only supported for Client-Side Row Model.

                                                                                                                                                                                                                                                                                              property rangeDeleteEnd

                                                                                                                                                                                                                                                                                              rangeDeleteEnd: EventEmitter<RangeDeleteEndEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Range delete operation (cell clear) has ended.

                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                v32.2 Use onCellSelectionDeleteEnd instead

                                                                                                                                                                                                                                                                                              property rangeDeleteStart

                                                                                                                                                                                                                                                                                              rangeDeleteStart: EventEmitter<RangeDeleteStartEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Range delete operation (cell clear) has started.

                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                v32.2 Use onCellSelectionDeleteStart instead

                                                                                                                                                                                                                                                                                              property rangeSelectionChanged

                                                                                                                                                                                                                                                                                              rangeSelectionChanged: EventEmitter<RangeSelectionChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • A change to range selection has occurred.

                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                v32.2 Use onCellSelectionChanged instead

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property redoEnded

                                                                                                                                                                                                                                                                                              redoEnded: EventEmitter<RedoEndedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Redo operation has ended.

                                                                                                                                                                                                                                                                                              property redoStarted

                                                                                                                                                                                                                                                                                              redoStarted: EventEmitter<RedoStartedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Redo operation has started.

                                                                                                                                                                                                                                                                                              property removePivotHeaderRowWhenSingleValueColumn

                                                                                                                                                                                                                                                                                              removePivotHeaderRowWhenSingleValueColumn: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to omit the value Column header when there is only a single value column. false

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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).

                                                                                                                                                                                                                                                                                              property rowClassRules

                                                                                                                                                                                                                                                                                              rowClassRules: any;
                                                                                                                                                                                                                                                                                              • Rules which can be applied to include certain CSS classes.

                                                                                                                                                                                                                                                                                              property rowClicked

                                                                                                                                                                                                                                                                                              rowClicked: EventEmitter<RowClickedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Row is clicked.

                                                                                                                                                                                                                                                                                              property rowData

                                                                                                                                                                                                                                                                                              rowData: TData[];
                                                                                                                                                                                                                                                                                              • Set the data to be displayed as rows in the grid.

                                                                                                                                                                                                                                                                                              property rowDataUpdated

                                                                                                                                                                                                                                                                                              rowDataUpdated: EventEmitter<RowDataUpdatedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property rowDoubleClicked

                                                                                                                                                                                                                                                                                              rowDoubleClicked: EventEmitter<RowDoubleClickedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Row is double clicked.

                                                                                                                                                                                                                                                                                              property rowDragCancel

                                                                                                                                                                                                                                                                                              rowDragCancel: EventEmitter<RowDragCancelEvent<TData>>;
                                                                                                                                                                                                                                                                                              • The drag has been cancelled over the grid.

                                                                                                                                                                                                                                                                                              property rowDragEnd

                                                                                                                                                                                                                                                                                              rowDragEnd: EventEmitter<RowDragEndEvent<TData>>;
                                                                                                                                                                                                                                                                                              • The drag has finished over the grid.

                                                                                                                                                                                                                                                                                              property rowDragEnter

                                                                                                                                                                                                                                                                                              rowDragEnter: EventEmitter<RowDragEnterEvent<TData>>;
                                                                                                                                                                                                                                                                                              • A drag has started, or dragging was already started and the mouse has re-entered the grid having previously left the grid.

                                                                                                                                                                                                                                                                                              property rowDragEntireRow

                                                                                                                                                                                                                                                                                              rowDragEntireRow: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to enable clicking and dragging anywhere on the row without the need for a drag handle. false

                                                                                                                                                                                                                                                                                              property rowDragLeave

                                                                                                                                                                                                                                                                                              rowDragLeave: EventEmitter<RowDragLeaveEvent<TData>>;
                                                                                                                                                                                                                                                                                              • The mouse has left the grid while dragging.

                                                                                                                                                                                                                                                                                              property rowDragManaged

                                                                                                                                                                                                                                                                                              rowDragManaged: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to enable Managed Row Dragging. false

                                                                                                                                                                                                                                                                                              property rowDragMove

                                                                                                                                                                                                                                                                                              rowDragMove: EventEmitter<RowDragMoveEvent<TData>>;
                                                                                                                                                                                                                                                                                              • The mouse has moved while dragging.

                                                                                                                                                                                                                                                                                              property rowDragMultiRow

                                                                                                                                                                                                                                                                                              rowDragMultiRow: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to enable dragging multiple rows at the same time. false

                                                                                                                                                                                                                                                                                              property rowDragText

                                                                                                                                                                                                                                                                                              rowDragText: (params: IRowDragItem, dragItemCount: number) => string;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property rowEditingStarted

                                                                                                                                                                                                                                                                                              rowEditingStarted: EventEmitter<RowEditingStartedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property rowEditingStopped

                                                                                                                                                                                                                                                                                              rowEditingStopped: EventEmitter<RowEditingStoppedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property rowGroupOpened

                                                                                                                                                                                                                                                                                              rowGroupOpened: EventEmitter<RowGroupOpenedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • A row group was opened or closed.

                                                                                                                                                                                                                                                                                              property rowGroupPanelShow

                                                                                                                                                                                                                                                                                              rowGroupPanelShow: 'always' | 'never' | 'onlyWhenGrouping';
                                                                                                                                                                                                                                                                                              • When to show the 'row group panel' (where you drag rows to group) at the top. 'never'

                                                                                                                                                                                                                                                                                              property rowGroupPanelSuppressSort

                                                                                                                                                                                                                                                                                              rowGroupPanelSuppressSort: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to suppress sort indicators and actions from the row group panel. false

                                                                                                                                                                                                                                                                                              property rowHeight

                                                                                                                                                                                                                                                                                              rowHeight: number;
                                                                                                                                                                                                                                                                                              • Default row height in pixels. 25

                                                                                                                                                                                                                                                                                              property rowModelType

                                                                                                                                                                                                                                                                                              rowModelType: any;
                                                                                                                                                                                                                                                                                              • Sets the row model type. 'clientSide'

                                                                                                                                                                                                                                                                                              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: any;
                                                                                                                                                                                                                                                                                              • Configure the Row Numbers Feature. false

                                                                                                                                                                                                                                                                                              property rowSelected

                                                                                                                                                                                                                                                                                              rowSelected: EventEmitter<RowSelectedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property rowSelection

                                                                                                                                                                                                                                                                                              rowSelection: any;
                                                                                                                                                                                                                                                                                              • Use the RowSelectionOptions object to configure row selection. The string values 'single' and 'multiple' are deprecated.

                                                                                                                                                                                                                                                                                              property rowStyle

                                                                                                                                                                                                                                                                                              rowStyle: any;
                                                                                                                                                                                                                                                                                              • The style properties to apply to all rows. Set to an object of key (style names) and values (style values).

                                                                                                                                                                                                                                                                                              property rowValueChanged

                                                                                                                                                                                                                                                                                              rowValueChanged: EventEmitter<RowValueChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • A cell's value within a row has changed. This event corresponds to Full Row Editing only.

                                                                                                                                                                                                                                                                                              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 selectionChanged

                                                                                                                                                                                                                                                                                              selectionChanged: EventEmitter<SelectionChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Row selection is changed. Use the grid API getSelectedNodes() or getSelectedRows() to get the new list of selected nodes / row data.

                                                                                                                                                                                                                                                                                              property selectionColumnDef

                                                                                                                                                                                                                                                                                              selectionColumnDef: any;
                                                                                                                                                                                                                                                                                              • 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: (params: SendToClipboardParams<TData>) => void;
                                                                                                                                                                                                                                                                                              • 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.

                                                                                                                                                                                                                                                                                              property serverSideDatasource

                                                                                                                                                                                                                                                                                              serverSideDatasource: any;
                                                                                                                                                                                                                                                                                              • Provide the serverSideDatasource for server side row model.

                                                                                                                                                                                                                                                                                              property serverSideEnableClientSideSort

                                                                                                                                                                                                                                                                                              serverSideEnableClientSideSort: boolean;
                                                                                                                                                                                                                                                                                              • When enabled, sorts fully loaded groups in the browser instead of requesting from the server. false

                                                                                                                                                                                                                                                                                              property serverSideInitialRowCount

                                                                                                                                                                                                                                                                                              serverSideInitialRowCount: number;
                                                                                                                                                                                                                                                                                              • Set how many loading rows to display to the user for the root level group. 1

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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. '_'

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property showOpenedGroup

                                                                                                                                                                                                                                                                                              showOpenedGroup: boolean;
                                                                                                                                                                                                                                                                                              • Shows the open group in the group column for non-group rows. false

                                                                                                                                                                                                                                                                                              property sideBar

                                                                                                                                                                                                                                                                                              sideBar: any;
                                                                                                                                                                                                                                                                                              • Specifies the side bar components.

                                                                                                                                                                                                                                                                                              property singleClickEdit

                                                                                                                                                                                                                                                                                              singleClickEdit: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to enable Single Click Editing for cells, to start editing with a single click. false

                                                                                                                                                                                                                                                                                              property skipHeaderOnAutoSize

                                                                                                                                                                                                                                                                                              skipHeaderOnAutoSize: boolean;
                                                                                                                                                                                                                                                                                              • Set this to true to skip the headerName when autoSize is called by default. false

                                                                                                                                                                                                                                                                                              property sortChanged

                                                                                                                                                                                                                                                                                              sortChanged: EventEmitter<SortChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Sort has changed. The grid also listens for this and updates the model.

                                                                                                                                                                                                                                                                                              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 stateUpdated

                                                                                                                                                                                                                                                                                              stateUpdated: EventEmitter<StateUpdatedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • Grid state has been updated.

                                                                                                                                                                                                                                                                                              property statusBar

                                                                                                                                                                                                                                                                                              statusBar: { statusPanels: StatusPanelDef[] };
                                                                                                                                                                                                                                                                                              • Specifies the status bar components to use in the status bar.

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property storeRefreshed

                                                                                                                                                                                                                                                                                              storeRefreshed: EventEmitter<StoreRefreshedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • A server side store has finished refreshing.

                                                                                                                                                                                                                                                                                              property suppressAdvancedFilterEval

                                                                                                                                                                                                                                                                                              suppressAdvancedFilterEval: boolean;
                                                                                                                                                                                                                                                                                              • By default, Advanced Filter sanitises user input and passes it to new Function() to provide the best performance. Set to true to prevent this and use defined functions instead. This will result in slower filtering, but it enables Advanced Filter to work when unsafe-eval is disabled. false

                                                                                                                                                                                                                                                                                              property suppressAggFilteredOnly

                                                                                                                                                                                                                                                                                              suppressAggFilteredOnly: boolean;
                                                                                                                                                                                                                                                                                              • Set to true so that aggregations are not impacted by filtering. false

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property suppressAnimationFrame

                                                                                                                                                                                                                                                                                              suppressAnimationFrame: boolean;
                                                                                                                                                                                                                                                                                              • When true, the grid will not use animation frames when drawing rows while scrolling. Use this if the grid is working fast enough that you don't need animation frames and you don't want the grid to flicker. 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

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property suppressClipboardPaste

                                                                                                                                                                                                                                                                                              suppressClipboardPaste: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to turn off paste operations within the grid. false

                                                                                                                                                                                                                                                                                              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. 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

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property suppressLoadingOverlay

                                                                                                                                                                                                                                                                                              suppressLoadingOverlay: boolean;
                                                                                                                                                                                                                                                                                              • Disables the 'loading' overlay.

                                                                                                                                                                                                                                                                                                Deprecated

                                                                                                                                                                                                                                                                                                v32 - Deprecated. Use 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

                                                                                                                                                                                                                                                                                              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. false

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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. 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.

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property suppressStickyTotalRow

                                                                                                                                                                                                                                                                                              suppressStickyTotalRow: boolean | 'grand' | 'group';
                                                                                                                                                                                                                                                                                              • Suppress the sticky behaviour of the total rows, can be suppressed individually by passing 'grand' or 'group'.

                                                                                                                                                                                                                                                                                              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: (params: TabToNextCellParams<TData>) => CellPosition | boolean;
                                                                                                                                                                                                                                                                                              • 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 tabToNextHeader

                                                                                                                                                                                                                                                                                              tabToNextHeader: (
                                                                                                                                                                                                                                                                                              params: TabToNextHeaderParams<TData>
                                                                                                                                                                                                                                                                                              ) => HeaderPosition | boolean;
                                                                                                                                                                                                                                                                                              • 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: any;
                                                                                                                                                                                                                                                                                              • 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. If your application loads its styles into a CSS layer, use this to load the grid styles into a previous layer so that application styles can override grid styles.

                                                                                                                                                                                                                                                                                                See Also

                                                                                                                                                                                                                                                                                                • https://developer.mozilla.org/en-US/docs/Web/CSS/@layer

                                                                                                                                                                                                                                                                                              property themeStyleContainer

                                                                                                                                                                                                                                                                                              themeStyleContainer: HTMLElement;
                                                                                                                                                                                                                                                                                              • An element to insert style elements into when injecting styles into the grid. 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).

                                                                                                                                                                                                                                                                                              property toolPanelSizeChanged

                                                                                                                                                                                                                                                                                              toolPanelSizeChanged: EventEmitter<ToolPanelSizeChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • The tool panel size has been changed.

                                                                                                                                                                                                                                                                                              property toolPanelVisibleChanged

                                                                                                                                                                                                                                                                                              toolPanelVisibleChanged: EventEmitter<ToolPanelVisibleChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                              • The tool panel visibility has changed. Fires twice if switching between panels - once with the old panel and once with the new panel.

                                                                                                                                                                                                                                                                                              property tooltipHide

                                                                                                                                                                                                                                                                                              tooltipHide: EventEmitter<TooltipHideEvent<TData>>;
                                                                                                                                                                                                                                                                                              • A tooltip was hidden

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              property tooltipMouseTrack

                                                                                                                                                                                                                                                                                              tooltipMouseTrack: boolean;
                                                                                                                                                                                                                                                                                              • Set to true to have tooltips follow the cursor once they are displayed. false

                                                                                                                                                                                                                                                                                              property tooltipShow

                                                                                                                                                                                                                                                                                              tooltipShow: EventEmitter<TooltipShowEvent<TData>>;
                                                                                                                                                                                                                                                                                              • A tooltip has been displayed

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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'

                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                              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.

                                                                                                                                                                                                                                                                                              property treeDataDisplayType

                                                                                                                                                                                                                                                                                              treeDataDisplayType: any;

                                                                                                                                                                                                                                                                                                property undoEnded

                                                                                                                                                                                                                                                                                                undoEnded: EventEmitter<UndoEndedEvent<TData>>;
                                                                                                                                                                                                                                                                                                • Undo operation has ended.

                                                                                                                                                                                                                                                                                                property undoRedoCellEditing

                                                                                                                                                                                                                                                                                                undoRedoCellEditing: boolean;
                                                                                                                                                                                                                                                                                                • Set to true to enable Undo / Redo while editing.

                                                                                                                                                                                                                                                                                                property undoRedoCellEditingLimit

                                                                                                                                                                                                                                                                                                undoRedoCellEditingLimit: number;
                                                                                                                                                                                                                                                                                                • Set the size of the undo / redo stack. 10

                                                                                                                                                                                                                                                                                                property undoStarted

                                                                                                                                                                                                                                                                                                undoStarted: EventEmitter<UndoStartedEvent<TData>>;
                                                                                                                                                                                                                                                                                                • Undo operation has started.

                                                                                                                                                                                                                                                                                                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

                                                                                                                                                                                                                                                                                                property valueCacheNeverExpires

                                                                                                                                                                                                                                                                                                valueCacheNeverExpires: boolean;
                                                                                                                                                                                                                                                                                                • Set to true to configure the value cache to not expire after data updates. false

                                                                                                                                                                                                                                                                                                property viewportChanged

                                                                                                                                                                                                                                                                                                viewportChanged: EventEmitter<ViewportChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                                • Which rows are rendered in the DOM has changed.

                                                                                                                                                                                                                                                                                                property viewportDatasource

                                                                                                                                                                                                                                                                                                viewportDatasource: any;
                                                                                                                                                                                                                                                                                                • To use the viewport row model you need to provide the grid with a viewportDatasource.

                                                                                                                                                                                                                                                                                                property viewportRowModelBufferSize

                                                                                                                                                                                                                                                                                                viewportRowModelBufferSize: number;
                                                                                                                                                                                                                                                                                                • When using viewport row model, sets the buffer size for the viewport.

                                                                                                                                                                                                                                                                                                property viewportRowModelPageSize

                                                                                                                                                                                                                                                                                                viewportRowModelPageSize: number;
                                                                                                                                                                                                                                                                                                • When using viewport row model, sets the page size for the viewport.

                                                                                                                                                                                                                                                                                                property virtualColumnsChanged

                                                                                                                                                                                                                                                                                                virtualColumnsChanged: EventEmitter<VirtualColumnsChangedEvent<TData>>;
                                                                                                                                                                                                                                                                                                • The list of rendered columns changed (only columns in the visible scrolled viewport are rendered by default).

                                                                                                                                                                                                                                                                                                property virtualRowRemoved

                                                                                                                                                                                                                                                                                                virtualRowRemoved: EventEmitter<VirtualRowRemovedEvent<TData>>;
                                                                                                                                                                                                                                                                                                • A row was removed from the DOM, for any reason. Use to clean up resources (if any) used by the row.

                                                                                                                                                                                                                                                                                                method isEmitterUsed

                                                                                                                                                                                                                                                                                                protected isEmitterUsed: (eventType: string) => boolean;

                                                                                                                                                                                                                                                                                                  method ngAfterViewInit

                                                                                                                                                                                                                                                                                                  ngAfterViewInit: () => void;

                                                                                                                                                                                                                                                                                                    method ngOnChanges

                                                                                                                                                                                                                                                                                                    ngOnChanges: (changes: any) => void;

                                                                                                                                                                                                                                                                                                      method ngOnDestroy

                                                                                                                                                                                                                                                                                                      ngOnDestroy: () => void;

                                                                                                                                                                                                                                                                                                        class AgGridModule

                                                                                                                                                                                                                                                                                                        class AgGridModule {}

                                                                                                                                                                                                                                                                                                          property ɵfac

                                                                                                                                                                                                                                                                                                          static ɵfac: i0.ɵɵFactoryDeclaration<AgGridModule, never>;

                                                                                                                                                                                                                                                                                                            property ɵinj

                                                                                                                                                                                                                                                                                                            static ɵinj: i0.ɵɵInjectorDeclaration<AgGridModule>;

                                                                                                                                                                                                                                                                                                              property ɵmod

                                                                                                                                                                                                                                                                                                              static ɵmod: i0.ɵɵNgModuleDeclaration<
                                                                                                                                                                                                                                                                                                              AgGridModule,
                                                                                                                                                                                                                                                                                                              never,
                                                                                                                                                                                                                                                                                                              [typeof i1.AgGridAngular],
                                                                                                                                                                                                                                                                                                              [typeof i1.AgGridAngular]
                                                                                                                                                                                                                                                                                                              >;

                                                                                                                                                                                                                                                                                                                class AngularFrameworkComponentWrapper

                                                                                                                                                                                                                                                                                                                class AngularFrameworkComponentWrapper
                                                                                                                                                                                                                                                                                                                extends BaseComponentWrapper<WrappableInterface>
                                                                                                                                                                                                                                                                                                                implements FrameworkComponentWrapper {}

                                                                                                                                                                                                                                                                                                                  property ɵfac

                                                                                                                                                                                                                                                                                                                  static ɵfac: i0.ɵɵFactoryDeclaration<AngularFrameworkComponentWrapper, never>;

                                                                                                                                                                                                                                                                                                                    property ɵprov

                                                                                                                                                                                                                                                                                                                    static ɵprov: i0.ɵɵInjectableDeclaration<AngularFrameworkComponentWrapper>;

                                                                                                                                                                                                                                                                                                                      method createComponent

                                                                                                                                                                                                                                                                                                                      createComponent: <T>(
                                                                                                                                                                                                                                                                                                                      componentType: new (...args: any[]) => T
                                                                                                                                                                                                                                                                                                                      ) => ComponentRef<T>;

                                                                                                                                                                                                                                                                                                                        method createWrapper

                                                                                                                                                                                                                                                                                                                        protected createWrapper: (OriginalConstructor: {
                                                                                                                                                                                                                                                                                                                        new (): any;
                                                                                                                                                                                                                                                                                                                        }) => WrappableInterface;

                                                                                                                                                                                                                                                                                                                          method setViewContainerRef

                                                                                                                                                                                                                                                                                                                          setViewContainerRef: (
                                                                                                                                                                                                                                                                                                                          viewContainerRef: ViewContainerRef,
                                                                                                                                                                                                                                                                                                                          angularFrameworkOverrides: AngularFrameworkOverrides
                                                                                                                                                                                                                                                                                                                          ) => void;

                                                                                                                                                                                                                                                                                                                            class AngularFrameworkOverrides

                                                                                                                                                                                                                                                                                                                            class AngularFrameworkOverrides extends VanillaFrameworkOverrides {}

                                                                                                                                                                                                                                                                                                                              constructor

                                                                                                                                                                                                                                                                                                                              constructor(_ngZone: NgZone);

                                                                                                                                                                                                                                                                                                                                property ɵfac

                                                                                                                                                                                                                                                                                                                                static ɵfac: i0.ɵɵFactoryDeclaration<AngularFrameworkOverrides, never>;

                                                                                                                                                                                                                                                                                                                                  property ɵprov

                                                                                                                                                                                                                                                                                                                                  static ɵprov: i0.ɵɵInjectableDeclaration<AngularFrameworkOverrides>;

                                                                                                                                                                                                                                                                                                                                    property shouldWrapOutgoing

                                                                                                                                                                                                                                                                                                                                    readonly shouldWrapOutgoing: boolean;
                                                                                                                                                                                                                                                                                                                                    • The shouldWrapOutgoing property is used to determine if events should be run outside of Angular or not. If an event handler is registered outside of Angular then we should not wrap the event handler with runInsideAngular() as the user may not have wanted this. This is also used to not wrap internal event listeners that are registered with RowNodes and Columns.

                                                                                                                                                                                                                                                                                                                                    property wrapIncoming

                                                                                                                                                                                                                                                                                                                                    wrapIncoming: <T>(
                                                                                                                                                                                                                                                                                                                                    callback: () => T,
                                                                                                                                                                                                                                                                                                                                    source?: FrameworkOverridesIncomingSource
                                                                                                                                                                                                                                                                                                                                    ) => T;

                                                                                                                                                                                                                                                                                                                                      property wrapOutgoing

                                                                                                                                                                                                                                                                                                                                      wrapOutgoing: <T>(callback: () => T) => T;
                                                                                                                                                                                                                                                                                                                                      • Make sure that any code that is executed outside of AG Grid is running within the Angular zone. This means users can update templates and use binding without having to do anything extra.

                                                                                                                                                                                                                                                                                                                                      method createGlobalEventListenerWrapper

                                                                                                                                                                                                                                                                                                                                      createGlobalEventListenerWrapper: () => IFrameworkEventListenerService<any, any>;

                                                                                                                                                                                                                                                                                                                                        method createLocalEventListenerWrapper

                                                                                                                                                                                                                                                                                                                                        createLocalEventListenerWrapper: (
                                                                                                                                                                                                                                                                                                                                        existingFrameworkEventListenerService:
                                                                                                                                                                                                                                                                                                                                        | IFrameworkEventListenerService<any, any>
                                                                                                                                                                                                                                                                                                                                        | undefined,
                                                                                                                                                                                                                                                                                                                                        localEventService: LocalEventService<any>
                                                                                                                                                                                                                                                                                                                                        ) => IFrameworkEventListenerService<any, any> | undefined;

                                                                                                                                                                                                                                                                                                                                          method isFrameworkComponent

                                                                                                                                                                                                                                                                                                                                          isFrameworkComponent: (comp: any) => boolean;

                                                                                                                                                                                                                                                                                                                                            method runInsideAngular

                                                                                                                                                                                                                                                                                                                                            runInsideAngular: <T>(callback: () => T) => T;

                                                                                                                                                                                                                                                                                                                                              method runOutsideAngular

                                                                                                                                                                                                                                                                                                                                              runOutsideAngular: <T>(
                                                                                                                                                                                                                                                                                                                                              callback: () => T,
                                                                                                                                                                                                                                                                                                                                              source?: FrameworkOverridesIncomingSource
                                                                                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                                                                                Interfaces

                                                                                                                                                                                                                                                                                                                                                interface AgEditorComponent

                                                                                                                                                                                                                                                                                                                                                interface AgEditorComponent extends ICellEditorAngularComp {}

                                                                                                                                                                                                                                                                                                                                                  interface AgFilterComponent

                                                                                                                                                                                                                                                                                                                                                  interface AgFilterComponent extends IFilterAngularComp {}

                                                                                                                                                                                                                                                                                                                                                    interface AgFloatingFilterComponent

                                                                                                                                                                                                                                                                                                                                                    interface AgFloatingFilterComponent extends IFloatingFilterAngularComp {}

                                                                                                                                                                                                                                                                                                                                                      interface AgFrameworkComponent

                                                                                                                                                                                                                                                                                                                                                      interface AgFrameworkComponent<T> {}

                                                                                                                                                                                                                                                                                                                                                        method agInit

                                                                                                                                                                                                                                                                                                                                                        agInit: (params: T) => void;
                                                                                                                                                                                                                                                                                                                                                        • Mandatory - Params for rendering this component.

                                                                                                                                                                                                                                                                                                                                                        interface AgRendererComponent

                                                                                                                                                                                                                                                                                                                                                        interface AgRendererComponent extends ICellRendererAngularComp {}

                                                                                                                                                                                                                                                                                                                                                          interface ICellEditorAngularComp

                                                                                                                                                                                                                                                                                                                                                          interface ICellEditorAngularComp
                                                                                                                                                                                                                                                                                                                                                          extends AgFrameworkComponent<ICellEditorParams>,
                                                                                                                                                                                                                                                                                                                                                          ICellEditor {}

                                                                                                                                                                                                                                                                                                                                                            interface ICellEditorRendererAngularComp

                                                                                                                                                                                                                                                                                                                                                            interface ICellEditorRendererAngularComp
                                                                                                                                                                                                                                                                                                                                                            extends AgFrameworkComponent<ICellEditorRendererParams> {}

                                                                                                                                                                                                                                                                                                                                                              interface ICellRendererAngularComp

                                                                                                                                                                                                                                                                                                                                                              interface ICellRendererAngularComp
                                                                                                                                                                                                                                                                                                                                                              extends AgFrameworkComponent<ICellRendererParams>,
                                                                                                                                                                                                                                                                                                                                                              ICellRenderer {}

                                                                                                                                                                                                                                                                                                                                                                interface IDateAngularComp

                                                                                                                                                                                                                                                                                                                                                                interface IDateAngularComp extends AgFrameworkComponent<IDateParams>, IDate {}

                                                                                                                                                                                                                                                                                                                                                                  interface IDragAndDropImageAngularComponent

                                                                                                                                                                                                                                                                                                                                                                  interface IDragAndDropImageAngularComponent
                                                                                                                                                                                                                                                                                                                                                                  extends AgFrameworkComponent<IDragAndDropImageParams>,
                                                                                                                                                                                                                                                                                                                                                                  IDragAndDropImage {}

                                                                                                                                                                                                                                                                                                                                                                    interface IFilterAngularComp

                                                                                                                                                                                                                                                                                                                                                                    interface IFilterAngularComp extends AgFrameworkComponent<IFilterParams>, IFilter {}

                                                                                                                                                                                                                                                                                                                                                                      interface IFloatingFilterAngularComp

                                                                                                                                                                                                                                                                                                                                                                      interface IFloatingFilterAngularComp<P = any>
                                                                                                                                                                                                                                                                                                                                                                      extends AgFrameworkComponent<IFloatingFilterParams<P>>,
                                                                                                                                                                                                                                                                                                                                                                      IFloatingFilter {}

                                                                                                                                                                                                                                                                                                                                                                        interface IHeaderAngularComp

                                                                                                                                                                                                                                                                                                                                                                        interface IHeaderAngularComp extends AgFrameworkComponent<IHeaderParams>, IHeader {}

                                                                                                                                                                                                                                                                                                                                                                          interface IHeaderGroupAngularComp

                                                                                                                                                                                                                                                                                                                                                                          interface IHeaderGroupAngularComp
                                                                                                                                                                                                                                                                                                                                                                          extends AgFrameworkComponent<IHeaderGroupParams>,
                                                                                                                                                                                                                                                                                                                                                                          IHeaderGroup {}

                                                                                                                                                                                                                                                                                                                                                                            interface IInnerHeaderAngularComp

                                                                                                                                                                                                                                                                                                                                                                            interface IInnerHeaderAngularComp
                                                                                                                                                                                                                                                                                                                                                                            extends AgFrameworkComponent<IHeaderParams>,
                                                                                                                                                                                                                                                                                                                                                                            IHeader {}

                                                                                                                                                                                                                                                                                                                                                                              interface IInnerHeaderGroupAngularComp

                                                                                                                                                                                                                                                                                                                                                                              interface IInnerHeaderGroupAngularComp
                                                                                                                                                                                                                                                                                                                                                                              extends AgFrameworkComponent<IHeaderGroupParams>,
                                                                                                                                                                                                                                                                                                                                                                              IHeaderGroup {}

                                                                                                                                                                                                                                                                                                                                                                                interface ILoadingCellRendererAngularComp

                                                                                                                                                                                                                                                                                                                                                                                interface ILoadingCellRendererAngularComp
                                                                                                                                                                                                                                                                                                                                                                                extends AgFrameworkComponent<ILoadingCellRendererParams> {}

                                                                                                                                                                                                                                                                                                                                                                                  interface ILoadingOverlayAngularComp

                                                                                                                                                                                                                                                                                                                                                                                  interface ILoadingOverlayAngularComp
                                                                                                                                                                                                                                                                                                                                                                                  extends AgFrameworkComponent<ILoadingOverlayParams>,
                                                                                                                                                                                                                                                                                                                                                                                  ILoadingOverlay {}

                                                                                                                                                                                                                                                                                                                                                                                    interface IMenuItemAngularComp

                                                                                                                                                                                                                                                                                                                                                                                    interface IMenuItemAngularComp
                                                                                                                                                                                                                                                                                                                                                                                    extends AgFrameworkComponent<IMenuItemParams>,
                                                                                                                                                                                                                                                                                                                                                                                    IMenuItem {}

                                                                                                                                                                                                                                                                                                                                                                                      interface INoRowsOverlayAngularComp

                                                                                                                                                                                                                                                                                                                                                                                      interface INoRowsOverlayAngularComp
                                                                                                                                                                                                                                                                                                                                                                                      extends AgFrameworkComponent<INoRowsOverlayParams>,
                                                                                                                                                                                                                                                                                                                                                                                      INoRowsOverlay {}

                                                                                                                                                                                                                                                                                                                                                                                        interface IStatusPanelAngularComp

                                                                                                                                                                                                                                                                                                                                                                                        interface IStatusPanelAngularComp
                                                                                                                                                                                                                                                                                                                                                                                        extends AgFrameworkComponent<IStatusPanelParams>,
                                                                                                                                                                                                                                                                                                                                                                                        IStatusPanel {}

                                                                                                                                                                                                                                                                                                                                                                                          interface IToolPanelAngularComp

                                                                                                                                                                                                                                                                                                                                                                                          interface IToolPanelAngularComp
                                                                                                                                                                                                                                                                                                                                                                                          extends AgFrameworkComponent<IToolPanelParams>,
                                                                                                                                                                                                                                                                                                                                                                                          IToolPanel {}

                                                                                                                                                                                                                                                                                                                                                                                            interface ITooltipAngularComp

                                                                                                                                                                                                                                                                                                                                                                                            interface ITooltipAngularComp extends AgFrameworkComponent<ITooltipParams> {}

                                                                                                                                                                                                                                                                                                                                                                                              Package Files (6)

                                                                                                                                                                                                                                                                                                                                                                                              Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                              Dev Dependencies (0)

                                                                                                                                                                                                                                                                                                                                                                                              No dev dependencies.

                                                                                                                                                                                                                                                                                                                                                                                              Peer Dependencies (2)

                                                                                                                                                                                                                                                                                                                                                                                              Badge

                                                                                                                                                                                                                                                                                                                                                                                              To add a badge like this onejsDocs.io badgeto 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-angular.

                                                                                                                                                                                                                                                                                                                                                                                              • Markdown
                                                                                                                                                                                                                                                                                                                                                                                                [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ag-grid-angular)
                                                                                                                                                                                                                                                                                                                                                                                              • HTML
                                                                                                                                                                                                                                                                                                                                                                                                <a href="https://www.jsdocs.io/package/ag-grid-angular"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>