React Data Grid: Grid API

function setPopupParent(
    ePopupParent: HTMLElement
): void;

function showColumnMenuAfterButtonClick(
    colKey: string | Column,
    buttonElement: HTMLElement
): void;

function showColumnMenuAfterMouseClick(
    colKey: string | Column,
    mouseEvent: MouseEvent | Touch
): void;

function hidePopupMenu(): void;

function setSideBar(
    def: SideBarDef | string | string[] | boolean
): void;

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

function getSideBar(): SideBarDef | undefined;

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

function setSideBarVisible(show: boolean): void;

function isSideBarVisible(): boolean;

function setSideBarPosition(
    position: 'left' | 'right'
): void;

function openToolPanel(key: string): void;

function closeToolPanel(): void;

function getOpenedToolPanel(): string | null;

function isToolPanelShowing(): boolean;

function refreshToolPanel(): void;

function getToolPanelInstance(id: string): TToolPanel | undefined;

function getStatusPanel(key: string): TStatusPanel | undefined;

function cutToClipboard(
    params?: IClipboardCopyParams
): void;

interface IClipboardCopyParams {
  includeHeaders?: boolean;
  includeGroupHeaders?: boolean;
}

function copyToClipboard(
    params?: IClipboardCopyParams
): void;

interface IClipboardCopyParams {
  includeHeaders?: boolean;
  includeGroupHeaders?: boolean;
}

function copySelectedRangeToClipboard(
    params?: IClipboardCopyParams
): void;

interface IClipboardCopyParams {
  includeHeaders?: boolean;
  includeGroupHeaders?: boolean;
}

function copySelectedRangeDown(): void;

function copySelectedRowsToClipboard(
    params?: IClipboardCopyRowsParams
): void;

interface IClipboardCopyRowsParams {
  columnKeys?: (string | Column)[];
  includeHeaders?: boolean;
  includeGroupHeaders?: boolean;
}

function getColumnDefs(): (ColDef<TData> | ColGroupDef<TData>)[] | undefined;

function setColumnDefs(
    colDefs: (ColDef<TData> | ColGroupDef<TData>)[],
    source: ColumnEventType = "api"
): void;

function setAutoGroupColumnDef(
    colDef: ColDef<TData>,
    source: ColumnEventType = "api"
): void;

function setDefaultColDef(
    colDef: ColDef<TData>,
    source: ColumnEventType = "api"
): void;

function sizeColumnsToFit(
    params?: ISizeColumnsToFitParams
): void;

interface ISizeColumnsToFitParams {
  // Defines a default minimum width for every column (does not override the column minimum width) 
  defaultMinWidth?: number;
  // Defines a default maximum width for every column (does not override the column maximum width) 
  defaultMaxWidth?: number;
  // Provides a minimum and/or maximum width to specific columns 
  columnLimits?: IColumnLimit[];
}

interface IColumnLimit {
  // Selector for the column to which these dimension limits will apply 
  key: Column | string;
  // Defines a minimum width for this column (does not override the column minimum width) 
  minWidth?: number;
  // Defines a maximum width for this column (does not override the column maximum width) 
  maxWidth?: number;
}

function setHeaderHeight(headerHeight?: number): void;

function setGroupHeaderHeight(headerHeight?: number): void;

function setFloatingFiltersHeight(headerHeight?: number): void;

function setPivotHeaderHeight(headerHeight?: number): void;

function setPivotGroupHeaderHeight(headerHeight?: number): void;

function startEditingCell(
    params: StartEditingCellParams
): void;

interface StartEditingCellParams {
  // The row index of the row to start editing 
  rowIndex: number;
  // The column key of the row to start editing 
  colKey: string | Column;
  // Set to `'top'` or `'bottom'` to start editing a pinned row 
  rowPinned?: RowPinnedType;
  // The key to pass to the cell editor 
  key?: string;
  // The charPress to pass to the cell editor 
  charPress?: string;
}

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

function stopEditing(
    cancel: boolean = false
): void;

function getEditingCells(): CellPosition[];

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

function getCellEditorInstances(
    params: GetCellEditorInstancesParams<TData> = {}
): ICellEditor[];

interface GetCellEditorInstancesParams<TData = any> {
  // Optional list of row nodes to restrict operation to 
  rowNodes?: IRowNode<TData>[];
  // Optional list of columns to restrict operation to 
  columns?: (string | Column)[];
}

function addEventListener(
    eventType: string,
    listener: Function
): void;

function addGlobalListener(listener: Function): void;

function removeEventListener(
    eventType: string,
    listener: Function
): void;

function removeGlobalListener(listener: Function): void;

function addRenderedRowListener(
    eventName: string,
    rowIndex: number,
    callback: Function
): void;

