React Data Grid: Grid API

function getColumnDefs(): (ColDef | ColGroupDef)[];

function sizeColumnsToFit(): void;

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

type ColumnEventType = 
      "sizeColumnsToFit" 
    | "autosizeColumns" 
    | "alignedGridChanged" 
    | "filterChanged" 
    | "filterDestroyed" 
    | "gridOptionsChanged" 
    | "gridInitializing" 
    | "toolPanelDragAndDrop" 
    | "toolPanelUi" 
    | "uiColumnMoved" 
    | "uiColumnResized" 
    | "uiColumnDragged" 
    | "uiColumnExpanded" 
    | "uiColumnSorted" 
    | "contextMenu" 
    | "columnMenu" 
    | "rowModelUpdated" 
    | "api" 
    | "flex" 
    | "pivotChart"

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

type ColumnEventType = 
      "sizeColumnsToFit" 
    | "autosizeColumns" 
    | "alignedGridChanged" 
    | "filterChanged" 
    | "filterDestroyed" 
    | "gridOptionsChanged" 
    | "gridInitializing" 
    | "toolPanelDragAndDrop" 
    | "toolPanelUi" 
    | "uiColumnMoved" 
    | "uiColumnResized" 
    | "uiColumnDragged" 
    | "uiColumnExpanded" 
    | "uiColumnSorted" 
    | "contextMenu" 
    | "columnMenu" 
    | "rowModelUpdated" 
    | "api" 
    | "flex" 
    | "pivotChart"

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

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

interface RowDataTransaction {
  addIndex?: number | null;
  add?: any[] | null;
  remove?: any[] | null;
  update?: any[] | null;
}

interface RowNodeTransaction {
  add: RowNode[];
  remove: RowNode[];
  update: RowNode[];
}

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

interface RowDataTransaction {
  addIndex?: number | null;
  add?: any[] | null;
  remove?: any[] | null;
  update?: any[] | null;
}

interface RowNodeTransaction {
  add: RowNode[];
  remove: RowNode[];
  update: RowNode[];
}

function flushAsyncTransactions(): void;

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

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

function getPinnedTopRowCount(): number;

function getPinnedBottomRowCount(): number;

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

function getPinnedBottomRow(index: number): RowNode | 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;
  // This is legacy, not used by AG Grid, but keeping for backward compatibility 
  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): 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(): string;
  // 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;
}

function refreshClientSideRowModel(step: string): any;

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. See below for params. 
  getRows(params: IGetRowsParams): void;
  destroy?(): void;
}

function setServerSideDatasource(
    datasource: IServerSideDatasource
): void;

interface IServerSideDatasource {
  getRows(params: IServerSideGetRowsParams): void;
  destroy?(): void;
}

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

function getRowNode(id: string): RowNode | undefined;

function forEachNode(
    callback: (rowNode: RowNode, index: number) => void
): void;

function forEachNodeAfterFilter(
    callback: (rowNode: RowNode, index: number) => void
): void;

function forEachNodeAfterFilterAndSort(
    callback: (rowNode: RowNode, index: number) => void
): void;

function forEachLeafNode(
    callback: (rowNode: RowNode) => void
): void;

function getDisplayedRowAtIndex(index: number): RowNode | undefined;

function getDisplayedRowCount(): number;

function getFirstDisplayedRow(): number;

function getLastDisplayedRow(): number;

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

interface DetailGridInfo {
  api?: GridApi;
  columnApi?: ColumnApi;
  id: string;
}

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

interface DetailGridInfo {
  api?: GridApi;
  columnApi?: ColumnApi;
  id: string;
}

function selectAll(): void;

function deselectAll(): void;

function selectAllFiltered(): void;

function deselectAllFiltered(): void;

function getSelectedNodes(): RowNode[];

function getSelectedRows(): any[];

function getBestCostNodeSelection(): RowNode[] | undefined;

function getCellRanges(): CellRange[] | null;

interface CellRange {
  id?: string;
  type?: CellRangeType;
  startRow?: RowPosition;
  endRow?: RowPosition;
  columns: Column[];
  startColumn: Column;
}

function addCellRange(
    params: CellRangeParams
): void;

interface CellRangeParams {
  rowStartIndex: number | null;
  rowStartPinned?: string | null;
  rowEndIndex: number | null;
  rowEndPinned?: string | null;
  columnStart?: string | Column;
  columnEnd?: string | Column;
  columns?: (string | Column)[];
}

function clearRangeSelection(): void;

function setSuppressRowClickSelection(value: boolean): void;

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

interface RefreshCellsParams {
  rowNodes?: RowNode[];
  columns?: (string | Column)[];
  force?: boolean;
  suppressFlash?: boolean;
}

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

interface RedrawRowsParams {
  rowNodes?: RowNode[];
}

