JavaScript Data GridGrid 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: GetContextMenuItems<TData>;

interface GetContextMenuItems<TData = any> {
    (params: GetContextMenuItemsParams<TData>) : (string | MenuItemDef)[]
}

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?: Element | string;
  // CSS classes to apply to the menu item 
  cssClasses?: string[];
  // Tooltip for the menu item 
  tooltip?: string;
}

interface GetContextMenuItemsParams<TData = any, TContext = any> {
  // 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: IRowNode<TData> | null;
  // The value, if a cell was clicked, otherwise null.  
  value: any;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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

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

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?: Element | string;
  // CSS classes to apply to the menu item 
  cssClasses?: string[];
  // Tooltip for the menu item 
  tooltip?: string;
}

postProcessPopup = (
    params: PostProcessPopupParams<TData>
) => void;

interface PostProcessPopupParams<TData = any, TContext = any> {
  // If popup is for a column, this gives the Column 
  column?: Column | null;
  // If popup is for a row, this gives the RowNode 
  rowNode?: IRowNode<TData> | 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

processCellForClipboard = (
    params: ProcessCellForExportParams<TData>
) => any;

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

processHeaderForClipboard = (
    params: ProcessHeaderForExportParams<TData>
) => any;

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

processGroupHeaderForClipboard = (
    params: ProcessGroupHeaderForExportParams<TData>
) => any;

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

processCellFromClipboard = (
    params: ProcessCellForExportParams<TData>
) => any;

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

sendToClipboard = (
    params: SendToClipboardParams<TData>
) => void;

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

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

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

excelStyles: ExcelStyle[];

interface ExcelStyle {
  // The id of the Excel Style, this should match a CSS cell class. 
  id: string;
  // Use this property to customise cell alignment properties. 
  alignment?: ExcelAlignment;
  // Use this property to customise cell borders. 
  borders?: ExcelBorders;
  // Use this property to specify the type of data being exported. 
  dataType?: ExcelDataType;
  // Use this property to customise the font used in the cell. 
  font?: ExcelFont;
  // Use this property to customise the cell background. 
  interior?: ExcelInterior;
  // Use this property to customise the cell value as a formatted number. 
  numberFormat?: ExcelNumberFormat;
  // Use this property to setup cell protection. 
  protection?: ExcelProtection;
}

isExternalFilterPresent = (
    params: IsExternalFilterPresentParams<TData>
) => boolean;

interface IsExternalFilterPresentParams<TData = any, TContext = any> {
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

doesExternalFilterPass = (node: IRowNode<TData>) => boolean;

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

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

type ChartMenuOptions = 
      ChartToolPanelMenuOptions 
    | ChartToolbarMenuItemOptions


type ChartToolPanelMenuOptions = 
      'chartSettings' 
    | 'chartData' 
    | 'chartFormat'


type ChartToolbarMenuItemOptions = 
      'chartLink' 
    | 'chartUnlink' 
    | 'chartDownload'

createChartContainer = (
    params: ChartRefParams<TData>
) => void;

interface ChartRefParams<TData = any> {
  // The grid api. 
  api: GridApi<TData>;
  // 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 };

type AgChartTheme = 
      string 
    | AgChartThemeDefinition


interface AgChartThemeDefinition {
}

chartThemeOverrides: AgChartThemeOverrides;

interface AgChartThemeOverrides {
}

chartToolPanelsDef: ChartToolPanelsDef;

interface ChartToolPanelsDef {
  // Customisations for the settings panel and chart menu items in the Context Menu. 
  settingsPanel?: ChartSettingsPanel;
  // Customisations for the format panel 
  formatPanel?: ChartFormatPanel;
  // Customisations for the data panel 
  dataPanel?: ChartDataPanel;
  // The ordered list of panels to show in the chart tool panels. If none specified, all panels are shown 
  panels?: ChartToolPanelName[];
  // The panel to open by default when the chart loads. If none specified, the tool panel is hidden by default and the first panel is open when triggered. 
  defaultToolPanel?: ChartToolPanelName;
}

interface ChartSettingsPanel {
  // Chart groups customisations for which charts are displayed in the settings panel 
  chartGroupsDef?: ChartGroupsDef;
}

interface ChartGroupsDef {
  columnGroup?: ('column' | 'stackedColumn' | 'normalizedColumn')[];
  barGroup?: ('bar' | 'stackedBar' | 'normalizedBar')[];
  pieGroup?: ('pie' | 'doughnut')[];
  lineGroup?: ('line')[];
  scatterGroup?: ('scatter' | 'bubble')[];
  areaGroup?: ('area' | 'stackedArea' | 'normalizedArea')[];
  histogramGroup?: ('histogram')[];
  combinationGroup?: ('columnLineCombo' | 'areaColumnCombo' | 'customCombo')[];
}

interface ChartFormatPanel {
  // The format panel group configurations, their order and whether they are shown. If not specified shows all groups 
  groups?: ChartPanelGroupDef<ChartFormatPanelGroup>[];
}

interface ChartPanelGroupDef<GroupType> {
  // The panel group type 
  type: GroupType;
  // Whether the panel group is open by default. If not specified, it is closed 
  isOpen?: boolean;
}

type ChartFormatPanelGroup = 
      'chart' 
    | 'legend' 
    | 'axis' 
    | 'series' 
    | 'navigator'


interface ChartDataPanel {
  // The data panel group configurations, their order and whether they are shown. If not specified shows all groups 
  groups?: ChartPanelGroupDef<ChartDataPanelGroup>[];
}

type ChartDataPanelGroup = 
      'categories' 
    | 'series' 
    | 'seriesChartType'


type ChartToolPanelName = 
      'settings' 
    | 'data' 
    | 'format'

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

interface NavigateToNextHeaderParams<TData = any, TContext = any> {
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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<TData>
) => (HeaderPosition | null);

interface TabToNextHeaderParams<TData = any, TContext = any> {
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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<TData>
) => (CellPosition | null);

interface NavigateToNextCellParams<TData = any, TContext = any> {
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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/undefined (for not pinned) 
  rowPinned: RowPinnedType;
}

type RowPinnedType = 
      'top' 
    | 'bottom' 
    | null 
    | undefined

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

interface TabToNextCellParams<TData = any, TContext = any> {
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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/undefined (for not pinned) 
  rowPinned: RowPinnedType;
}

type RowPinnedType = 
      'top' 
    | 'bottom' 
    | null 
    | undefined

loadingCellRendererSelector: LoadingCellRendererSelectorFunc<TData>;

interface LoadingCellRendererSelectorFunc<TData = any> {
    (params: ILoadingCellRendererParams<TData>) : LoadingCellRendererSelectorResult | undefined
}

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

interface ILoadingCellRendererParams<TData = any, TContext = any> {
  // Value to be rendered. 
  value: TValue;
  // Formatted value to be rendered. 
  valueFormatted: string | null | undefined;
  // True if this is a full width row. 
  fullWidth?: boolean;
  // Pinned state of the cell. 
  pinned?: "left" | "right" | null;
  // The row's data. Data property can be `undefined` when row grouping or loading infinite row models. 
  data: TData | undefined;
  // The row node. 
  node: IRowNode<TData>;
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

getLocaleText = (
    params: GetLocaleTextParams<TData>
) => string;

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

isRowMaster: IsRowMaster<TData>;

interface IsRowMaster<TData = any> {
    (dataItem: TData) : boolean
}

getDocument = () => Document;

paginationNumberFormatter = (
    params: PaginationNumberFormatterParams<TData>
) => string;

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

processPivotResultColDef = (colDef: ColDef<TData>) => void;

processPivotResultColGroupDef = (
    colGroupDef: ColGroupDef<TData>
) => void;

aggFuncs: { [key: string]: IAggFunc<TData>; };

interface IAggFunc<TData = any, TValue = any> {
    (params: IAggFuncParams<TData, TValue>) : any
}

interface IAggFuncParams<TData = any, TValue = any> {
  // Values to aggregate 
  values: TValue[];
  // Column the aggregation function is working on 
  column: Column;
  // ColDef of the aggregation column 
  colDef: ColDef<TData>;
  // Pivot Result Column being produced using this aggregation 
  pivotResultColumn?: Column;
  // The parent RowNode, where the aggregation result will be shown 
  rowNode: IRowNode<TData>;
  // data (if any) of the parent RowNode 
  data: TData;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

getGroupRowAgg = (
    params: GetGroupRowAggParams<TData>
) => any;

interface GetGroupRowAggParams<TData = any, TContext = any> {
  nodes: IRowNode<TData>[];
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

groupAggFiltering: boolean | IsRowFilterable<TData>;

interface IsRowFilterable<TData = any> {
    (params: GetGroupAggFilteringParams<TData>) : boolean
}

interface GetGroupAggFilteringParams<TData = any, TContext = any> {
  node: IRowNode<TData>;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

domLayout: DomLayoutType;

type DomLayoutType = 
      'normal' 
    | 'autoHeight' 
    | 'print'

getBusinessKeyForNode = (node: IRowNode<TData>) => string;

processRowPostCreate = (
    params: ProcessRowParams<TData>
) => void;

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

rowDragText = (
    params: IRowDragItem,
    dragItemCount: number
) => string;

interface IRowDragItem {
  // The default text that would be applied to this Drag Element 
  defaultTextValue: string;
  // When dragging a row, this contains the row node being dragged
  // When dragging multiple rows, this contains the row that started the drag.
  rowNode?: IRowNode;
  // When dragging multiple rows, this contains all rows being dragged 
  rowNodes?: IRowNode[];
  // When dragging columns, this contains the columns being dragged 
  columns?: Column[];
  // When dragging columns, this contains the visible state of the columns 
  visibleState?: { [key: string]: boolean; };
}

groupDisplayType: RowGroupingDisplayType;

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

isGroupOpenByDefault = (
    params: IsGroupOpenByDefaultParams<TData>
) => boolean;

interface IsGroupOpenByDefaultParams<TData = any, TContext = any> {
  // The row node being considered. 
  rowNode: IRowNode<TData>;
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

initialGroupOrderComparator = (
    params: InitialGroupOrderComparatorParams<TData>
) => number;

interface InitialGroupOrderComparatorParams<TData = any, TContext = any> {
  nodeA: IRowNode<TData>;
  nodeB: IRowNode<TData>;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

getDataPath: GetDataPath<TData>;

interface GetDataPath<TData = any> {
    (data: TData) : string[]
}

rowModelType: RowModelType;

type RowModelType = 
      'infinite' 
    | 'viewport' 
    | 'clientSide' 
    | 'serverSide'

getRowId: GetRowIdFunc<TData>;

interface GetRowIdFunc<TData = any> {
    (params: GetRowIdParams<TData>) : string
}

interface GetRowIdParams<TData = any, TContext = any> {
  // The data item provided to the grid for the row in question 
  data: TData;
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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

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<TData = any, TContext = any> {
  // 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: IRowNode;
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

interface IServerSideGetRowsRequest {
  // First row requested or undefined for all rows. 
  startRow: number | undefined;
  // Index after the last row required row 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.
  rowCount?: number;
  // Any extra information for the grid to associate with this load.
  groupLevelInfo?: any;
}

getChildCount = (dataItem: any) => number;

getServerSideGroupLevelParams = (
    params: GetServerSideGroupLevelParamsParams
) => ServerSideGroupLevelParams;

interface GetServerSideGroupLevelParamsParams {
  // 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?: IRowNode;
  // 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<any>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: any;
}

interface ServerSideGroupLevelParams {
  // Whether to have infinite scroll active or not for the level.
  suppressInfiniteScroll?: boolean;
  // For Infinite Scroll only.
  // How many blocks to keep in cache.
  // If missing, defaults to grid options `maxBlocksInCache`.
  maxBlocksInCache?: number;
  // For Infinite Scroll only.
  // Cache block size.
  // If missing, defaults to grid options `cacheBlockSize`.
  cacheBlockSize?: number;
}

isServerSideGroupOpenByDefault = (
    params: IsServerSideGroupOpenByDefaultParams
) => boolean;

interface IsServerSideGroupOpenByDefaultParams {
  data: any;
  rowNode: IRowNode;
  // The grid api. 
  api: GridApi<any>;
  // 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: IRowNode;
  // Store info, if any, as passed via the success() callback when loading data. 
  groupLevelInfo: any;
  // The grid api. 
  api: GridApi<any>;
  // 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) => IRowNode;
}

isRowSelectable: IsRowSelectable<TData>;

interface IsRowSelectable<TData = any> {
    (node: IRowNode<TData>) : boolean
}

fillOperation = (
    params: FillOperationParams<TData>
) => any;

interface FillOperationParams<TData = any, TContext = any> {
  // 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: IRowNode<TData>;
  // 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<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

sortingOrder: (SortDirection)[];

type SortDirection = 
      'asc' 
    | 'desc' 
    | null

postSortRows = (
    params: PostSortRowsParams<TData>
) => void;

interface PostSortRowsParams<TData = any, TContext = any> {
  nodes: IRowNode<TData>[];
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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

interface RowHeightParams<TData = any, TContext = any> {
  // The data associated with this row from rowData. Data is `undefined` for row groups. 
  data: TData | undefined;
  // The RowNode of the row in question. 
  node: IRowNode<TData>;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

rowStyle: RowStyle;

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

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

interface RowClassParams<TData = any, TContext = any> {
  // The data associated with this row from rowData. Data is `undefined` for row groups. 
  data: TData | undefined;
  // The RowNode associated with this row 
  node: IRowNode<TData>;
  // The index of the row 
  rowIndex: number;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

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

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

interface RowClassParams<TData = any, TContext = any> {
  // The data associated with this row from rowData. Data is `undefined` for row groups. 
  data: TData | undefined;
  // The RowNode associated with this row 
  node: IRowNode<TData>;
  // The index of the row 
  rowIndex: number;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

rowClassRules: RowClassRules<TData>;

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

interface RowClassParams<TData = any, TContext = any> {
  // The data associated with this row from rowData. Data is `undefined` for row groups. 
  data: TData | undefined;
  // The RowNode associated with this row 
  node: IRowNode<TData>;
  // The index of the row 
  rowIndex: number;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}

isFullWidthRow = (
    params: IsFullWidthRowParams<TData>
) => boolean;

interface IsFullWidthRowParams<TData = any, TContext = any> {
  rowNode: IRowNode<TData>;
  // The grid api. 
  api: GridApi<TData>;
  // The column api. 
  columnApi: ColumnApi;
  // Application context as set on `gridOptions.context`. 
  context: TContext;
}