function exportDataAsCsv(
    params?: CsvExportParams
): void;

function getDataAsCsv(
    params?: CsvExportParams
): string | undefined;

function exportDataAsExcel(
    params?: ExcelExportParams
): void;

function getDataAsExcel(
    params?: ExcelExportParams
): string | Blob | undefined;

function getSheetDataForExcel(
    params?: ExcelExportParams
): string | undefined;

function exportMultipleSheetsAsExcel(
    params: ExcelExportMultipleSheetParams
): void;

interface ExcelExportMultipleSheetParams {
  // The author of the exported file.
  // Default: `AG Grid`
  author?: string;
  // Array of strings containing the raw data for Excel workbook sheets.
  // This property is only used when exporting to multiple sheets using `api.exportMultipleSheetsAsExcel()` and the data for each sheet is obtained by calling `api.getSheetDataForExcel()`.
  data: string[];
  // String to use as the file name.
  // Default: `export.xlsx`
  fileName?: string;
  // The default value for the font size of the Excel document.
  // Default: `11`
  fontSize?: number;
  // The mimeType of the Excel file.
  // Default: `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`
  mimeType?: string;
}

function getMultipleSheetsAsExcel(
    params: ExcelExportMultipleSheetParams
): Blob | undefined;

interface ExcelExportMultipleSheetParams {
  // The author of the exported file.
  // Default: `AG Grid`
  author?: string;
  // Array of strings containing the raw data for Excel workbook sheets.
  // This property is only used when exporting to multiple sheets using `api.exportMultipleSheetsAsExcel()` and the data for each sheet is obtained by calling `api.getSheetDataForExcel()`.
  data: string[];
  // String to use as the file name.
  // Default: `export.xlsx`
  fileName?: string;
  // The default value for the font size of the Excel document.
  // Default: `11`
  fontSize?: number;
  // The mimeType of the Excel file.
  // Default: `application/vnd.openxmlformats-officedocument.spreadsheetml.sheet`
  mimeType?: string;
}

function getQuickFilter(): string | undefined;

function setQuickFilter(newFilter: string): void;

function resetQuickFilter(): void;

function isQuickFilterPresent(): boolean;

function setExcludeHiddenColumnsFromQuickFilter(value: boolean): void;

function isColumnFilterPresent(): boolean;

function isAnyFilterPresent(): boolean;

function getFilterInstance(
    key: string | Column,
    callback?: (filter: TFilter | null) => void
): TFilter | null | undefined;

function getFilterModel(): { [key: string]: any; };

function setFilterModel(model: any): void;

function onFilterChanged(): void;

function destroyFilter(key: string | Column): void;

function createRangeChart(
    params: CreateRangeChartParams
): ChartRef | undefined;

interface ChartRef {
  // 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;
}

function createPivotChart(
    params: CreatePivotChartParams
): ChartRef | undefined;

interface CreatePivotChartParams {
  // The type of chart to create. 
  chartType: ChartType;
  // The default theme to use, either a default option or your own custom theme. 
  chartThemeName?: string;
  // Provide to display the chart outside of the grid in your own container. 
  chartContainer?: HTMLElement;
  // Allows specific chart options in the current theme to be overridden. 
  chartThemeOverrides?: AgChartThemeOverrides;
  // When enabled the chart will be unlinked from the grid after creation, any updates to the data will not be reflected in the chart. 
  unlinkChart?: boolean;
}

type ChartType = 
      'column' 
    | 'groupedColumn' 
    | 'stackedColumn' 
    | 'normalizedColumn' 
    | 'bar' 
    | 'groupedBar' 
    | 'stackedBar' 
    | 'normalizedBar' 
    | 'line' 
    | 'scatter' 
    | 'bubble' 
    | 'pie' 
    | 'doughnut' 
    | 'area' 
    | 'stackedArea' 
    | 'normalizedArea' 
    | 'histogram' 
    | 'columnLineCombo' 
    | 'areaColumnCombo' 
    | 'customCombo'


interface ChartRef {
  // 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;
}

function createCrossFilterChart(
    params: CreateCrossFilterChartParams
): ChartRef | undefined;

interface CreateCrossFilterChartParams {
  // The type of cross-filter chart to create. 
  chartType: CrossFilterChartType;
  // The range of cells to be charted. If no rows / rowIndexes are specified all rows will be included. 
  cellRange: ChartParamsCellRange;
  // Suppress highlighting the selected range in the grid. 
  suppressChartRanges?: boolean;
  // The aggregation function that should be applied to all series data. 
  aggFunc?: string | IAggFunc;
  // The default theme to use, either a default option or your own custom theme. 
  chartThemeName?: string;
  // Provide to display the chart outside of the grid in your own container. 
  chartContainer?: HTMLElement;
  // Allows specific chart options in the current theme to be overridden. 
  chartThemeOverrides?: AgChartThemeOverrides;
  // When enabled the chart will be unlinked from the grid after creation, any updates to the data will not be reflected in the chart. 
  unlinkChart?: boolean;
}