function refreshHeader(): void;

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

interface FlashCellsParams {
  rowNodes?: RowNode[];
  columns?: (string | Column)[];
  flashDelay?: number;
  fadeDelay?: number;
}

function setQuickFilter(newFilter: any): void;

function isQuickFilterPresent(): boolean;

function isColumnFilterPresent(): boolean;

function isAnyFilterPresent(): boolean;

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

interface IFilterComp {
  // Return the DOM element of your component, this is what the grid puts into the DOM 
  getGui(): HTMLElement;
  // Gets called once by grid when the component is being removed; if your component needs to do any cleanup, do it here 
  destroy?(): void;
  // A hook to perform any necessary operation just after the GUI for this component has been rendered
  // on the screen.
  // If a parent popup is closed and reopened (e.g. for filters), this method is called each time the component is shown.
  // This is useful for any
  // logic that requires attachment before executing, such as putting focus on a particular DOM
  // element. The params has one callback method 'hidePopup', which you can call at any later
  // point to hide the popup - good if you have an 'Apply' button and you want to hide the popup
  // after it is pressed. 
  afterGuiAttached?(params?: IAfterGuiAttachedParams): void;
  // The init(params) method is called on the component once. See below for details on the parameters. 
  init?(params: IFilterParams): AgPromise<void> | void;
  // This is used to let the grid know if the filter is active or not 
  isFilterActive(): boolean;
  // The grid will ask each active filter, in turn, whether each row in the grid passes. If any
  // filter fails, then the row will be excluded from the final set. The method is provided a
  // params object with attributes node (the rodNode the grid creates that wraps the data) and data
  // (the data object that you provided to the grid for that row). 
  doesFilterPass(params: IDoesFilterPassParams): boolean;
  // Gets the filter state for storing 
  getModel(): any;
  // Restores the filter state. 
  setModel(model: any): void | AgPromise<void>;
  // Gets called when new rows are inserted into the grid. If the filter needs to change its
  // state after rows are loaded, it can do it here. For example the set filters uses this
  // to update the list of available values to select from (e.g. 'Ireland', 'UK' etc for
  // Country filter). To get the list of available values from within this method from the
  // Client Side Row Model, use gridApi.forEachLeafNode(callback). 
  onNewRowsLoaded?(): void;
  // Called whenever any filter is changed. 
  onAnyFilterChanged?(): void;
  // If using React or Angular 2, returns the underlying component instance, so you can call methods
  // on it if you want. 
  getFrameworkComponentInstance?(): any;
  // Optional method used by AG Grid when rendering floating filters and there isn't a floating filter
  // associated for this filter, this will happen if you create a custom filter and NOT a custom floating
  // filter. 
  getModelAsString?(model: any): string;
}

interface IFilterComp {
  // Return the DOM element of your component, this is what the grid puts into the DOM 
  getGui(): HTMLElement;
  // Gets called once by grid when the component is being removed; if your component needs to do any cleanup, do it here 
  destroy?(): void;
  // A hook to perform any necessary operation just after the GUI for this component has been rendered
  // on the screen.
  // If a parent popup is closed and reopened (e.g. for filters), this method is called each time the component is shown.
  // This is useful for any
  // logic that requires attachment before executing, such as putting focus on a particular DOM
  // element. The params has one callback method 'hidePopup', which you can call at any later
  // point to hide the popup - good if you have an 'Apply' button and you want to hide the popup
  // after it is pressed. 
  afterGuiAttached?(params?: IAfterGuiAttachedParams): void;
  // The init(params) method is called on the component once. See below for details on the parameters. 
  init?(params: IFilterParams): AgPromise<void> | void;
  // This is used to let the grid know if the filter is active or not 
  isFilterActive(): boolean;
  // The grid will ask each active filter, in turn, whether each row in the grid passes. If any
  // filter fails, then the row will be excluded from the final set. The method is provided a
  // params object with attributes node (the rodNode the grid creates that wraps the data) and data
  // (the data object that you provided to the grid for that row). 
  doesFilterPass(params: IDoesFilterPassParams): boolean;
  // Gets the filter state for storing 
  getModel(): any;
  // Restores the filter state. 
  setModel(model: any): void | AgPromise<void>;
  // Gets called when new rows are inserted into the grid. If the filter needs to change its
  // state after rows are loaded, it can do it here. For example the set filters uses this
  // to update the list of available values to select from (e.g. 'Ireland', 'UK' etc for
  // Country filter). To get the list of available values from within this method from the
  // Client Side Row Model, use gridApi.forEachLeafNode(callback). 
  onNewRowsLoaded?(): void;
  // Called whenever any filter is changed. 
  onAnyFilterChanged?(): void;
  // If using React or Angular 2, returns the underlying component instance, so you can call methods
  // on it if you want. 
  getFrameworkComponentInstance?(): any;
  // Optional method used by AG Grid when rendering floating filters and there isn't a floating filter
  // associated for this filter, this will happen if you create a custom filter and NOT a custom floating
  // filter. 
  getModelAsString?(model: any): string;
}

