JavaScript Data Grid: Grid Options

statusBar: { statusPanels: StatusPanelDef[]; };

interface StatusPanelDef {
  statusPanel?: any;
  align?: string;
  key?: string;
  statusPanelParams?: any;
}

sideBar: SideBarDef | string | string[] | boolean | null;

interface SideBarDef {
  // A list of all the panels to place in the side bar. The panels will be displayed in the provided order from top to bottom. 
  toolPanels?: (ToolPanelDef | string)[];
  // The panel (identified by ID) to open by default. If none specified, the side bar is initially displayed closed. 
  defaultToolPanel?: string;
  // To hide the side bar by default, set this to `true`. If left undefined the side bar will be shown. 
  hiddenByDefault?: boolean;
  // Sets the side bar position relative to the grid. 
  position?: 'left' | 'right';
}

interface ToolPanelDef {
  // The unique ID for this panel. Used in the API and elsewhere to refer to the panel. 
  id: string;
  // The key used for localisation for displaying the label. The label is displayed in the tab button. 
  labelKey: string;
  // The default label if `labelKey` is missing or does not map to valid text through localisation. 
  labelDefault: string;
  // The min width of the tool panel. Default: `100` 
  minWidth?: number;
  // The max width of the tool panel. Default: `undefined` 
  maxWidth?: number;
  // The initial width of the tool panel. Default: `$side-bar-panel-width (theme variable)` 
  width?: number;
  // The key of the icon to be used as a graphical aid beside the label in the side bar. 
  iconKey: string;
  // The tool panel component to use as the panel.
  // The provided panels use components `agColumnsToolPanel` and `agFiltersToolPanel`.
  // To provide your own custom panel component, you reference it here. 
  toolPanel?: any;
  // Customise the parameters provided to the `toolPanel` component. 
  toolPanelParams?: any;
}

getContextMenuItems = (
    params: GetContextMenuItemsParams
) => (string | MenuItemDef)[];