type CrossFilterChartType = 
      'column' 
    | 'bar' 
    | 'line' 
    | 'scatter' 
    | 'bubble' 
    | 'pie' 
    | 'doughnut' 
    | 'area'


type ChartParamsCellRange = 
      Partial<Omit<CellRangeParams, 'rowStartPinned' 
    | 'rowEndPinned'>>


interface ChartRef {
  // 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;
}

function getChartRef(chartId: string): ChartRef | undefined;

interface ChartRef {
  // 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;
}

function getChartModels(): ChartModel[] | undefined;

function restoreChart(
    chartModel: ChartModel,
    chartContainer?: HTMLElement
): ChartRef | undefined;

interface ChartRef {
  // 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;
}

function getChartImageDataURL(
    params: GetChartImageDataUrlParams
): string | undefined;

interface GetChartImageDataUrlParams {
  // The id of the created chart. 
  chartId: string;
  // A string indicating the image format.
  // The default format type is `image/png`.
  // Options: `image/png`, `image/jpeg`
  fileFormat?: string;
}

function downloadChart(
    params: ChartDownloadParams
): void;

interface ChartDownloadParams {
  // The id of the created chart. 
  chartId: string;
  // Name of downloaded image file. The chart title will be used by default 
  fileName?: string;
  // A string indicating the image format.
  // The default format type is `image/png`.
  // Options: `image/png`, `image/jpeg`
  fileFormat?: string;
  // Dimensions of downloaded chart image in pixels. The current chart dimensions will be used if not specified.
  dimensions?: { width: number; height: number; };
}

function openChartToolPanel(
    params: OpenChartToolPanelParams
): void;

interface OpenChartToolPanelParams {
  // The id of the created chart. 
  chartId: string;
  // Name of the Chart Tool Panel. The default 'Settings' Tool Panel will be used if not specified.
  panel?: ChartToolPanelName;
}

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

function closeChartToolPanel(
    params: CloseChartToolPanelParams
): void;

interface CloseChartToolPanelParams {
  // The id of the created chart. 
  chartId: string;
}

function getFocusedCell(): CellPosition | null;

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

function setFocusedCell(
    rowIndex: number,
    colKey: string | Column,
    rowPinned?: RowPinnedType
): void;

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

function clearFocusedCell(): void;

function tabToNextCell(event?: KeyboardEvent): boolean;

function tabToPreviousCell(event?: KeyboardEvent): boolean;

function getDetailGridInfo(id: string): DetailGridInfo | undefined;

interface DetailGridInfo {
  // Id of the detail grid, the format is `detail_<ROW_ID>`,
  // where ROW_ID is the `id` of the parent row.
  id: string;
  // Grid api of the detail grid. 
  api?: GridApi;
  // Column api of the detail grid. 
  columnApi?: ColumnApi;
}

function forEachDetailGridInfo(
    callback: (gridInfo: DetailGridInfo, index: number) => void
): void;

interface DetailGridInfo {
  // Id of the detail grid, the format is `detail_<ROW_ID>`,
  // where ROW_ID is the `id` of the parent row.
  id: string;
  // Grid api of the detail grid. 
  api?: GridApi;
  // Column api of the detail grid. 
  columnApi?: ColumnApi;
}

function addDetailGridInfo(
    id: string,
    gridInfo: DetailGridInfo
): void;

interface DetailGridInfo {
  // Id of the detail grid, the format is `detail_<ROW_ID>`,
  // where ROW_ID is the `id` of the parent row.
  id: string;
  // Grid api of the detail grid. 
  api?: GridApi;
  // Column api of the detail grid. 
  columnApi?: ColumnApi;
}

function removeDetailGridInfo(id: string): void;

function getValue(
    colKey: string | Column,
    rowNode: IRowNode
): any;

function setDomLayout(
    domLayout?: DomLayoutType
): void;

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

function destroy(): void;

function setGridAriaProperty(
    property: string,
    value: string | null
): void;

function isAnimationFrameQueueEmpty(): boolean;

function showLoadingOverlay(): void;

function showNoRowsOverlay(): void;

function hideOverlay(): void;

function setPagination(value: boolean): void;

function paginationIsLastPageFound(): boolean;

function paginationGetPageSize(): number;

function paginationSetPageSize(size?: number): void;

function paginationGetCurrentPage(): number;

function paginationGetTotalPages(): number;