function getFilterModel(): void;

function setFilterModel(model: any): void;

function onFilterChanged(): void;

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

function onSortChanged(): void;

function getFocusedCell(): CellPosition | null;

interface CellPosition {
  // 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 undefined/null (for not pinned) 
  rowPinned: string | null;
  // The grid column 
  column: Column;
}

function setFocusedCell(
    rowIndex: number,
    colKey: string | Column,
    floating: string
): void;

function clearFocusedCell(): void;

function tabToNextCell(): boolean;

function tabToPreviousCell(): boolean;

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

function startEditingCell(
    params: StartEditingCellParams
): void;

interface StartEditingCellParams {
  rowIndex: number;
  colKey: string | Column;
  rowPinned?: string;
  keyPress?: number;
  charPress?: string;
}

function getEditingCells(): CellPosition[];

interface CellPosition {
  // 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 undefined/null (for not pinned) 
  rowPinned: string | null;
  // The grid column 
  column: Column;
}

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 {
  author?: string;
  data: string[];
  fileName?: string;
  fontSize?: number;
}

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

interface ExcelExportMultipleSheetParams {
  author?: string;
  data: string[];
  fileName?: string;
  fontSize?: number;
}

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 expandAll(): void;

function collapseAll(): void;

function setRowNodeExpanded(
    rowNode: RowNode,
    expanded: boolean
): void;

function onGroupExpandedOrCollapsed(
    deprecated_refreshFromIndex: any
): void;

function setSuppressRowDrag(value: boolean): void;

function setSuppressMoveWhenRowDragging(value: boolean): void;

function addRowDropZone(
    params: RowDropZoneParams
): void;

interface RowDropZoneParams {
  onDragEnter?: (params: RowDragEnterEvent) => void;
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  onDragging?: (params: RowDragMoveEvent) => void;
  onDragStop?: (params: RowDragEndEvent) => void;
  getContainer: () => HTMLElement;
}

function removeRowDropZone(
    params: RowDropZoneParams
): void;

interface RowDropZoneParams {
  onDragEnter?: (params: RowDragEnterEvent) => void;
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  onDragging?: (params: RowDragMoveEvent) => void;
  onDragStop?: (params: RowDragEndEvent) => void;
  getContainer: () => HTMLElement;
}

function getRowDropZoneParams(
    events: RowDropZoneEvents
): RowDropZoneParams;

interface RowDropZoneEvents {
  onDragEnter?: (params: RowDragEnterEvent) => void;
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  onDragging?: (params: RowDragMoveEvent) => void;
  onDragStop?: (params: RowDragEndEvent) => void;
}

interface RowDropZoneParams {
  onDragEnter?: (params: RowDragEnterEvent) => void;
  onDragLeave?: (params: RowDragLeaveEvent) => void;
  onDragging?: (params: RowDragMoveEvent) => void;
  onDragStop?: (params: RowDragEndEvent) => void;
  getContainer: () => HTMLElement;
}

function getRenderedNodes(): RowNode[];

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

interface GetCellRendererInstancesParams {
  rowNodes?: RowNode[];
  columns?: (string | Column)[];
}

interface ICellRenderer {
  // 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): boolean;
}

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

interface GetCellEditorInstancesParams {
  rowNodes?: RowNode[];
  columns?: (string | Column)[];
}

interface ICellEditor {
  // Return the final value - called by the grid once after editing is complete 
  getValue(): any;
  // Gets called once after initialised. If you return true, the editor will
  // appear in a popup, so is not constrained to the boundaries of the cell.
  // This is great if you want to, for example, provide you own custom dropdown list
  // for selection. Default is false (ie if you don't provide the method). 
  isPopup?(): boolean;
  // Gets called once, only if isPopup() returns true. Return "over" if the popup
  // should cover the cell, or "under" if it should be positioned below leaving the
  // cell value visible. If this method is not present, the default is "over". 
  getPopupPosition?(): string | undefined;
  // Gets called once after initialised. If you return true, the editor will not be
  // used and the grid will continue editing. Use this to make a decision on editing
  // inside the init() function, eg maybe you want to only start editing if the user
  // hits a numeric key, but not a letter, if the editor is for numbers. 
  isCancelBeforeStart?(): boolean;
  // Gets called once after editing is complete. If your return true, then the new
  // value will not be used. The editing will have no impact on the record. Use this
  // if you do not want a new value from your gui, i.e. you want to cancel the editing. 
  isCancelAfterEnd?(): boolean;
  // If doing full line edit, then gets called when focus should be put into the editor 
  focusIn?(): void;
  // If doing full line edit, then gets called when focus is leaving the editor 
  focusOut?(): void;
  // If using a framework this returns the underlying component instance, so you can call
  // methods on it if you want. 
  getFrameworkComponentInstance?(): any;
}