interface GetContextMenuItemsParams {
  // Names of the items that would be provided by default. 
  defaultItems: string[] | undefined;
  // The column, if a cell was clicked, otherwise null. 
  column: Column | null;
  // The row node, if a cell was clicked, otherwise null. 
  node: RowNode | null;
  // The value, if a cell was clicked, otherwise null. 
  value: any;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface MenuItemDef {
  // If this item is a sub menu, contains a list of menu item definitions 
  subMenu?: (MenuItemDef | string)[];
  // Name of the menu item 
  name: string;
  // It the item should be enabled / disabled 
  disabled?: boolean;
  // Shortcut (just display text, saying the shortcut here does nothing) 
  shortcut?: string;
  // Function that gets executed when item is chosen 
  action?: () => void;
  // Set to true to provide a check beside the option 
  checked?: boolean;
  // The icon to display, either a DOM element or HTML string 
  icon?: HTMLElement | string;
  // CSS classes to apply to the menu item 
  cssClasses?: string[];
  // Tooltip for the menu item 
  tooltip?: string;
}

getMainMenuItems = (
    params: GetMainMenuItemsParams
) => (string | MenuItemDef)[];

interface GetMainMenuItemsParams {
  // The column that was clicked 
  column: Column;
  // List of the items that would be displayed by default 
  defaultItems: string[];
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface MenuItemDef {
  // If this item is a sub menu, contains a list of menu item definitions 
  subMenu?: (MenuItemDef | string)[];
  // Name of the menu item 
  name: string;
  // It the item should be enabled / disabled 
  disabled?: boolean;
  // Shortcut (just display text, saying the shortcut here does nothing) 
  shortcut?: string;
  // Function that gets executed when item is chosen 
  action?: () => void;
  // Set to true to provide a check beside the option 
  checked?: boolean;
  // The icon to display, either a DOM element or HTML string 
  icon?: HTMLElement | string;
  // CSS classes to apply to the menu item 
  cssClasses?: string[];
  // Tooltip for the menu item 
  tooltip?: string;
}

postProcessPopup = (
    params: PostProcessPopupParams
) => void;

interface PostProcessPopupParams {
  // If popup is for a column, this gives the Column 
  column?: Column | null;
  // If popup is for a row, this gives the RowNode 
  rowNode?: RowNode | null;
  // The popup we are showing 
  ePopup: HTMLElement;
  // The different types are:
  // 'contextMenu', 'columnMenu', 'aggFuncSelect', 'popupCellEditor' 
  type: string;
  // If the popup is as a result of a button click (eg menu button),
  // this is the component that the user clicked 
  eventSource?: HTMLElement | null;
  // If the popup is as a result of a click or touch,
  // this is the event - eg user showing context menu 
  mouseEvent?: MouseEvent | Touch | null;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

processCellForClipboard = (
    params: ProcessCellForExportParams
) => any;

interface ProcessCellForExportParams {
  value: any;
  accumulatedRowIndex?: number;
  node?: RowNode | null;
  column: Column;
  type: string;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

processHeaderForClipboard = (
    params: ProcessHeaderForExportParams
) => any;

interface ProcessHeaderForExportParams {
  column: Column;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

processGroupHeaderForClipboard = (
    params: ProcessGroupHeaderForExportParams
) => any;

interface ProcessGroupHeaderForExportParams {
  columnGroup: ColumnGroup;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

processCellFromClipboard = (
    params: ProcessCellForExportParams
) => any;

interface ProcessCellForExportParams {
  value: any;
  accumulatedRowIndex?: number;
  node?: RowNode | null;
  column: Column;
  type: string;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

sendToClipboard = (
    params: SendToClipboardParams
) => void;

interface SendToClipboardParams {
  data: string;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

processDataFromClipboard = (
    params: ProcessDataFromClipboardParams
) => string[][] | null;

interface ProcessDataFromClipboardParams {
  // 2D array of all cells from the clipboard 
  data: string[][];
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

excelStyles: ExcelStyle[];

interface ExcelStyle {
  id: string;
  alignment?: ExcelAlignment;
  borders?: ExcelBorders;
  dataType?: ExcelDataType;
  font?: ExcelFont;
  interior?: ExcelInterior;
  numberFormat?: ExcelNumberFormat;
  protection?: ExcelProtection;
}

isExternalFilterPresent = (
    params: IsExternalFilterPresentParams
) => boolean;

interface IsExternalFilterPresentParams {
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

doesExternalFilterPass = (node: RowNode) => boolean;

getChartToolbarItems = (
    params: GetChartToolbarItemsParams
) => ChartMenuOptions[];

interface GetChartToolbarItemsParams {
  defaultItems?: ChartMenuOptions[];
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

type ChartMenuOptions = 
      'chartSettings' 
    | 'chartData' 
    | 'chartFormat' 
    | 'chartLink' 
    | 'chartUnlink' 
    | 'chartDownload'

createChartContainer = (params: ChartRefParams) => void;

interface ChartRefParams {
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
  // The id of the created chart. 
  chartId: string;
  // The chart instance that is produced by AG Charts which can be used to interact with the chart directly. 
  chart: any;
  // The chart DOM element, which the application is responsible for placing into the DOM. 
  chartElement: HTMLElement;
  // The application is responsible for calling this when the chart is no longer needed. 
  destroyChart: () => void;
}

customChartThemes: { [name: string]: AgChartTheme };

interface AgChartTheme {
  // The name of the theme to base your theme on. Your custom theme will inherit all of the configuration from
  // the base theme, allowing you to override just the settings you wish to change using the `overrides` config (see
  // below). 
  baseTheme?: AgChartThemeName;
  // The palette to use. If specified, this replaces the palette from the base theme. 
  palette?: AgChartThemePalette;
  // Configuration from this object is merged over the defaults specified in the base theme. 
  overrides?: AgChartThemeOverrides;
}

interface AgChartThemePalette {
  // The array of fills to be used. 
  fills: string[];
  // The array of strokes to be used. 
  strokes: string[];
}

navigateToNextHeader = (
    params: NavigateToNextHeaderParams
) => (HeaderPosition | null);

interface NavigateToNextHeaderParams {
  // The key for the arrow key pressed,
  // left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown' 
  key: string;
  // The header that currently has focus 
  previousHeaderPosition: HeaderPosition | null;
  // The header the grid would normally pick as the next header for this navigation 
  nextHeaderPosition: HeaderPosition | null;
  // The number of header rows present in the grid 
  headerRowCount: number;
  event: KeyboardEvent;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface HeaderPosition {
  // A number from 0 to n, where n is the last header row the grid is rendering 
  headerRowIndex: number;
  // The grid column or column group 
  column: Column | ColumnGroup;
}

tabToNextHeader = (
    params: TabToNextHeaderParams
) => (HeaderPosition | null);

interface TabToNextHeaderParams {
  // True if the Shift key is also down 
  backwards: boolean;
  // The header that currently has focus 
  previousHeaderPosition: HeaderPosition | null;
  // The header the grid would normally pick as the next header for this navigation 
  nextHeaderPosition: HeaderPosition | null;
  // The number of header rows present in the grid 
  headerRowCount: number;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface HeaderPosition {
  // A number from 0 to n, where n is the last header row the grid is rendering 
  headerRowIndex: number;
  // The grid column or column group 
  column: Column | ColumnGroup;
}

navigateToNextCell = (
    params: NavigateToNextCellParams
) => (CellPosition | null);

interface NavigateToNextCellParams {
  // The keycode for the arrow key pressed:
  // left = 'ArrowLeft', up = 'ArrowUp', right = 'ArrowRight', down = 'ArrowDown' 
  key: string;
  // The cell that currently has focus 
  previousCellPosition: CellPosition;
  // The cell the grid would normally pick as the next cell for navigation 
  nextCellPosition: CellPosition | null;
  event: KeyboardEvent | null;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface CellPosition {
  // The grid column 
  column: Column;
  // A positive number from 0 to n, where n is the last row the grid is rendering
  // or -1 if you want to navigate to the grid header 
  rowIndex: number;
  // Either 'top', 'bottom' or null (for not pinned) 
  rowPinned: string | null;
}

tabToNextCell = (
    params: TabToNextCellParams
) => (CellPosition | null);

interface TabToNextCellParams {
  // True if the Shift key is also down 
  backwards: boolean;
  // True if the current cell is editing
  // (you may want to skip cells that are not editable, as the grid will enter the next cell in editing mode also if tabbing) 
  editing: boolean;
  // The cell that currently has focus 
  previousCellPosition: CellPosition;
  // The cell the grid would normally pick as the next cell for navigation. 
  nextCellPosition: CellPosition | null;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface CellPosition {
  // The grid column 
  column: Column;
  // A positive number from 0 to n, where n is the last row the grid is rendering
  // or -1 if you want to navigate to the grid header 
  rowIndex: number;
  // Either 'top', 'bottom' or null (for not pinned) 
  rowPinned: string | null;
}

loadingCellRendererSelector = (
    params: ILoadingCellRendererParams
) => LoadingCellRendererSelectorResult | undefined;

interface ILoadingCellRendererParams {
  // Value to be rendered. 
  value: any;
  // Formatted value to be rendered. 
  valueFormatted: any;
  // True if this is a full width row. 
  fullWidth?: boolean;
  // Pinned state of the cell. 
  pinned?: string | null;
  // The row's data. 
  data: any;
  // The row node. 
  node: RowNode;
  // The current index of the row (this changes after filter and sort). 
  rowIndex: number;
  // The cell's column definition. 
  colDef?: ColDef;
  // The cell's column. 
  column?: Column;
  // The grid's cell, a DOM div element. 
  eGridCell: HTMLElement;
  // The parent DOM item for the cell renderer, same as eGridCell unless using checkbox selection. 
  eParentOfValue: HTMLElement;
  // Convenience function to get most recent up to date value. 
  getValue?: () => any;
  // Convenience function to set the value. 
  setValue?: (value: any) => void;
  // Convenience function to format a value using the column's formatter. 
  formatValue?: (value: any) => any;
  // Convenience function to refresh the cell. 
  refreshCell?: () => void;
  // registerRowDragger:
  // @param rowDraggerElement The HTMLElement to be used as Row Dragger
  // @param dragStartPixels The amount of pixels required to start the drag (Default: 4)
  // @param value The value to be displayed while dragging. Note: Only relevant with Full Width Rows.
  // @param suppressVisibilityChange Set to `true` to prevent the Grid from hiding the Row Dragger when it is disabled.
  registerRowDragger: (rowDraggerElement: HTMLElement, dragStartPixels?: number, value?: string, suppressVisibilityChange?: boolean) => void;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface LoadingCellRendererSelectorResult {
  // Equivalent of setting `loadingCellRenderer` 
  component?: any;
  // Equivalent of setting `loadingCellRendererParams` 
  params?: any;
}

getLocaleText = (
    params: GetLocaleTextParams
) => string;

interface GetLocaleTextParams {
  key: string;
  defaultValue: string;
  variableValues?: string[];
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

isRowMaster = (dataItem: any) => boolean;

getDocument = () => Document;

paginationNumberFormatter = (
    params: PaginationNumberFormatterParams
) => string;

interface PaginationNumberFormatterParams {
  value: number;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

processSecondaryColDef = (colDef: ColDef) => void;

processSecondaryColGroupDef = (
    colGroupDef: ColGroupDef
) => void;

aggFuncs: { [key: string]: IAggFunc; };

interface IAggFunc {
    (params: IAggFuncParams) : any
}

interface IAggFuncParams {
  // Values to aggregate 
  values: any[];
  // Column the aggregation function is working on 
  column: Column;
  // ColDef of the aggregation column 
  colDef: ColDef;
  // The parent RowNode, where the aggregation result will be shown 
  rowNode: RowNode;
  // data (if any) of the parent RowNode 
  data: any;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

getGroupRowAgg = (
    params: GetGroupRowAggParams
) => any;

interface GetGroupRowAggParams {
  nodes: RowNode[];
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

groupAggFiltering: boolean | IsRowFilterable;

interface IsRowFilterable {
    (params: GetGroupAggFilteringParams) : boolean
}

interface GetGroupAggFilteringParams {
  node: RowNode;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

getBusinessKeyForNode = (node: RowNode) => string;

processRowPostCreate = (
    params: ProcessRowParams
) => void;

interface ProcessRowParams {
  eRow: HTMLElement;
  ePinnedLeftRow: HTMLElement;
  ePinnedRightRow: HTMLElement;
  rowIndex: number;
  node: RowNode;
  addRenderedRowListener: (eventType: string, listener: Function) => void;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

groupDisplayType: RowGroupingDisplayType;

type RowGroupingDisplayType = 
      'singleColumn' 
    | 'multipleColumns' 
    | 'groupRows' 
    | 'custom'

isGroupOpenByDefault = (
    params: IsGroupOpenByDefaultParams
) => boolean;

interface IsGroupOpenByDefaultParams {
  // The row node being considered. 
  rowNode: RowNode;
  // The Column for which this row is grouping. 
  rowGroupColumn: Column;
  // Same as `rowNode.level` - what level the group is at, e.g. 0 for top level, 1 for second etc 
  level: number;
  // Same as `rowNode.field` - the field we are grouping on, e.g. 'country' 
  field: string;
  // Same as `rowNode.key`, the value of this group, e.g. 'Ireland' 
  key: string;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

initialGroupOrderComparator = (
    params: InitialGroupOrderComparatorParams
) => number;

interface InitialGroupOrderComparatorParams {
  nodeA: RowNode;
  nodeB: RowNode;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

getDataPath = (data: any) => string[];

getRowId = (params: GetRowIdParams) => string;

interface GetRowIdParams {
  // The data item provided to the grid for the row in question 
  data: any;
  // If grouping, the level, ie how many levels from the top. Used by ServerSide Row Model only 
  level: number;
  // If grouping, provides the keys of the parent groups. Used by ServerSide Row Model only 
  parentKeys?: string[];
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

datasource: IDatasource;

interface IDatasource {
  // If you know up front how many rows are in the dataset, set it here. Otherwise leave blank. 
  rowCount?: number;
  // Callback the grid calls that you implement to fetch rows from the server. 
  getRows(params: IGetRowsParams): void;
  // Optional destroy method, if your datasource has state it needs to clean up. 
  destroy?(): void;
}

interface IGetRowsParams {
  // The first row index to get. 
  startRow: number;
  // The first row index to NOT get. 
  endRow: number;
  // Callback to call for the result when successful. 
  successCallback(rowsThisBlock: any[], lastRow?: number): void;
  // Callback to call when the request fails. 
  failCallback(): void;
  // If doing server side sorting, contains the sort model 
  sortModel: SortModelItem[];
  // If doing server side filtering, contains the filter model 
  filterModel: any;
  // The context as provided on `gridOptions.context` 
  context: any;
}

interface SortModelItem {
  // Column Id to apply the sort to. 
  colId: string;
  // Sort direction 
  sort: 'asc' | 'desc';
}

serverSideStoreType: ServerSideStoreType;

type ServerSideStoreType = 'full' | 'partial'

serverSideDatasource: IServerSideDatasource;

interface IServerSideDatasource {
  // Grid calls `getRows` when it requires more rows as specified in the params.
  // Params object contains callbacks for responding to the request. 
  getRows(params: IServerSideGetRowsParams): void;
  // Optional method, if your datasource has state it needs to clean up. 
  destroy?(): void;
}

interface IServerSideGetRowsParams {
  // Details for the request. A simple object that can be converted to JSON. 
  request: IServerSideGetRowsRequest;
  // The parent row node. The RootNode (level -1) if request is top level.
  // This is NOT part fo the request as it cannot be serialised to JSON (a rowNode has methods). 
  parentNode: RowNode;
  // Success callback, pass the rows back to the grid that were requested. 
  success(params: LoadSuccessParams): void;
  // Fail callback, tell the grid the call failed so it can adjust it's state. 
  fail(): void;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface IServerSideGetRowsRequest {
  // First row requested or undefined for all rows. 
  startRow: number | undefined;
  // Last row requested or undefined for all rows. 
  endRow: number | undefined;
  // Columns that are currently row grouped. 
  rowGroupCols: ColumnVO[];
  // Columns that have aggregations on them. 
  valueCols: ColumnVO[];
  // Columns that have pivot on them. 
  pivotCols: ColumnVO[];
  // Defines if pivot mode is on or off. 
  pivotMode: boolean;
  // What groups the user is viewing. 
  groupKeys: string[];
  // If filtering, what the filter model is. 
  filterModel: any;
  // If sorting, what the sort model is. 
  sortModel: SortModelItem[];
}

interface ColumnVO {
  id: string;
  displayName: string;
  field?: string;
  aggFunc?: string;
}

interface SortModelItem {
  // Column Id to apply the sort to. 
  colId: string;
  // Sort direction 
  sort: 'asc' | 'desc';
}

interface LoadSuccessParams {
  // Data retrieved from the server as requested by the grid. 
  rowData: any[];
  // The last row, if known, to help Infinite Scroll (i.e Partial Store) and Pagination. 
  rowCount?: number;
  // Any extra information for the grid to associate with this load. 
  storeInfo?: any;
}

getChildCount = (dataItem: any) => number;

getServerSideStoreParams = (
    params: GetServerSideStoreParamsParams
) => ServerSideStoreParams;

interface GetServerSideStoreParamsParams {
  // The level of the store. Top level is 0. 
  level: number;
  // The Row Node for the group that got expanded, or undefined if top level (ie no parent) 
  parentRowNode?: RowNode;
  // Active Row Group Columns, if any. 
  rowGroupColumns: Column[];
  // Active Pivot Columns, if any. 
  pivotColumns: Column[];
  // true if pivot mode is active. 
  pivotMode: boolean;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface ServerSideStoreParams {
  // What store type to use.
  // If missing, then defaults to grid option `serverSideStoreType`. 
  storeType?: ServerSideStoreType;
  // For Partial Store only.
  // How many blocks to keep in cache.
  // If missing, defaults to grid options `maxBlocksInCache`. 
  maxBlocksInCache?: number;
  // For Partial Store only.
  // Cache block size.
  // If missing, defaults to grid options `cacheBlockSize`. 
  cacheBlockSize?: number;
}

type ServerSideStoreType = 'full' | 'partial'

isServerSideGroupOpenByDefault = (
    params: IsServerSideGroupOpenByDefaultParams
) => boolean;

interface IsServerSideGroupOpenByDefaultParams {
  data: any;
  rowNode: RowNode;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

isApplyServerSideTransaction = (
    params: IsApplyServerSideTransactionParams
) => boolean;

interface IsApplyServerSideTransactionParams {
  // The transaction getting applied. 
  transaction: ServerSideTransaction;
  // The parent RowNode, if transaction is applied to a group. 
  parentNode: RowNode;
  storeInfo: any;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

isServerSideGroup = (dataItem: any) => boolean;

getServerSideGroupKey = (dataItem: any) => string;

viewportDatasource: IViewportDatasource;

interface IViewportDatasource {
  // Gets called exactly once before viewPort is used. Passes methods to be used to tell viewPort of data loads / changes. 
  init(params: IViewportDatasourceParams): void;
  // Tell the viewport what the scroll position of the grid is, so it knows what rows it has to get. 
  setViewportRange(firstRow: number, lastRow: number): void;
  // Gets called once when viewPort is no longer used. If you need to do any cleanup, do it here. 
  destroy?(): void;
}

interface IViewportDatasourceParams {
  // Datasource calls this method when the total row count changes. This in turn sets the height of the grids vertical scroll. 
  setRowCount: (count: number, keepRenderedRows?: boolean) => void;
  // Datasource calls this when new data arrives. The grid then updates the provided rows. The rows are mapped [rowIndex]=>rowData]. 
  setRowData: (rowData: { [key: number]: any; }) => void;
  // Datasource calls this when it wants a row node - typically used when it wants to update the row node. 
  getRow: (rowIndex: number) => RowNode;
}

isRowSelectable = (node: RowNode) => boolean;

fillOperation = (
    params: FillOperationParams
) => any;

interface FillOperationParams {
  // The mouse event for the fill operation. 
  event: MouseEvent;
  // The values that have been processed by the fill operation. 
  values: any[];
  // The RowNode of the current cell being changed. 
  rowNode: RowNode;
  // The Column of the current cell being changed. 
  column: Column;
  // The values that were present before processing started. 
  initialValues: any[];
  // The index of the current processed value. 
  currentIndex: number;
  // The value of the cell being currently processed by the Fill Operation. 
  currentCellValue: any;
  // The direction of the Fill Operation. 
  direction: 'up' | 'down' | 'left' | 'right';
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

postSortRows = (
    params: PostSortRowsParams
) => void;

interface PostSortRowsParams {
  nodes: RowNode[];
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

getRowHeight = (
    params: RowHeightParams
) => number | undefined | null;

interface RowHeightParams {
  data: any;
  node: RowNode;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

rowStyle: RowStyle;

interface RowStyle {
  [cssProperty: string]: string | number;
}

getRowStyle = (params: RowClassParams) => RowStyle | undefined;

interface RowClassParams {
  // The data associated with this row from rowData 
  data: any;
  // The RowNode associated with this row 
  node: RowNode;
  // The index of the row 
  rowIndex: number;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface RowStyle {
  [cssProperty: string]: string | number;
}

getRowClass = (params: RowClassParams) => string | string[] | undefined;

interface RowClassParams {
  // The data associated with this row from rowData 
  data: any;
  // The RowNode associated with this row 
  node: RowNode;
  // The index of the row 
  rowIndex: number;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

rowClassRules: RowClassRules;

interface RowClassRules {
  [cssClassName: string]: (((params: RowClassParams) => boolean) | string);
}

interface RowClassParams {
  // The data associated with this row from rowData 
  data: any;
  // The RowNode associated with this row 
  node: RowNode;
  // The index of the row 
  rowIndex: number;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

isFullWidthRow = (
    params: IsFullWidthRowParams
) => boolean;

interface IsFullWidthRowParams {
  rowNode: RowNode;
  // The grid api. 
  api: GridApi;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}