function paginationGetRowCount(): number;

function paginationGoToPage(page: number): void;

function paginationGoToNextPage(): void;

function paginationGoToPreviousPage(): void;

function paginationGoToFirstPage(): void;

function paginationGoToLastPage(): void;

function addAggFunc(
    key: string,
    aggFunc: IAggFunc
): void;

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

function addAggFuncs(
    aggFuncs: { [key: string]: IAggFunc; }
): void;

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

function clearAggFuncs(): void;

function refreshCells(
    params: RefreshCellsParams<TData> = {}
): void;

interface RefreshCellsParams<TData = any> {
  // Skip change detection, refresh everything. 
  force?: boolean;
  // Skip cell flashing, if cell flashing is enabled. 
  suppressFlash?: boolean;
  // Optional list of row nodes to restrict operation to 
  rowNodes?: IRowNode<TData>[];
  // Optional list of columns to restrict operation to 
  columns?: (string | Column)[];
}

function redrawRows(
    params: RedrawRowsParams<TData> = {}
): void;

interface RedrawRowsParams<TData = any> {
  // Row nodes to redraw 
  rowNodes?: IRowNode<TData>[];
}

function refreshHeader(): void;

function flashCells(
    params: FlashCellsParams<TData> = {}
): void;

interface FlashCellsParams<TData = any> {
  flashDelay?: number;
  fadeDelay?: number;
  // Optional list of row nodes to restrict operation to 
  rowNodes?: IRowNode<TData>[];
  // Optional list of columns to restrict operation to 
  columns?: (string | Column)[];
}

function getRenderedNodes(): IRowNode<TData>[];

function getCellRendererInstances(
    params: GetCellRendererInstancesParams<TData> = {}
): ICellRenderer[];

interface GetCellRendererInstancesParams<TData = any> {
  // Optional list of row nodes to restrict operation to 
  rowNodes?: IRowNode<TData>[];
  // Optional list of columns to restrict operation to 
  columns?: (string | Column)[];
}

interface ICellRenderer<TData = any> {
  // Get the cell to refresh. Return true if successful. Return false if not (or you don't have refresh logic),
  // then the grid will refresh the cell for you.
  refresh(params: ICellRendererParams<TData>): boolean;
}

function getSizesForCurrentTheme(): void;

function resetRowHeights(): void;

function onRowHeightChanged(): void;

function getDisplayedRowAtIndex(index: number): IRowNode<TData> | undefined;

function getDisplayedRowCount(): number;

function getFirstDisplayedRow(): number;

function getLastDisplayedRow(): number;

function setSuppressRowDrag(value: boolean): void;

function setSuppressMoveWhenRowDragging(value: boolean): void;

function addRowDropZone(
    params: RowDropZoneParams
): void;

interface RowDropZoneParams {
  // A callback method that returns the DropZone HTMLElement. 
  getContainer: () => HTMLElement;
  // Callback function that will be executed when the rowDrag enters the target. 
  onDragEnter?: (params: RowDragEnterEvent) => void;
  // Callback function that will be executed when the rowDrag leaves the target 
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  // Callback function that will be executed when the rowDrag is dragged inside the target.
  // Note: this gets called multiple times.
  onDragging?: (params: RowDragMoveEvent) => void;
  // Callback function that will be executed when the rowDrag drops rows within the target. 
  onDragStop?: (params: RowDragEndEvent) => void;
}

function removeRowDropZone(
    params: RowDropZoneParams
): void;

interface RowDropZoneParams {
  // A callback method that returns the DropZone HTMLElement. 
  getContainer: () => HTMLElement;
  // Callback function that will be executed when the rowDrag enters the target. 
  onDragEnter?: (params: RowDragEnterEvent) => void;
  // Callback function that will be executed when the rowDrag leaves the target 
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  // Callback function that will be executed when the rowDrag is dragged inside the target.
  // Note: this gets called multiple times.
  onDragging?: (params: RowDragMoveEvent) => void;
  // Callback function that will be executed when the rowDrag drops rows within the target. 
  onDragStop?: (params: RowDragEndEvent) => void;
}

function getRowDropZoneParams(
    events?: RowDropZoneEvents
): RowDropZoneParams;

interface RowDropZoneEvents {
  // Callback function that will be executed when the rowDrag enters the target. 
  onDragEnter?: (params: RowDragEnterEvent) => void;
  // Callback function that will be executed when the rowDrag leaves the target 
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  // Callback function that will be executed when the rowDrag is dragged inside the target.
  // Note: this gets called multiple times.
  onDragging?: (params: RowDragMoveEvent) => void;
  // Callback function that will be executed when the rowDrag drops rows within the target. 
  onDragStop?: (params: RowDragEndEvent) => void;
}