function getSizesForCurrentTheme(): void;

function setAlwaysShowHorizontalScroll(show: boolean): void;

function setAlwaysShowVerticalScroll(show: boolean): void;

function ensureIndexVisible(
    index: any,
    position: string | null
): void;

function ensureNodeVisible(
    comparator: any,
    position: string | null = null
): void;

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

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

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

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 showLoadingOverlay(): void;

function showNoRowsOverlay(): void;

function hideOverlay(): void;

function copySelectedRangeToClipboard(includeHeader: boolean): void;

function copySelectedRangeDown(): void;

function copySelectedRowsToClipboard(
    includeHeader: boolean,
    columnKeys: (string | Column)[]
): 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 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 undoCellEditing(): void;

function redoCellEditing(): void;

function getCurrentUndoSize(): number;

function getCurrentRedoSize(): number;

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

interface CreateRangeChartParams {
  cellRange: CellRangeParams;
  chartType: ChartType;
  chartThemeName?: string;
  chartContainer?: HTMLElement;
  suppressChartRanges?: boolean;
  aggFunc?: string | IAggFunc;
  chartThemeOverrides?: AgChartThemeOverrides;
  unlinkChart?: boolean;
}

interface ChartRef {
  chartId: string;
  chart: any;
  chartElement: HTMLElement;
  destroyChart: () => void;
}

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

interface CreatePivotChartParams {
  chartType: ChartType;
  chartThemeName?: string;
  chartContainer?: HTMLElement;
  chartThemeOverrides?: AgChartThemeOverrides;
  unlinkChart?: boolean;
}

interface ChartRef {
  chartId: string;
  chart: any;
  chartElement: HTMLElement;
  destroyChart: () => void;
}

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

interface CreateRangeChartParams {
  cellRange: CellRangeParams;
  chartType: ChartType;
  chartThemeName?: string;
  chartContainer?: HTMLElement;
  suppressChartRanges?: boolean;
  aggFunc?: string | IAggFunc;
  chartThemeOverrides?: AgChartThemeOverrides;
  unlinkChart?: boolean;
}

interface ChartRef {
  chartId: string;
  chart: any;
  chartElement: HTMLElement;
  destroyChart: () => void;
}

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

interface ChartRef {
  chartId: string;
  chart: any;
  chartElement: HTMLElement;
  destroyChart: () => void;
}

function getChartModels(): ChartModel[] | undefined;

interface ChartModel {
  modelType: ChartModelType;
  chartId: string;
  chartType: ChartType;
  cellRange: CellRangeParams;
  chartThemeName?: string;
  chartOptions: ChartOptions<any>;
  suppressChartRanges?: boolean;
  aggFunc?: string | IAggFunc;
  unlinkChart?: boolean;
}

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

interface ChartModel {
  modelType: ChartModelType;
  chartId: string;
  chartType: ChartType;
  cellRange: CellRangeParams;
  chartThemeName?: string;
  chartOptions: ChartOptions<any>;
  suppressChartRanges?: boolean;
  aggFunc?: string | IAggFunc;
  unlinkChart?: boolean;
}

interface ChartRef {
  chartId: string;
  chart: any;
  chartElement: HTMLElement;
  destroyChart: () => void;
}

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

interface GetChartImageDataUrlParams {
  chartId: string;
  fileFormat?: string;
}

function setPopupParent(
    ePopupParent: HTMLElement
): void;

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

function isToolPanelShowing(): void;

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

interface IToolPanel {
  refresh(): void;
}

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

function destroy(): void;

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

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

function resetRowHeights(): void;

function onRowHeightChanged(): void;

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

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;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

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

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;
  api: GridApi;
  columnApi: ColumnApi;
  // The context as provided on `gridOptions.context` 
  context: any;
}

function clearAggFuncs(): void;

function hidePopupMenu(): void;

function setEnableCellTextSelection(selectable: boolean): void;

function isAnimationFrameQueueEmpty(): boolean;

function refreshServerSideStore(
    params: RefreshStoreParams
): void;

interface RefreshStoreParams {
  route?: string[];
  purge?: boolean;
}

function getServerSideStoreState(): ServerSideStoreState[];

interface ServerSideStoreState {
  type: ServerSideStoreType;
  route: string[];
  rowCount: number;
  lastRowIndexKnown?: boolean;
  info?: any;
  maxBlocksInCache?: number;
  cacheBlockSize?: number;
}

function retryServerSideLoads(): void;

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

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