interface RowDropZoneParams {
  // A callback method that returns the DropZone HTMLElement. 
  getContainer: () => HTMLElement;
  // Callback function that will be executed when the rowDrag enters the target. 
  onDragEnter?: (params: RowDragEnterEvent) => void;
  // Callback function that will be executed when the rowDrag leaves the target 
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  // Callback function that will be executed when the rowDrag is dragged inside the target.
  // Note: this gets called multiple times.
  onDragging?: (params: RowDragMoveEvent) => void;
  // Callback function that will be executed when the rowDrag drops rows within the target. 
  onDragStop?: (params: RowDragEndEvent) => void;
}

function expandAll(): void;

function collapseAll(): void;

function setRowNodeExpanded(
    rowNode: IRowNode,
    expanded: boolean,
    expandParents?: boolean
): void;

function onGroupExpandedOrCollapsed(): void;

function getRowNode(id: string): IRowNode<TData> | undefined;

function forEachNode(
    callback: (rowNode: IRowNode<TData>, index: number) => void,
    includeFooterNodes?: boolean
): void;

function forEachNodeAfterFilter(
    callback: (rowNode: IRowNode<TData>, index: number) => void
): void;

function forEachNodeAfterFilterAndSort(
    callback: (rowNode: IRowNode<TData>, index: number) => void
): void;

function forEachLeafNode(
    callback: (rowNode: IRowNode<TData>) => void
): void;

function setPinnedTopRowData(rows?: any[]): void;

function setPinnedBottomRowData(rows?: any[]): void;

function getPinnedTopRowCount(): number;

function getPinnedBottomRowCount(): number;

function getPinnedTopRow(index: number): IRowNode | undefined;

function getPinnedBottomRow(index: number): IRowNode | undefined;

function getModel(): IRowModel;

interface IRowModel {
  // Returns the rowNode at the given index. 
  getRow(index: number): RowNode | undefined;
  // Returns the rowNode for given id. 
  getRowNode(id: string): RowNode | undefined;
  // Returns the number of rows 
  getRowCount(): number;
  getTopLevelRowCount(): number;
  getTopLevelRowDisplayedIndex(topLevelIndex: number): number;
  // Returns the row index at the given pixel 
  getRowIndexAtPixel(pixel: number): number;
  // Returns true if the provided rowNode is in the list of rows to render 
  isRowPresent(rowNode: RowNode): boolean;
  // Returns row top and bottom for a given row 
  getRowBounds(index: number): RowBounds | null;
  // Returns true if this model has no rows, regardless of model filter. EG if rows present, but filtered
  // out, this still returns false. If it returns true, then the grid shows the 'no rows' overlay - but we
  // don't show that overlay if the rows are just filtered out. 
  isEmpty(): boolean;
  // Returns true if no rows (either no rows at all, or the rows are filtered out). This is what the grid
  // uses to know if there are rows to render or not. 
  isRowsToRender(): boolean;
  // Returns all rows in range that should be selected. If there is a gap in range (non ClientSideRowModel) then
  //  then no rows should be returned  
  getNodesInRangeForSelection(first: RowNode, last: RowNode | null): RowNode[];
  // Iterate through each node. What this does depends on the model type. For clientSide, goes through
  // all nodes. For serverSide, goes through what's loaded in memory. 
  forEachNode(callback: (rowNode: RowNode, index: number) => void, includeFooterNodes?: boolean): void;
  // The base class returns the type. We use this instead of 'instanceof' as the client might provide
  // their own implementation of the models in the future. 
  getType(): RowModelType;
  // It tells us if this row model knows about the last row that it can produce. This is used by the
  // PaginationPanel, if last row is not found, then the 'last' button is disabled and the last page is
  // not shown. This is always true for ClientSideRowModel. It toggles for InfiniteRowModel.
  isLastRowIndexKnown(): boolean;
  // Used by CSRM only - is makes sure there are now estimated row heights within the range. 
  ensureRowHeightsValid(startPixel: number, endPixel: number, startLimitIndex: number, endLimitIndex: number): boolean;
  // Gets called after grid is initialised. What happens depends on row model. Client Side will take rowData
  // from gridOptions, the other row models will start calling their datasources. 
  start(): void;
}

interface RowBounds {
  rowTop: number;
  rowHeight: number;
  rowIndex?: number;
}

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

function setRowData(rowData: TData[]): void;

function applyTransaction(
    rowDataTransaction: RowDataTransaction<TData>
): RowNodeTransaction<TData> | null | undefined;

interface RowDataTransaction<TData = any> {
  // Index to add rows 
  addIndex?: number | null;
  // Rows to add 
  add?: TData[] | null;
  // Rows to remove 
  remove?: TData[] | null;
  // Rows to update 
  update?: TData[] | null;
}

interface RowNodeTransaction<TData = any> {
  // Row nodes added 
  add: IRowNode<TData>[];
  // Row nodes removed 
  remove: IRowNode<TData>[];
  // Row nodes updated 
  update: IRowNode<TData>[];
}

function applyTransactionAsync(
    rowDataTransaction: RowDataTransaction<TData>,
    callback?: (res: RowNodeTransaction<TData>) => void
): void;

interface RowDataTransaction<TData = any> {
  // Index to add rows 
  addIndex?: number | null;
  // Rows to add 
  add?: TData[] | null;
  // Rows to remove 
  remove?: TData[] | null;
  // Rows to update 
  update?: TData[] | null;
}

interface RowNodeTransaction<TData = any> {
  // Row nodes added 
  add: IRowNode<TData>[];
  // Row nodes removed 
  remove: IRowNode<TData>[];
  // Row nodes updated 
  update: IRowNode<TData>[];
}

function flushAsyncTransactions(): void;

function refreshClientSideRowModel(
    step?: ClientSideRowModelStep
): any;

type ClientSideRowModelStep = 
      'everything' 
    | 'group' 
    | 'filter' 
    | 'pivot' 
    | 'aggregate' 
    | 'sort' 
    | 'map'

function setDatasource(
    datasource: IDatasource
): void;

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

function refreshInfiniteCache(): void;

function purgeInfiniteCache(): void;

function getInfiniteRowCount(): number | undefined;

function isLastRowIndexKnown(): boolean | undefined;

function setRowCount(
    rowCount: number,
    maxRowFound?: boolean
): void;

function getCacheBlockState(): any;

function setServerSideDatasource(
    datasource: IServerSideDatasource
): void;

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

function setCacheBlockSize(blockSize: number): void;

function setRowCount(
    rowCount: number,
    maxRowFound?: boolean
): void;

function refreshServerSide(
    params?: RefreshServerSideParams
): void;

interface RefreshServerSideParams {
  // List of group keys, pointing to the level to refresh.
  // For example, to purge two levels down under 'Canada'and then '2002', pass in the string array ['Canada','2002'].
  // If no route is passed, or an empty array, then the top level is refreshed.
  route?: string[];
  // If true, then all rows at the level getting refreshed are immediately destroyed and 'loading' rows will appear.
  // If false, then all rows at the level getting refreshed are kept until rows are loaded (no 'loading' rows appear).
  purge?: boolean;
}

function getServerSideGroupLevelState(): ServerSideGroupLevelState[];

interface ServerSideGroupLevelState {
  // True if suppressing infinite scrolling and loading all the data at the current level 
  suppressInfiniteScroll: boolean;
  // The route that identifies this level. 
  route: string[];
  // How many rows the level has. This includes 'loading rows'. 
  rowCount: number;
  // Infinite Scroll only.
  // Whether the last row index is know.
  // 
  lastRowIndexKnown?: boolean;
  // Any extra info provided to the level, when data was loaded. 
  info?: any;
  //Infinite Scroll only.
  // Max blocks allowed in the infinite cache.
  maxBlocksInCache?: number;
  // Infinite Scroll only.
  // The size (number of rows) of each infinite cache block.
  cacheBlockSize?: number;
}

function retryServerSideLoads(): void;

function applyServerSideTransaction(
    transaction: ServerSideTransaction
): ServerSideTransactionResult | undefined;

interface ServerSideTransaction {
  // The Row Store to apply the transaction to, ie what group level.
  // eg ['Ireland','2002'] to update the child store found after expanding Ireland and 2002 groups.
  // Passing in blank to empty applies the transaction to the top level.
  route?: string[];
  // Index position to add at. If missing, rows will be added to the end. 
  addIndex?: number;
  // Rows to add 
  add?: any[];
  // Rows to remove 
  remove?: any[];
  // Rows to update 
  update?: any[];
}

interface ServerSideTransactionResult {
  // The status of applying the transaction. 
  status: ServerSideTransactionResultStatus;
  // If rows were added, the newly created Row Nodes for those rows. 
  add?: IRowNode[];
  // If rows were removed, the deleted Row Nodes. 
  remove?: IRowNode[];
  // If rows were updated, the updated Row Nodes. 
  update?: IRowNode[];
}

enum ServerSideTransactionResultStatus {
  // Transaction was successfully applied 
  Applied = 'Applied'
  // Store was not found, transaction not applied.
  // Either invalid route, or the parent row has not yet been expanded.
  StoreNotFound = 'StoreNotFound'
  // Store is loading, transaction not applied.
  StoreLoading = 'StoreLoading'
  // Store is loading (as max loads exceeded), transaction not applied.
  StoreWaitingToLoad = 'StoreWaitingToLoad'
  // Store load attempt failed, transaction not applied.
  StoreLoadingFailed = 'StoreLoadingFailed'
  // Store is type Partial, which doesn't accept transactions
  StoreWrongType = 'StoreWrongType'
  // Transaction was cancelled, due to grid.
  // Callback isApplyServerSideTransaction() returning false
  Cancelled = 'Cancelled'
}

function applyServerSideTransactionAsync(
    transaction: ServerSideTransaction,
    callback?: (res: ServerSideTransactionResult) => void
): void;

interface ServerSideTransaction {
  // The Row Store to apply the transaction to, ie what group level.
  // eg ['Ireland','2002'] to update the child store found after expanding Ireland and 2002 groups.
  // Passing in blank to empty applies the transaction to the top level.
  route?: string[];
  // Index position to add at. If missing, rows will be added to the end. 
  addIndex?: number;
  // Rows to add 
  add?: any[];
  // Rows to remove 
  remove?: any[];
  // Rows to update 
  update?: any[];
}

interface ServerSideTransactionResult {
  // The status of applying the transaction. 
  status: ServerSideTransactionResultStatus;
  // If rows were added, the newly created Row Nodes for those rows. 
  add?: IRowNode[];
  // If rows were removed, the deleted Row Nodes. 
  remove?: IRowNode[];
  // If rows were updated, the updated Row Nodes. 
  update?: IRowNode[];
}

enum ServerSideTransactionResultStatus {
  // Transaction was successfully applied 
  Applied = 'Applied'
  // Store was not found, transaction not applied.
  // Either invalid route, or the parent row has not yet been expanded.
  StoreNotFound = 'StoreNotFound'
  // Store is loading, transaction not applied.
  StoreLoading = 'StoreLoading'
  // Store is loading (as max loads exceeded), transaction not applied.
  StoreWaitingToLoad = 'StoreWaitingToLoad'
  // Store load attempt failed, transaction not applied.
  StoreLoadingFailed = 'StoreLoadingFailed'
  // Store is type Partial, which doesn't accept transactions
  StoreWrongType = 'StoreWrongType'
  // Transaction was cancelled, due to grid.
  // Callback isApplyServerSideTransaction() returning false
  Cancelled = 'Cancelled'
}

function getServerSideSelectionState(): IServerSideSelectionState | IServerSideGroupSelectionState | null;

interface IServerSideSelectionState {
  selectAll: boolean;
  toggledNodes: string[];
}

interface IServerSideGroupSelectionState {
  nodeId?: string;
  selectAllChildren?: boolean;
  toggledNodes?: IServerSideGroupSelectionState[];
}

function setServerSideSelectionState(
    state: IServerSideSelectionState | IServerSideGroupSelectionState
): void;

interface IServerSideSelectionState {
  selectAll: boolean;
  toggledNodes: string[];
}

interface IServerSideGroupSelectionState {
  nodeId?: string;
  selectAllChildren?: boolean;
  toggledNodes?: IServerSideGroupSelectionState[];
}

function getCacheBlockState(): any;

function setViewportDatasource(
    viewportDatasource: IViewportDatasource
): void;

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

function setAlwaysShowHorizontalScroll(show: boolean): void;

function setAlwaysShowVerticalScroll(show: boolean): void;

function ensureIndexVisible(
    index: number,
    position?: 'top' | 'bottom' | 'middle' | null
): void;

function ensureNodeVisible(
    nodeSelector: TData | IRowNode<TData> | ((row: IRowNode<TData>) => boolean),
    position: 'top' | 'bottom' | 'middle' | null = null
): void;

function ensureColumnVisible(
    key: string | Column,
    position: 'auto' | 'start' | 'middle' | 'end' = 'auto'
): void;

function getHorizontalPixelRange(): { left: number, right: number; };

function getVerticalPixelRange(): { top: number, bottom: number; };

function selectAll(
    source: SelectionEventSourceType = 'apiSelectAll'
): void;

type SelectionEventSourceType = 
      'api' 
    | 'apiSelectAll' 
    | 'apiSelectAllFiltered' 
    | 'apiSelectAllCurrentPage' 
    | 'checkboxSelected' 
    | 'rowClicked' 
    | 'rowDataChanged' 
    | 'rowGroupChanged' 
    | 'selectableChanged' 
    | 'spacePressed' 
    | 'uiSelectAll' 
    | 'uiSelectAllFiltered' 
    | 'uiSelectAllCurrentPage'

function deselectAll(
    source: SelectionEventSourceType = 'apiSelectAll'
): void;

type SelectionEventSourceType = 
      'api' 
    | 'apiSelectAll' 
    | 'apiSelectAllFiltered' 
    | 'apiSelectAllCurrentPage' 
    | 'checkboxSelected' 
    | 'rowClicked' 
    | 'rowDataChanged' 
    | 'rowGroupChanged' 
    | 'selectableChanged' 
    | 'spacePressed' 
    | 'uiSelectAll' 
    | 'uiSelectAllFiltered' 
    | 'uiSelectAllCurrentPage'

function selectAllFiltered(
    source: SelectionEventSourceType = 'apiSelectAllFiltered'
): void;

type SelectionEventSourceType = 
      'api' 
    | 'apiSelectAll' 
    | 'apiSelectAllFiltered' 
    | 'apiSelectAllCurrentPage' 
    | 'checkboxSelected' 
    | 'rowClicked' 
    | 'rowDataChanged' 
    | 'rowGroupChanged' 
    | 'selectableChanged' 
    | 'spacePressed' 
    | 'uiSelectAll' 
    | 'uiSelectAllFiltered' 
    | 'uiSelectAllCurrentPage'

function deselectAllFiltered(
    source: SelectionEventSourceType = 'apiSelectAllFiltered'
): void;

type SelectionEventSourceType = 
      'api' 
    | 'apiSelectAll' 
    | 'apiSelectAllFiltered' 
    | 'apiSelectAllCurrentPage' 
    | 'checkboxSelected' 
    | 'rowClicked' 
    | 'rowDataChanged' 
    | 'rowGroupChanged' 
    | 'selectableChanged' 
    | 'spacePressed' 
    | 'uiSelectAll' 
    | 'uiSelectAllFiltered' 
    | 'uiSelectAllCurrentPage'

function selectAllOnCurrentPage(
    source: SelectionEventSourceType = 'apiSelectAllCurrentPage'
): void;

type SelectionEventSourceType = 
      'api' 
    | 'apiSelectAll' 
    | 'apiSelectAllFiltered' 
    | 'apiSelectAllCurrentPage' 
    | 'checkboxSelected' 
    | 'rowClicked' 
    | 'rowDataChanged' 
    | 'rowGroupChanged' 
    | 'selectableChanged' 
    | 'spacePressed' 
    | 'uiSelectAll' 
    | 'uiSelectAllFiltered' 
    | 'uiSelectAllCurrentPage'

function deselectAllOnCurrentPage(
    source: SelectionEventSourceType = 'apiSelectAllCurrentPage'
): void;

type SelectionEventSourceType = 
      'api' 
    | 'apiSelectAll' 
    | 'apiSelectAllFiltered' 
    | 'apiSelectAllCurrentPage' 
    | 'checkboxSelected' 
    | 'rowClicked' 
    | 'rowDataChanged' 
    | 'rowGroupChanged' 
    | 'selectableChanged' 
    | 'spacePressed' 
    | 'uiSelectAll' 
    | 'uiSelectAllFiltered' 
    | 'uiSelectAllCurrentPage'

function getSelectedNodes(): IRowNode<TData>[];

function getSelectedRows(): TData[];

function getBestCostNodeSelection(): IRowNode<TData>[] | undefined;

function getCellRanges(): CellRange[] | null;

interface CellRange {
  id?: string;
  type?: CellRangeType;
  // The start row of the range 
  startRow?: RowPosition;
  // The end row of the range 
  endRow?: RowPosition;
  // The columns in the range 
  columns: Column[];
  // The start column for the range 
  startColumn: Column;
}

enum CellRangeType {
  VALUE
  DIMENSION
}

interface RowPosition {
  // 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

function addCellRange(
    params: CellRangeParams
): void;

interface CellRangeParams {
  // Start row index 
  rowStartIndex: number | null;
  // Pinned state of start row. Either 'top', 'bottom' or null 
  rowStartPinned?: RowPinnedType;
  // End row index 
  rowEndIndex: number | null;
  // Pinned state of end row. Either 'top', 'bottom' or null 
  rowEndPinned?: RowPinnedType;
  // Starting column for range 
  columnStart?: string | Column;
  // End column for range 
  columnEnd?: string | Column;
  // Specify Columns to include instead of using `columnStart` and `columnEnd` 
  columns?: (string | Column)[];
}

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

function clearRangeSelection(): void;

function setSuppressRowClickSelection(value: boolean): void;

function setEnableCellTextSelection(selectable: boolean): void;

function setFillHandleDirection(
    direction: 'x' | 'y' | 'xy'
): void;

function onSortChanged(): void;

function setDeltaSort(enable: boolean): void;

function undoCellEditing(): void;

function redoCellEditing(): void;

function getCurrentUndoSize(): number;

function getCurrentRedoSize(): number;