ag-grid

ag-grid

Version 18.1.2
Published 6 years ago
12.6 MB
No dependencies
MIT license

Install

npm i ag-grid

yarn add ag-grid

pnpm add ag-grid

Overview

Advanced Data Grid / Data Table supporting Javascript / React / AngularJS / Web Components

Index

Functions

function Autowired

Autowired: (name?: string) => Function;

function Bean

Bean: (beanName: string) => Function;

function defaultGroupComparator

defaultGroupComparator: (
    valueA: any,
    valueB: any,
    nodeA: RowNode,
    nodeB: RowNode,
    accentedCompare?: boolean
) => number;

function initialiseAgGridWithAngular1

initialiseAgGridWithAngular1: (angular: any) => void;

function initialiseAgGridWithWebComponents

initialiseAgGridWithWebComponents: () => void;

function Listener

Listener: (eventName?: string) => Function;

function Optional

Optional: (name?: string) => Function;

function PostConstruct

PostConstruct: (
    target: Object,
    methodName: string,
    descriptor: TypedPropertyDescriptor<any>
) => void;

function PreConstruct

PreConstruct: (
    target: Object,
    methodName: string,
    descriptor: TypedPropertyDescriptor<any>
) => void;

function PreDestroy

PreDestroy: (
    target: Object,
    methodName: string,
    descriptor: TypedPropertyDescriptor<any>
) => void;

function Qualifier

Qualifier: (name: string) => Function;

function QuerySelector

QuerySelector: (selector?: string) => Function;

function RefSelector

RefSelector: (ref?: string) => Function;

function simpleHttpRequest

simpleHttpRequest: (params: SimpleHttpRequestParams) => Promise<any>;

Classes

class AgCheckbox

class AgCheckbox extends Component {}

constructor

constructor();

property EVENT_CHANGED

static EVENT_CHANGED: string;

method getNextValue

getNextValue: () => boolean;

method isReadOnly

isReadOnly: () => boolean;

method isSelected

isSelected: () => boolean;

method setPassive

setPassive: (passive: boolean) => void;

method setReadOnly

setReadOnly: (readOnly: boolean) => void;

method setSelected

setSelected: (selected: boolean) => void;

method toggle

toggle: () => void;

class AlignedGridsService

class AlignedGridsService {}

method getColumnIds

getColumnIds: (event: ColumnEvent) => string[];

method getMasterColumns

getMasterColumns: (event: ColumnEvent) => Column[];

method init

init: () => void;

method onColumnEvent

onColumnEvent: (event: AgEvent) => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

class AnimateShowChangeCellRenderer

class AnimateShowChangeCellRenderer extends Component implements ICellRenderer {}

constructor

constructor();

method init

init: (params: any) => void;

method refresh

refresh: (params: any) => boolean;

class AnimateSlideCellRenderer

class AnimateSlideCellRenderer extends Component implements ICellRenderer {}

constructor

constructor();

method addSlideAnimation

addSlideAnimation: () => void;

method init

init: (params: any) => void;

method refresh

refresh: (params: any) => boolean;

class AutoWidthCalculator

class AutoWidthCalculator {}

method getPreferredWidthForColumn

getPreferredWidthForColumn: (column: Column) => number;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method registerHeaderRootComp

registerHeaderRootComp: (headerRootComp: HeaderRootComp) => void;

class BalancedColumnTreeBuilder

class BalancedColumnTreeBuilder {}

method createBalancedColumnGroups

createBalancedColumnGroups: (
    abstractColDefs: (ColDef | ColGroupDef)[],
    primaryColumns: boolean
) => any;

method createForAutoGroups

createForAutoGroups: (
    autoGroupCols: Column[],
    gridBalancedTree: OriginalColumnGroupChild[]
) => OriginalColumnGroupChild[];

method mergeColDefs

mergeColDefs: (colDef: ColDef) => ColDef;

class BaseComponentWrapper

abstract class BaseComponentWrapper<F extends WrapableInterface>
    implements FrameworkComponentWrapper {}

method createWrapper

abstract createWrapper: (
    OriginalConstructor: { new (): any },
    componentName?: string
) => F;

method wrap

wrap: <A extends IComponent<any>>(
    OriginalConstructor: { new (): any },
    mandatoryMethodList: string[],
    optionalMethodList?: string[],
    componentName?: string
) => A;

class BaseCreator

abstract class BaseCreator<
    T,
    S extends GridSerializingSession<T>,
    P extends ExportParams<T>
> {}

method createSerializingSession

abstract createSerializingSession: (params?: P) => S;

method export

export: (userParams?: P) => string;

method getData

getData: (params: P) => string;

method getDefaultFileExtension

abstract getDefaultFileExtension: () => string;

method getDefaultFileName

abstract getDefaultFileName: () => string;

method getMimeType

abstract getMimeType: () => string;

method isExportSuppressed

abstract isExportSuppressed: () => boolean;

method setBeans

protected setBeans: (beans: BaseCreatorBeans) => void;

class BaseFilter

abstract class BaseFilter<T, P extends IFilterParams, M>
    extends Component
    implements IFilterComp {}

T(ype) The type of this filter. ie in DateFilter T=Date P(arams) The params that this filter can take M(model getModel/setModel) The object that this filter serializes to F Floating filter params
Contains common logic to ALL filters.. Translation, apply and clear button get/setModel context wiring....

property applyActive

applyActive: boolean;

property clearActive

clearActive: boolean;

property conditionValue

conditionValue: string;

property CONTAINS

static CONTAINS: string;

property context

context: Context;

property defaultFilter

defaultFilter: string;

property ENDS_WITH

static ENDS_WITH: string;

property EQUALS

static EQUALS: string;

property filter

filter: string;

property filterCondition

filterCondition: string;

property filterParams

filterParams: IFilterParams;

property GREATER_THAN

static GREATER_THAN: string;

property GREATER_THAN_OR_EQUAL

static GREATER_THAN_OR_EQUAL: string;

property gridOptionsWrapper

gridOptionsWrapper: GridOptionsWrapper;

property IN_RANGE

static IN_RANGE: string;

property LESS_THAN

static LESS_THAN: string;

property LESS_THAN_OR_EQUAL

static LESS_THAN_OR_EQUAL: string;

property NOT_CONTAINS

static NOT_CONTAINS: string;

property NOT_EQUAL

static NOT_EQUAL: string;

property STARTS_WITH

static STARTS_WITH: string;

method acceptsBooleanLogic

acceptsBooleanLogic: () => boolean;

method bodyTemplate

abstract bodyTemplate: (type: FilterConditionType) => string;

method customInit

abstract customInit: () => void;

method doesFilterPass

abstract doesFilterPass: (params: IDoesFilterPassParams) => boolean;

method floatingFilter

floatingFilter: (from: string) => void;

method generateFilterHeader

generateFilterHeader: (type: FilterConditionType) => string;

method getDebounceMs

getDebounceMs: (filterParams: ITextFilterParams | INumberFilterParams) => number;

method getModel

getModel: () => M | CombinedFilter<M>;

method getNullableModel

getNullableModel: () => M | CombinedFilter<M>;

method init

init: (params: P) => void;

method initialiseFilterBodyUi

abstract initialiseFilterBodyUi: (type: FilterConditionType) => void;

method isFilterActive

abstract isFilterActive: () => boolean;

method isFilterConditionActive

abstract isFilterConditionActive: (type: FilterConditionType) => boolean;

method modelFromFloatingFilter

abstract modelFromFloatingFilter: (from: string) => M;

method onClearButton

onClearButton: () => void;

method onFilterChanged

onFilterChanged: (applyNow?: boolean) => void;

method onFloatingFilterChanged

onFloatingFilterChanged: (change: FloatingFilterChange) => boolean;

method onNewRowsLoaded

onNewRowsLoaded: () => void;

method parse

abstract parse: (toParse: M, type: FilterConditionType) => void;

method refreshFilterBodyUi

abstract refreshFilterBodyUi: (type: FilterConditionType) => void;

method resetState

abstract resetState: () => void;

method serialize

abstract serialize: (type: FilterConditionType) => M;

method setModel

setModel: (model: M | CombinedFilter<M>) => void;

method translate

translate: (toTranslate: string) => string;

method wrapCondition

wrapCondition: (mainCondition: string) => string;

class BaseFrameworkFactory

class BaseFrameworkFactory implements IFrameworkFactory {}

The base frameworks, eg React & Angular 2, override this bean with implementations specific to their requirement.

method colDefCellEditor

colDefCellEditor: (colDef: ColDef) => { new (): ICellEditorComp } | string;

method colDefCellRenderer

colDefCellRenderer: (
    colDef: ColDef
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method colDefFilter

colDefFilter: (colDef: ColDef) => { new (): IFilterComp } | string;

method colDefFloatingCellRenderer

colDefFloatingCellRenderer: (
    colDef: ColDef
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method dateComponent

dateComponent: (gridOptions: GridOptions) => { new (): IDateComp };

method gridOptionsFullWidthCellRenderer

gridOptionsFullWidthCellRenderer: (
    gridOptions: GridOptions
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method gridOptionsGroupRowInnerRenderer

gridOptionsGroupRowInnerRenderer: (
    gridOptions: GridOptions
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method gridOptionsGroupRowRenderer

gridOptionsGroupRowRenderer: (
    gridOptions: GridOptions
) => { new (): ICellRendererComp } | ICellRendererFunc | string;

method setTimeout

setTimeout: (action: any, timeout?: any) => void;

class BaseGridSerializingSession

abstract class BaseGridSerializingSession<T> implements GridSerializingSession<T> {}

constructor

constructor(
    columnController: ColumnController,
    valueService: ValueService,
    gridOptionsWrapper: GridOptionsWrapper,
    processCellCallback?: (params: ProcessCellForExportParams) => string,
    processHeaderCallback?: (params: ProcessHeaderForExportParams) => string,
    cellAndHeaderEscaper?: (rawValue: string) => string
);

property cellAndHeaderEscaper

cellAndHeaderEscaper: (rawValue: string) => string;

property columnController

columnController: ColumnController;

property gridOptionsWrapper

gridOptionsWrapper: GridOptionsWrapper;

property processCellCallback

processCellCallback: (params: ProcessCellForExportParams) => string;

property processHeaderCallback

processHeaderCallback: (params: ProcessHeaderForExportParams) => string;

property valueService

valueService: ValueService;

method addCustomFooter

abstract addCustomFooter: (customFooter: T) => void;

method addCustomHeader

abstract addCustomHeader: (customHeader: T) => void;

method extractHeaderValue

extractHeaderValue: (column: Column) => string;

method extractRowCellValue

extractRowCellValue: (
    column: Column,
    index: number,
    type: string,
    node?: RowNode
) => any;

method onNewBodyRow

abstract onNewBodyRow: () => RowAccumulator;

method onNewHeaderGroupingRow

abstract onNewHeaderGroupingRow: () => RowSpanningAccumulator;

method onNewHeaderRow

abstract onNewHeaderRow: () => RowAccumulator;

method parse

abstract parse: () => string;

method prepare

abstract prepare: (columnsToExport: Column[]) => void;

class BeanStub

class BeanStub implements IEventEmitter {}

property EVENT_DESTROYED

static EVENT_DESTROYED: string;

method addDestroyableEventListener

addDestroyableEventListener: (
    eElement: Window | HTMLElement | IEventEmitter | GridOptionsWrapper,
    event: string,
    listener: (event?: any) => void
) => void;

method addDestroyFunc

addDestroyFunc: (func: () => void) => void;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method destroy

destroy: () => void;

method dispatchEvent

dispatchEvent: <T extends AgEvent>(event: T) => void;

method dispatchEventAsync

dispatchEventAsync: (event: AgEvent) => void;

method isAlive

isAlive: () => boolean;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

class BodyDropPivotTarget

class BodyDropPivotTarget implements DropListener {}

constructor

constructor(pinned: string);

method getIconName

getIconName: () => string;

method onDragEnter

onDragEnter: (draggingEvent: DraggingEvent) => void;

Callback for when drag enters

method onDragging

onDragging: (draggingEvent: DraggingEvent) => void;

Callback for when dragging

method onDragLeave

onDragLeave: (draggingEvent: DraggingEvent) => void;

Callback for when drag leaves

method onDragStop

onDragStop: (draggingEvent: DraggingEvent) => void;

Callback for when drag stops

class BodyDropTarget

class BodyDropTarget implements DropTarget {}

constructor

constructor(pinned: string, eContainer: HTMLElement);

method getContainer

getContainer: () => HTMLElement;

method getIconName

getIconName: () => string;

method getSecondaryContainers

getSecondaryContainers: () => HTMLElement[];

method isInterestedIn

isInterestedIn: (type: DragSourceType) => boolean;

method onDragEnter

onDragEnter: (draggingEvent: DraggingEvent) => void;

method onDragging

onDragging: (params: DraggingEvent) => void;

method onDragLeave

onDragLeave: (params: DraggingEvent) => void;

method onDragStop

onDragStop: (params: DraggingEvent) => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

class CellComp

class CellComp extends Component {}

constructor

constructor(
    scope: any,
    beans: Beans,
    column: Column,
    rowNode: RowNode,
    rowComp: RowComp,
    autoHeightCell: boolean
);

property DOM_DATA_KEY_CELL_COMP

static DOM_DATA_KEY_CELL_COMP: string;

method afterAttached

afterAttached: () => void;

method attemptCellRendererRefresh

attemptCellRendererRefresh: () => boolean;

method destroy

destroy: () => void;

method detach

detach: () => void;

method dispatchCellContextMenuEvent

dispatchCellContextMenuEvent: (event: Event) => void;

method doesUserWantToCancelKeyboardEvent

doesUserWantToCancelKeyboardEvent: (event: KeyboardEvent) => boolean;

method flashCell

flashCell: () => void;

method focusCell

focusCell: (forceBrowserFocus?: boolean) => void;

method getCellEditor

getCellEditor: () => ICellEditorComp;

method getCellRenderer

getCellRenderer: () => ICellRendererComp;

method getColumn

getColumn: () => Column;

method getCreateTemplate

getCreateTemplate: () => string;

method getGridCell

getGridCell: () => GridCell;

method getInitialValueToRender

getInitialValueToRender: () => string;

method getParentRow

getParentRow: () => HTMLElement;

method getRenderedRow

getRenderedRow: () => RowComp;

method isCellEditable

isCellEditable: () => boolean;

method isEditing

isEditing: () => boolean;

method isSuppressNavigable

isSuppressNavigable: () => boolean;

method onKeyDown

onKeyDown: (event: KeyboardEvent) => void;

method onKeyPress

onKeyPress: (event: KeyboardEvent) => void;

method onMouseEvent

onMouseEvent: (eventName: string, mouseEvent: MouseEvent) => void;

method refreshCell

refreshCell: (params?: {
    suppressFlash?: boolean;
    newData?: boolean;
    forceRefresh?: boolean;
}) => void;

method setFocusInOnEditor

setFocusInOnEditor: () => void;

method setFocusOutOnEditor

setFocusOutOnEditor: () => void;

method setParentRow

setParentRow: (eParentRow: HTMLElement) => void;

method setUsingWrapper

setUsingWrapper: () => void;

method startEditingIfEnabled

startEditingIfEnabled: (
    keyPress?: number,
    charPress?: string,
    cellStartedEdit?: boolean
) => void;

method startRowOrCellEdit

startRowOrCellEdit: (keyPress?: number, charPress?: string) => void;

method stopEditing

stopEditing: (cancel?: boolean) => void;

method stopRowOrCellEdit

stopRowOrCellEdit: (cancel?: boolean) => void;

class CellEditorFactory

class CellEditorFactory {}

method addCellEditor

addCellEditor: (key: string, cellEditor: { new (): ICellEditorComp }) => void;

method createCellEditor

createCellEditor: (
    column: ColDef,
    params: ICellEditorParams
) => Promise<ICellEditorComp>;

class CellNavigationService

class CellNavigationService {}

method getNextCellToFocus

getNextCellToFocus: (key: any, lastCellToFocus: GridCell) => GridCell;

method getNextTabbedCell

getNextTabbedCell: (gridCell: GridCell, backwards: boolean) => GridCell;

method getNextTabbedCellBackwards

getNextTabbedCellBackwards: (gridCell: GridCell) => GridCell;

method getNextTabbedCellForwards

getNextTabbedCellForwards: (gridCell: GridCell) => GridCell;

method getRowBelow

getRowBelow: (lastRow: GridRow) => GridRow;

class CellRendererFactory

class CellRendererFactory {}

property ANIMATE_SHOW_CHANGE

static ANIMATE_SHOW_CHANGE: string;

property ANIMATE_SLIDE

static ANIMATE_SLIDE: string;

property GROUP

static GROUP: string;

method addCellRenderer

addCellRenderer: (
    key: string,
    cellRenderer: { new (): ICellRenderer } | ICellRendererFunc
) => void;

method getCellRenderer

getCellRenderer: (key: string) => { new (): ICellRenderer } | ICellRendererFunc;

class CellRendererService

class CellRendererService {}

Class to use a cellRenderer.

method bindToHtml

bindToHtml: (
    cellRendererPromise: Promise<ICellRendererComp>,
    eTarget: HTMLElement
) => Promise<ICellRendererComp>;

method useCellRenderer

useCellRenderer: (
    target: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useFilterCellRenderer

useFilterCellRenderer: (
    target: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useFullWidthGroupRowInnerCellRenderer

useFullWidthGroupRowInnerCellRenderer: (
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useInnerCellRenderer

useInnerCellRenderer: (
    target: GroupCellRendererParams,
    originalColumn: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

method useRichSelectCellRenderer

useRichSelectCellRenderer: (
    target: ColDef,
    eTarget: HTMLElement,
    params: any
) => Promise<ICellRendererComp>;

class ChangedPath

class ChangedPath {}

constructor

constructor(keepingColumns: boolean);

method addParentNode

addParentNode: (rowNode: RowNode, columns?: Column[]) => void;

method getNotValueColumnsForNode

getNotValueColumnsForNode: (
    rowNode: RowNode,
    valueColumns: Column[]
) => Column[];

method getValueColumnsForNode

getValueColumnsForNode: (rowNode: RowNode, valueColumns: Column[]) => Column[];

method isActive

isActive: () => boolean;

method isInPath

isInPath: (rowNode: RowNode) => boolean;

method setInactive

setInactive: () => void;

class CheckboxSelectionComponent

class CheckboxSelectionComponent extends Component {}

constructor

constructor();

method init

init: (params: any) => void;

class ClientSideNodeManager

class ClientSideNodeManager {}

constructor

constructor(
    rootNode: RowNode,
    gridOptionsWrapper: GridOptionsWrapper,
    context: Context,
    eventService: EventService,
    columnController: ColumnController,
    gridApi: GridApi,
    columnApi: ColumnApi,
    selectionController: SelectionController
);

method addItems

addItems: (items: any) => RowNode[];

method getCopyOfNodesMap

getCopyOfNodesMap: () => { [id: string]: RowNode };

method getRowNode

getRowNode: (id: string) => RowNode;

method insertItemsAtIndex

insertItemsAtIndex: (index: number, rowData: any[]) => RowNode[];

method isLegacyTreeData

isLegacyTreeData: () => boolean;

method postConstruct

postConstruct: () => void;

method setRowData

setRowData: (rowData: any[]) => RowNode[];

method updateRowData

updateRowData: (
    rowDataTran: RowDataTransaction,
    rowNodeOrder: { [id: string]: number }
) => RowNodeTransaction;

class ClientSideRowModel

class ClientSideRowModel {}

method batchUpdateRowData

batchUpdateRowData: (
    rowDataTransaction: RowDataTransaction,
    callback?: (res: RowNodeTransaction) => void
) => void;

method doAggregate

doAggregate: (changedPath?: ChangedPath) => void;

method ensureRowAtPixel

ensureRowAtPixel: (rowNode: RowNode, pixel: number) => boolean;

method expandOrCollapseAll

expandOrCollapseAll: (expand: boolean) => void;

method forEachLeafNode

forEachLeafNode: (callback: Function) => void;

method forEachNode

forEachNode: (callback: Function) => void;

method forEachNodeAfterFilter

forEachNodeAfterFilter: (callback: Function) => void;

method forEachNodeAfterFilterAndSort

forEachNodeAfterFilterAndSort: (callback: Function) => void;

method forEachPivotNode

forEachPivotNode: (callback: Function) => void;

method getCopyOfNodesMap

getCopyOfNodesMap: () => { [id: string]: RowNode };

method getCurrentPageHeight

getCurrentPageHeight: () => number;

method getNodesInRangeForSelection

getNodesInRangeForSelection: (
    firstInRange: RowNode,
    lastInRange: RowNode
) => RowNode[];

method getPageFirstRow

getPageFirstRow: () => number;

method getPageLastRow

getPageLastRow: () => number;

method getRootNode

getRootNode: () => RowNode;

method getRow

getRow: (index: number) => RowNode;

method getRowBounds

getRowBounds: (index: number) => RowBounds;

method getRowCount

getRowCount: () => number;

method getRowIndexAtPixel

getRowIndexAtPixel: (pixelToMatch: number) => number;

method getRowNode

getRowNode: (id: string) => RowNode;

method getTopLevelNodes

getTopLevelNodes: () => RowNode[];

method getType

getType: () => string;

method getVirtualRowCount

getVirtualRowCount: () => number;

method init

init: () => void;

method isEmpty

isEmpty: () => boolean;

method isLastRowFound

isLastRowFound: () => boolean;

method isRowPresent

isRowPresent: (rowNode: RowNode) => boolean;

method isRowsToRender

isRowsToRender: () => boolean;

method onRowHeightChanged

onRowHeightChanged: () => void;

method refreshModel

refreshModel: (params: RefreshModelParams) => void;

method resetRowHeights

resetRowHeights: () => void;

method setDatasource

setDatasource: (datasource: any) => void;

method setRowData

setRowData: (rowData: any[]) => void;

method updateRowData

updateRowData: (
    rowDataTran: RowDataTransaction,
    rowNodeOrder?: { [id: string]: number }
) => RowNodeTransaction;

class ColDefUtil

class ColDefUtil {}

property ALL_PROPERTIES

static ALL_PROPERTIES: string[];

property ARRAY_PROPERTIES

static ARRAY_PROPERTIES: string[];

property BOOLEAN_PROPERTIES

static BOOLEAN_PROPERTIES: string[];

property FRAMEWORK_PROPERTIES

static FRAMEWORK_PROPERTIES: string[];

property FUNCTION_PROPERTIES

static FUNCTION_PROPERTIES: string[];

property NUMBER_PROPERTIES

static NUMBER_PROPERTIES: string[];

property OBJECT_PROPERTIES

static OBJECT_PROPERTIES: string[];

property STRING_PROPERTIES

static STRING_PROPERTIES: string[];

class Column

class Column implements ColumnGroupChild, OriginalColumnGroupChild, IEventEmitter {}

constructor

constructor(colDef: ColDef, colId: string, primary: boolean);

property EVENT_FILTER_ACTIVE_CHANGED

static EVENT_FILTER_ACTIVE_CHANGED: string;

property EVENT_FILTER_CHANGED

static EVENT_FILTER_CHANGED: string;

property EVENT_FIRST_RIGHT_PINNED_CHANGED

static EVENT_FIRST_RIGHT_PINNED_CHANGED: string;

property EVENT_LAST_LEFT_PINNED_CHANGED

static EVENT_LAST_LEFT_PINNED_CHANGED: string;

property EVENT_LEFT_CHANGED

static EVENT_LEFT_CHANGED: string;

property EVENT_MENU_VISIBLE_CHANGED

static EVENT_MENU_VISIBLE_CHANGED: string;

property EVENT_MOVING_CHANGED

static EVENT_MOVING_CHANGED: string;

property EVENT_PIVOT_CHANGED

static EVENT_PIVOT_CHANGED: string;

property EVENT_ROW_GROUP_CHANGED

static EVENT_ROW_GROUP_CHANGED: string;

property EVENT_SORT_CHANGED

static EVENT_SORT_CHANGED: string;

property EVENT_VALUE_CHANGED

static EVENT_VALUE_CHANGED: string;

property EVENT_VISIBLE_CHANGED

static EVENT_VISIBLE_CHANGED: string;

property EVENT_WIDTH_CHANGED

static EVENT_WIDTH_CHANGED: string;

property PINNED_LEFT

static PINNED_LEFT: string;

property PINNED_RIGHT

static PINNED_RIGHT: string;

property SORT_ASC

static SORT_ASC: string;

property SORT_DESC

static SORT_DESC: string;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method getActualWidth

getActualWidth: () => number;

method getAggFunc

getAggFunc: () => string | IAggFunc;

method getColDef

getColDef: () => ColDef;

method getColId

getColId: () => string;

method getColSpan

getColSpan: (rowNode: RowNode) => number;

method getColumnGroupShow

getColumnGroupShow: () => string;

method getDefinition

getDefinition: () => AbstractColDef;

method getId

getId: () => string;

method getLeft

getLeft: () => number;

method getMaxWidth

getMaxWidth: () => number;

method getMenuTabs

getMenuTabs: (defaultValues: string[]) => string[];

method getMinWidth

getMinWidth: () => number;

method getOldLeft

getOldLeft: () => number;

method getParent

getParent: () => ColumnGroup;

method getPinned

getPinned: () => string;

method getRight

getRight: () => number;

method getRowSpan

getRowSpan: (rowNode: RowNode) => number;

method getSort

getSort: () => string;

method getSortedAt

getSortedAt: () => number;

method getUniqueId

getUniqueId: () => string;

method initialise

initialise: () => void;

method isAllowPivot

isAllowPivot: () => boolean;

method isAllowRowGroup

isAllowRowGroup: () => boolean;

method isAllowValue

isAllowValue: () => boolean;

method isAnyFunctionActive

isAnyFunctionActive: () => boolean;

method isAnyFunctionAllowed

isAnyFunctionAllowed: () => boolean;

method isCellCheckboxSelection

isCellCheckboxSelection: (rowNode: RowNode) => boolean;

method isCellEditable

isCellEditable: (rowNode: RowNode) => boolean;

method isEmptyGroup

isEmptyGroup: () => boolean;

method isFieldContainsDots

isFieldContainsDots: () => boolean;

method isFilterActive

isFilterActive: () => boolean;

method isFilterAllowed

isFilterAllowed: () => boolean;

method isFirstRightPinned

isFirstRightPinned: () => boolean;

method isGreaterThanMax

isGreaterThanMax: (width: number) => boolean;

method isLastLeftPinned

isLastLeftPinned: () => boolean;

method isLockPinned

isLockPinned: () => boolean;

method isLockPosition

isLockPosition: () => boolean;

method isLockVisible

isLockVisible: () => boolean;

method isMenuVisible

isMenuVisible: () => boolean;

method isMoving

isMoving: () => boolean;

method isPinned

isPinned: () => boolean;

method isPinnedLeft

isPinnedLeft: () => boolean;

method isPinnedRight

isPinnedRight: () => boolean;

method isPivotActive

isPivotActive: () => boolean;

method isPrimary

isPrimary: () => boolean;

method isResizable

isResizable: () => boolean;

method isRowDrag

isRowDrag: (rowNode: RowNode) => boolean;

method isRowGroupActive

isRowGroupActive: () => boolean;

method isRowGroupDisplayed

isRowGroupDisplayed: (colId: string) => boolean;

method isSortAscending

isSortAscending: () => boolean;

method isSortDescending

isSortDescending: () => boolean;

method isSorting

isSorting: () => boolean;

method isSortNone

isSortNone: () => boolean;

method isSuppressNavigable

isSuppressNavigable: (rowNode: RowNode) => boolean;

method isSuppressPaste

isSuppressPaste: (rowNode: RowNode) => boolean;

method isTooltipFieldContainsDots

isTooltipFieldContainsDots: () => boolean;

method isValueActive

isValueActive: () => boolean;

method isVisible

isVisible: () => boolean;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

method setActualWidth

setActualWidth: (actualWidth: number, source?: ColumnEventType) => void;

method setAggFunc

setAggFunc: (aggFunc: string | IAggFunc) => void;

method setFilterActive

setFilterActive: (active: boolean, source?: ColumnEventType) => void;

method setFirstRightPinned

setFirstRightPinned: (
    firstRightPinned: boolean,
    source?: ColumnEventType
) => void;

method setLastLeftPinned

setLastLeftPinned: (lastLeftPinned: boolean, source?: ColumnEventType) => void;

method setLeft

setLeft: (left: number, source?: ColumnEventType) => void;

method setMenuVisible

setMenuVisible: (visible: boolean, source?: ColumnEventType) => void;

method setMinimum

setMinimum: (source?: ColumnEventType) => void;

method setMoving

setMoving: (moving: boolean, source?: ColumnEventType) => void;

method setParent

setParent: (parent: ColumnGroup) => void;

method setPinned

setPinned: (pinned: string | boolean) => void;

method setPivotActive

setPivotActive: (pivot: boolean, source?: ColumnEventType) => void;

method setRowGroupActive

setRowGroupActive: (rowGroup: boolean, source?: ColumnEventType) => void;

method setSort

setSort: (sort: string, source?: ColumnEventType) => void;

method setSortedAt

setSortedAt: (sortedAt: number) => void;

method setValueActive

setValueActive: (value: boolean, source?: ColumnEventType) => void;

method setVisible

setVisible: (visible: boolean, source?: ColumnEventType) => void;

class ColumnApi

class ColumnApi {}

method addAggregationColumn

addAggregationColumn: (colKey: string | Column) => void;

method addAggregationColumns

addAggregationColumns: (colKeys: (string | Column)[]) => void;

method addPivotColumn

addPivotColumn: (colKey: string | Column) => void;

method addPivotColumns

addPivotColumns: (colKeys: (string | Column)[]) => void;

method addRowGroupColumn

addRowGroupColumn: (colKey: string | Column) => void;

method addRowGroupColumns

addRowGroupColumns: (colKeys: (string | Column)[]) => void;

method addValueColumn

addValueColumn: (colKey: string | Column) => void;

method addValueColumns

addValueColumns: (colKeys: (string | Column)[]) => void;

method autoSizeAllColumns

autoSizeAllColumns: () => void;

method autoSizeColumn

autoSizeColumn: (key: string | Column) => void;

method autoSizeColumns

autoSizeColumns: (keys: (string | Column)[]) => void;

method columnGroupOpened

columnGroupOpened: (
    group: OriginalColumnGroup | string,
    newValue: boolean
) => void;

method getAggregationColumns

getAggregationColumns: () => Column[];

method getAllColumns

getAllColumns: () => Column[];

method getAllDisplayedColumnGroups

getAllDisplayedColumnGroups: () => ColumnGroupChild[];

method getAllDisplayedColumns

getAllDisplayedColumns: () => Column[];

method getAllDisplayedVirtualColumns

getAllDisplayedVirtualColumns: () => Column[];

method getAllGridColumns

getAllGridColumns: () => Column[];

method getCenterDisplayedColumnGroups

getCenterDisplayedColumnGroups: () => ColumnGroupChild[];

method getColumn

getColumn: (key: any) => Column;

method getColumnGroup

getColumnGroup: (name: string, instanceId?: number) => ColumnGroup;

method getColumnGroupState

getColumnGroupState: () => { groupId: string; open: boolean }[];

method getColumnState

getColumnState: () => ColumnState[];

method getDisplayedCenterColumns

getDisplayedCenterColumns: () => Column[];

method getDisplayedColAfter

getDisplayedColAfter: (col: Column) => Column;

method getDisplayedColBefore

getDisplayedColBefore: (col: Column) => Column;

method getDisplayedLeftColumns

getDisplayedLeftColumns: () => Column[];

method getDisplayedRightColumns

getDisplayedRightColumns: () => Column[];

method getDisplayNameForCol

getDisplayNameForCol: (column: any) => string;

method getDisplayNameForColumn

getDisplayNameForColumn: (column: Column, location: string) => string;

method getDisplayNameForColumnGroup

getDisplayNameForColumnGroup: (
    columnGroup: ColumnGroup,
    location: string
) => string;

method getLeftDisplayedColumnGroups

getLeftDisplayedColumnGroups: () => ColumnGroupChild[];

method getOriginalColumnGroup

getOriginalColumnGroup: (name: string) => OriginalColumnGroup;

method getPivotColumns

getPivotColumns: () => Column[];

method getRightDisplayedColumnGroups

getRightDisplayedColumnGroups: () => ColumnGroupChild[];

method getRowGroupColumns

getRowGroupColumns: () => Column[];

method getSecondaryPivotColumn

getSecondaryPivotColumn: (
    pivotKeys: string[],
    valueColKey: string | Column
) => Column;

method getState

getState: () => ColumnState[];

method getValueColumns

getValueColumns: () => Column[];

method hideColumn

hideColumn: (colId: any, hide: any) => void;

method hideColumns

hideColumns: (colIds: any, hide: any) => void;

method isPinning

isPinning: () => boolean;

method isPinningLeft

isPinningLeft: () => boolean;

method isPinningRight

isPinningRight: () => boolean;

method isPivotMode

isPivotMode: () => boolean;

method moveColumn

moveColumn: (key: string | Column, toIndex: number) => void;

method moveColumnByIndex

moveColumnByIndex: (fromIndex: number, toIndex: number) => void;

method moveColumns

moveColumns: (columnsToMoveKeys: (string | Column)[], toIndex: number) => void;

method moveRowGroupColumn

moveRowGroupColumn: (fromIndex: number, toIndex: number) => void;

method removeAggregationColumn

removeAggregationColumn: (colKey: string | Column) => void;

method removeAggregationColumns

removeAggregationColumns: (colKeys: (string | Column)[]) => void;

method removePivotColumn

removePivotColumn: (colKey: string | Column) => void;

method removePivotColumns

removePivotColumns: (colKeys: (string | Column)[]) => void;

method removeRowGroupColumn

removeRowGroupColumn: (colKey: string | Column) => void;

method removeRowGroupColumns

removeRowGroupColumns: (colKeys: (string | Column)[]) => void;

method removeValueColumn

removeValueColumn: (colKey: string | Column) => void;

method removeValueColumns

removeValueColumns: (colKeys: (string | Column)[]) => void;

method resetColumnGroupState

resetColumnGroupState: () => void;

method resetColumnState

resetColumnState: () => void;

method resetState

resetState: () => void;

method setColumnAggFunc

setColumnAggFunc: (column: Column, aggFunc: string) => void;

method setColumnAggFunction

setColumnAggFunction: (column: Column, aggFunc: string) => void;

method setColumnGroupOpened

setColumnGroupOpened: (
    group: OriginalColumnGroup | string,
    newValue: boolean
) => void;

method setColumnGroupState

setColumnGroupState: (stateItems: { groupId: string; open: boolean }[]) => void;

method setColumnPinned

setColumnPinned: (key: string | Column, pinned: string) => void;

method setColumnsPinned

setColumnsPinned: (keys: (string | Column)[], pinned: string) => void;

method setColumnState

setColumnState: (columnState: ColumnState[]) => boolean;

method setColumnsVisible

setColumnsVisible: (keys: (string | Column)[], visible: boolean) => void;

method setColumnVisible

setColumnVisible: (key: string | Column, visible: boolean) => void;

method setColumnWidth

setColumnWidth: (
    key: string | Column,
    newWidth: number,
    finished?: boolean
) => void;

method setPivotColumns

setPivotColumns: (colKeys: (string | Column)[]) => void;

method setPivotMode

setPivotMode: (pivotMode: boolean) => void;

method setRowGroupColumns

setRowGroupColumns: (colKeys: (string | Column)[]) => void;

method setSecondaryColumns

setSecondaryColumns: (colDefs: (ColDef | ColGroupDef)[]) => void;

method setState

setState: (columnState: ColumnState[]) => boolean;

method setValueColumns

setValueColumns: (colKeys: (string | Column)[]) => void;

method sizeColumnsToFit

sizeColumnsToFit: (gridWidth: any) => void;

class ColumnController

class ColumnController {}

method addPivotColumn

addPivotColumn: (key: string | Column, source?: ColumnEventType) => void;

method addPivotColumns

addPivotColumns: (keys: (string | Column)[], source?: ColumnEventType) => void;

method addRowGroupColumn

addRowGroupColumn: (key: string | Column, source?: ColumnEventType) => void;

method addRowGroupColumns

addRowGroupColumns: (
    keys: (string | Column)[],
    source?: ColumnEventType
) => void;

method addValueColumn

addValueColumn: (colKey: string | Column, source?: ColumnEventType) => void;

method addValueColumns

addValueColumns: (keys: (string | Column)[], source?: ColumnEventType) => void;

method autoSizeAllColumns

autoSizeAllColumns: (source?: ColumnEventType) => void;

method autoSizeColumn

autoSizeColumn: (key: string | Column, source?: ColumnEventType) => void;

method autoSizeColumns

autoSizeColumns: (keys: (string | Column)[], source?: ColumnEventType) => void;

method doesMovePassLockedPositions

doesMovePassLockedPositions: (proposedColumnOrder: Column[]) => boolean;

method doesMovePassMarryChildren

doesMovePassMarryChildren: (allColumnsCopy: Column[]) => boolean;

method doesMovePassRules

doesMovePassRules: (columnsToMove: Column[], toIndex: number) => boolean;

method getAllAutoRowHeightCols

getAllAutoRowHeightCols: () => Column[];

method getAllColumnsForQuickFilter

getAllColumnsForQuickFilter: () => Column[];

method getAllDisplayedCenterVirtualColumnsForRow

getAllDisplayedCenterVirtualColumnsForRow: (rowNode: RowNode) => Column[];

method getAllDisplayedColumnGroups

getAllDisplayedColumnGroups: () => ColumnGroupChild[];

method getAllDisplayedColumns

getAllDisplayedColumns: () => Column[];

method getAllDisplayedVirtualColumns

getAllDisplayedVirtualColumns: () => Column[];

method getAllGridColumns

getAllGridColumns: () => Column[];

method getAllPrimaryColumns

getAllPrimaryColumns: () => Column[];

method getBodyContainerWidth

getBodyContainerWidth: () => number;

method getCenterDisplayedColumnGroups

getCenterDisplayedColumnGroups: () => ColumnGroupChild[];

method getColumnGroup

getColumnGroup: (
    colId: string | ColumnGroup,
    instanceId?: number
) => ColumnGroup;

method getColumnGroupState

getColumnGroupState: () => { groupId: string; open: boolean }[];

method getColumnState

getColumnState: () => ColumnState[];

method getColumnWithValidation

getColumnWithValidation: (key: string | Column) => Column;

method getContainerWidth

getContainerWidth: (pinned: string) => number;

method getDisplayedCenterColumns

getDisplayedCenterColumns: () => Column[];

method getDisplayedColAfter

getDisplayedColAfter: (col: Column) => Column;

method getDisplayedColBefore

getDisplayedColBefore: (col: Column) => Column;

method getDisplayedColumnGroups

getDisplayedColumnGroups: (type: string) => ColumnGroupChild[];

method getDisplayedColumns

getDisplayedColumns: (type: string) => Column[];

method getDisplayedColumnsStartingAt

getDisplayedColumnsStartingAt: (column: Column) => Column[];

method getDisplayedGroupAfter

getDisplayedGroupAfter: (columnGroup: ColumnGroup) => ColumnGroup;

method getDisplayedLeftColumns

getDisplayedLeftColumns: () => Column[];

method getDisplayedLeftColumnsForRow

getDisplayedLeftColumnsForRow: (rowNode: RowNode) => Column[];

method getDisplayedRightColumns

getDisplayedRightColumns: () => Column[];

method getDisplayedRightColumnsForRow

getDisplayedRightColumnsForRow: (rowNode: RowNode) => Column[];

method getDisplayNameForColumn

getDisplayNameForColumn: (
    column: Column,
    location: string,
    includeAggFunc?: boolean
) => string;

method getDisplayNameForColumnGroup

getDisplayNameForColumnGroup: (
    columnGroup: ColumnGroup,
    location: string
) => string;

method getDisplayNameForOriginalColumnGroup

getDisplayNameForOriginalColumnGroup: (
    columnGroup: ColumnGroup,
    originalColumnGroup: OriginalColumnGroup,
    location: string
) => string;

method getGridBalancedTree

getGridBalancedTree: () => OriginalColumnGroupChild[];

method getGridColumn

getGridColumn: (key: string | Column) => Column;

method getGridColumns

getGridColumns: (keys: (string | Column)[]) => Column[];

method getGroupAutoColumns

getGroupAutoColumns: () => Column[];

method getGroupDisplayColumns

getGroupDisplayColumns: () => Column[];

method getHeaderRowCount

getHeaderRowCount: () => number;

method getLeftDisplayedColumnGroups

getLeftDisplayedColumnGroups: () => ColumnGroupChild[];

method getOriginalColumnGroup

getOriginalColumnGroup: (
    key: OriginalColumnGroup | string
) => OriginalColumnGroup;

method getPinnedLeftContainerWidth

getPinnedLeftContainerWidth: () => number;

method getPinnedRightContainerWidth

getPinnedRightContainerWidth: () => number;

method getPivotColumns

getPivotColumns: () => Column[];

method getPrimaryAndSecondaryAndAutoColumns

getPrimaryAndSecondaryAndAutoColumns: () => Column[];

method getPrimaryColumn

getPrimaryColumn: (key: string | Column) => Column;

method getPrimaryColumnTree

getPrimaryColumnTree: () => OriginalColumnGroupChild[];

method getRightDisplayedColumnGroups

getRightDisplayedColumnGroups: () => ColumnGroupChild[];

method getRowGroupColumns

getRowGroupColumns: () => Column[];

method getSecondaryPivotColumn

getSecondaryPivotColumn: (
    pivotKeys: string[],
    valueColKey: Column | string
) => Column;

method getValueColumns

getValueColumns: () => Column[];

method getVirtualHeaderGroupRow

getVirtualHeaderGroupRow: (type: string, dept: number) => ColumnGroupChild[];

method init

init: () => void;

method isAutoRowHeightActive

isAutoRowHeightActive: () => boolean;

method isColumnDisplayed

isColumnDisplayed: (column: Column) => boolean;

method isEmpty

isEmpty: () => boolean;

method isPinningLeft

isPinningLeft: () => boolean;

method isPinningRight

isPinningRight: () => boolean;

method isPivotActive

isPivotActive: () => boolean;

method isPivotMode

isPivotMode: () => boolean;

method isPrimaryColumnGroupsPresent

isPrimaryColumnGroupsPresent: () => boolean;

method isReady

isReady: () => boolean;

method isRowGroupEmpty

isRowGroupEmpty: () => boolean;

method isSecondaryColumnsPresent

isSecondaryColumnsPresent: () => boolean;

method moveColumn

moveColumn: (
    key: string | Column,
    toIndex: number,
    source?: ColumnEventType
) => void;

method moveColumnByIndex

moveColumnByIndex: (
    fromIndex: number,
    toIndex: number,
    source?: ColumnEventType
) => void;

method moveColumns

moveColumns: (
    columnsToMoveKeys: (string | Column)[],
    toIndex: number,
    source?: ColumnEventType
) => void;

method moveRowGroupColumn

moveRowGroupColumn: (
    fromIndex: number,
    toIndex: number,
    source?: ColumnEventType
) => void;

method removePivotColumn

removePivotColumn: (key: string | Column, source?: ColumnEventType) => void;

method removePivotColumns

removePivotColumns: (
    keys: (string | Column)[],
    source?: ColumnEventType
) => void;

method removeRowGroupColumn

removeRowGroupColumn: (key: string | Column, source?: ColumnEventType) => void;

method removeRowGroupColumns

removeRowGroupColumns: (
    keys: (string | Column)[],
    source?: ColumnEventType
) => void;

method removeValueColumn

removeValueColumn: (colKey: string | Column, source?: ColumnEventType) => void;

method removeValueColumns

removeValueColumns: (
    keys: (string | Column)[],
    source?: ColumnEventType
) => void;

method resetColumnGroupState

resetColumnGroupState: (source?: ColumnEventType) => void;

method resetColumnState

resetColumnState: (source?: ColumnEventType) => void;

method resizeColumnSets

resizeColumnSets: (
    resizeSets: ColumnResizeSet[],
    finished: boolean,
    source: ColumnEventType
) => void;

method setColumnAggFunc

setColumnAggFunc: (
    column: Column,
    aggFunc: string,
    source?: ColumnEventType
) => void;

method setColumnDefs

setColumnDefs: (
    columnDefs: (ColDef | ColGroupDef)[],
    source?: ColumnEventType
) => void;

method setColumnGroupOpened

setColumnGroupOpened: (
    key: OriginalColumnGroup | string,
    newValue: boolean,
    source?: ColumnEventType
) => void;

method setColumnGroupState

setColumnGroupState: (
    stateItems: { groupId: string; open: boolean }[],
    source?: ColumnEventType
) => void;

method setColumnPinned

setColumnPinned: (
    key: string | Column,
    pinned: string | boolean,
    source?: ColumnEventType
) => void;

method setColumnsPinned

setColumnsPinned: (
    keys: (string | Column)[],
    pinned: string | boolean,
    source?: ColumnEventType
) => void;

method setColumnState

setColumnState: (
    columnState: ColumnState[],
    source?: ColumnEventType
) => boolean;

method setColumnsVisible

setColumnsVisible: (
    keys: (string | Column)[],
    visible: boolean,
    source?: ColumnEventType
) => void;

method setColumnVisible

setColumnVisible: (
    key: string | Column,
    visible: boolean,
    source?: ColumnEventType
) => void;

method setColumnWidth

setColumnWidth: (
    key: string | Column,
    newWidth: number,
    shiftKey: boolean,
    finished: boolean,
    source?: ColumnEventType
) => void;

method setPivotColumns

setPivotColumns: (
    colKeys: (string | Column)[],
    source?: ColumnEventType
) => void;

method setPivotMode

setPivotMode: (pivotMode: boolean, source?: ColumnEventType) => void;

method setRowGroupColumns

setRowGroupColumns: (
    colKeys: (string | Column)[],
    source?: ColumnEventType
) => void;

method setSecondaryColumns

setSecondaryColumns: (
    colDefs: (ColDef | ColGroupDef)[],
    source?: ColumnEventType
) => void;

method setValueColumns

setValueColumns: (
    colKeys: (string | Column)[],
    source?: ColumnEventType
) => void;

method setVirtualViewportPosition

setVirtualViewportPosition: (
    scrollWidth: number,
    scrollPosition: number
) => void;

method sizeColumnsToFit

sizeColumnsToFit: (gridWidth: any, source?: ColumnEventType) => void;

method updatePrimaryColumnList

updatePrimaryColumnList: (
    keys: (string | Column)[],
    masterList: Column[],
    actionIsAdd: boolean,
    columnCallback: (column: Column) => void,
    eventType: string,
    source?: ColumnEventType
) => void;

class ColumnGroup

class ColumnGroup implements ColumnGroupChild {}

constructor

constructor(
    originalColumnGroup: OriginalColumnGroup,
    groupId: string,
    instanceId: number
);

property EVENT_DISPLAYED_CHILDREN_CHANGED

static EVENT_DISPLAYED_CHILDREN_CHANGED: string;

property EVENT_LEFT_CHANGED

static EVENT_LEFT_CHANGED: string;

property gridOptionsWrapper

gridOptionsWrapper: GridOptionsWrapper;

property HEADER_GROUP_SHOW_CLOSED

static HEADER_GROUP_SHOW_CLOSED: string;

property HEADER_GROUP_SHOW_OPEN

static HEADER_GROUP_SHOW_OPEN: string;

method addChild

addChild: (child: ColumnGroupChild) => void;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method calculateDisplayedColumns

calculateDisplayedColumns: () => void;

method checkLeft

checkLeft: () => void;

method createUniqueId

static createUniqueId: (groupId: string, instanceId: number) => string;

method getActualWidth

getActualWidth: () => number;

method getChildren

getChildren: () => ColumnGroupChild[];

method getColGroupDef

getColGroupDef: () => ColGroupDef;

method getColumnGroupShow

getColumnGroupShow: () => string;

method getDefinition

getDefinition: () => AbstractColDef;

method getDisplayedChildren

getDisplayedChildren: () => ColumnGroupChild[];

method getDisplayedLeafColumns

getDisplayedLeafColumns: () => Column[];

method getGroupId

getGroupId: () => string;

method getInstanceId

getInstanceId: () => number;

method getLeafColumns

getLeafColumns: () => Column[];

method getLeft

getLeft: () => number;

method getMinWidth

getMinWidth: () => number;

method getOldLeft

getOldLeft: () => number;

method getOriginalColumnGroup

getOriginalColumnGroup: () => OriginalColumnGroup;

method getParent

getParent: () => ColumnGroup;

method getUniqueId

getUniqueId: () => string;

method isChildInThisGroupDeepSearch

isChildInThisGroupDeepSearch: (wantedChild: ColumnGroupChild) => boolean;

method isEmptyGroup

isEmptyGroup: () => boolean;

method isExpandable

isExpandable: () => boolean;

method isExpanded

isExpanded: () => boolean;

method isMoving

isMoving: () => boolean;

method isPadding

isPadding: () => boolean;

method isResizable

isResizable: () => boolean;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

method reset

reset: () => void;

method setExpanded

setExpanded: (expanded: boolean) => void;

method setLeft

setLeft: (left: number) => void;

method setParent

setParent: (parent: ColumnGroup) => void;

class ColumnKeyCreator

class ColumnKeyCreator {}

method getUniqueKey

getUniqueKey: (colId: string, colField: string) => string;

class ColumnUtils

class ColumnUtils {}

method calculateColInitialWidth

calculateColInitialWidth: (colDef: any) => number;

method depthFirstAllColumnTreeSearch

depthFirstAllColumnTreeSearch: (
    tree: ColumnGroupChild[],
    callback: (treeNode: ColumnGroupChild) => void
) => void;

method depthFirstDisplayedColumnTreeSearch

depthFirstDisplayedColumnTreeSearch: (
    tree: ColumnGroupChild[],
    callback: (treeNode: ColumnGroupChild) => void
) => void;

method depthFirstOriginalTreeSearch

depthFirstOriginalTreeSearch: (
    tree: OriginalColumnGroupChild[],
    callback: (treeNode: OriginalColumnGroupChild) => void
) => void;

method getOriginalPathForColumn

getOriginalPathForColumn: (
    column: Column,
    originalBalancedTree: OriginalColumnGroupChild[]
) => OriginalColumnGroup[];

class Component

class Component extends BeanStub implements IComponent<any> {}

constructor

constructor(template?: string);

property EVENT_VISIBLE_CHANGED

static EVENT_VISIBLE_CHANGED: string;

method addCssClass

addCssClass: (className: string) => void;

method addFeature

addFeature: (context: Context, feature: BeanStub) => void;

method addGuiEventListener

addGuiEventListener: (event: string, listener: (event: any) => void) => void;

method addOrRemoveCssClass

addOrRemoveCssClass: (className: string, addOrRemove: boolean) => void;

method appendChild

appendChild: (newChild: Node | IComponent<any>) => void;

method destroy

destroy: () => void;

method getAttribute

getAttribute: (key: string) => string;

method getCompId

getCompId: () => number;

method getGui

getGui: () => HTMLElement;

method getRefElement

getRefElement: (refName: string) => HTMLElement;

method instantiate

instantiate: (context: Context) => void;

method isVisible

isVisible: () => boolean;

method queryForHtmlElement

protected queryForHtmlElement: (cssSelector: string) => HTMLElement;

method queryForHtmlInputElement

protected queryForHtmlInputElement: (cssSelector: string) => HTMLInputElement;

method removeCssClass

removeCssClass: (className: string) => void;

method setGui

protected setGui: (eGui: HTMLElement) => void;

method setTemplate

setTemplate: (template: string) => void;

method setTemplateFromElement

setTemplateFromElement: (element: HTMLElement) => void;

method setVisible

setVisible: (visible: boolean) => void;

method wireQuerySelectors

protected wireQuerySelectors: () => void;

class ComponentProvider

class ComponentProvider {}

method registerComponent

registerComponent: <A extends IComponent<any>>(
    rawName: string,
    component: AgGridRegisteredComponentInput<A>
) => void;

method registerDefaultComponent

registerDefaultComponent: <A extends IComponent<any>>(
    rawName: string,
    component: AgGridRegisteredComponentInput<A>,
    overridable?: boolean
) => void;

method registerFwComponent

registerFwComponent: <A extends IComponent<any> & B, B>(
    rawName: string,
    component: { new (): IComponent<B> }
) => void;

B the business interface (ie IHeader) A the agGridComponent interface (ie IHeaderComp). The final object acceptable by ag-grid

method retrieve

retrieve: <A extends IComponent<any> & B, B>(
    rawName: string
) => RegisteredComponent<A, B>;

B the business interface (ie IHeader) A the agGridComponent interface (ie IHeaderComp). The final object acceptable by ag-grid

class ComponentUtil

class ComponentUtil {}

property ALL_PROPERTIES

static ALL_PROPERTIES: string[];

property ARRAY_PROPERTIES

static ARRAY_PROPERTIES: string[];

property BOOLEAN_PROPERTIES

static BOOLEAN_PROPERTIES: string[];

property EVENTS

static EVENTS: string[];

property FUNCTION_PROPERTIES

static FUNCTION_PROPERTIES: string[];

property NUMBER_PROPERTIES

static NUMBER_PROPERTIES: string[];

property OBJECT_PROPERTIES

static OBJECT_PROPERTIES: string[];

property STRING_PROPERTIES

static STRING_PROPERTIES: string[];

method copyAttributesToGridOptions

static copyAttributesToGridOptions: (
    gridOptions: GridOptions,
    component: any,
    skipEventDeprecationCheck?: boolean
) => GridOptions;

method getCallbackForEvent

static getCallbackForEvent: (eventName: string) => string;

method getEventCallbacks

static getEventCallbacks: () => string[];

method processOnChange

static processOnChange: (
    changes: any,
    gridOptions: GridOptions,
    api: GridApi,
    columnApi: ColumnApi
) => void;

method toBoolean

static toBoolean: (value: any) => boolean;

method toNumber

static toNumber: (value: any) => number;

class Constants

class Constants {}

property ALWAYS

static ALWAYS: string;

property BATCH_WAIT_MILLIS

static BATCH_WAIT_MILLIS: number;

property DEPRECATED_ROW_MODEL_TYPE_NORMAL

static DEPRECATED_ROW_MODEL_TYPE_NORMAL: string;

property EXPORT_TYPE_CLIPBOARD

static EXPORT_TYPE_CLIPBOARD: string;

property EXPORT_TYPE_CSV

static EXPORT_TYPE_CSV: string;

property EXPORT_TYPE_DRAG_COPY

static EXPORT_TYPE_DRAG_COPY: string;

property EXPORT_TYPE_EXCEL

static EXPORT_TYPE_EXCEL: string;

property KEY_A

static KEY_A: number;

property KEY_BACKSPACE

static KEY_BACKSPACE: number;

property KEY_C

static KEY_C: number;

property KEY_D

static KEY_D: number;

property KEY_DELETE

static KEY_DELETE: number;

property KEY_DOWN

static KEY_DOWN: number;

property KEY_ENTER

static KEY_ENTER: number;

property KEY_ESCAPE

static KEY_ESCAPE: number;

property KEY_F2

static KEY_F2: number;

property KEY_LEFT

static KEY_LEFT: number;

property KEY_NEW_LINE

static KEY_NEW_LINE: number;

property KEY_PAGE_DOWN

static KEY_PAGE_DOWN: number;

property KEY_PAGE_END

static KEY_PAGE_END: number;

property KEY_PAGE_HOME

static KEY_PAGE_HOME: number;

property KEY_PAGE_UP

static KEY_PAGE_UP: number;

property KEY_RIGHT

static KEY_RIGHT: number;

property KEY_SHIFT

static KEY_SHIFT: number;

property KEY_SPACE

static KEY_SPACE: number;

property KEY_TAB

static KEY_TAB: number;

property KEY_UP

static KEY_UP: number;

property KEY_V

static KEY_V: number;

property LAYOUT_INTERVAL

static LAYOUT_INTERVAL: number;

property ONLY_WHEN_GROUPING

static ONLY_WHEN_GROUPING: string;

property PINNED_BOTTOM

static PINNED_BOTTOM: string;

property PINNED_TOP

static PINNED_TOP: string;

property ROW_BUFFER_SIZE

static ROW_BUFFER_SIZE: number;

property ROW_MODEL_TYPE_CLIENT_SIDE

static ROW_MODEL_TYPE_CLIENT_SIDE: string;

property ROW_MODEL_TYPE_INFINITE

static ROW_MODEL_TYPE_INFINITE: string;

property ROW_MODEL_TYPE_SERVER_SIDE

static ROW_MODEL_TYPE_SERVER_SIDE: string;

property ROW_MODEL_TYPE_VIEWPORT

static ROW_MODEL_TYPE_VIEWPORT: string;

property STEP_AGGREGATE

static STEP_AGGREGATE: number;

property STEP_EVERYTHING

static STEP_EVERYTHING: number;

property STEP_FILTER

static STEP_FILTER: number;

property STEP_MAP

static STEP_MAP: number;

property STEP_PIVOT

static STEP_PIVOT: number;

property STEP_SORT

static STEP_SORT: number;

class Context

class Context {}

constructor

constructor(params: ContextParams, logger: ILogger);

method createComponent

createComponent: (
    element: Element,
    afterPreCreateCallback?: (comp: Component) => void
) => Component;

method destroy

destroy: () => void;

method getBean

getBean: (name: string) => any;

method wireBean

wireBean: (
    bean: any,
    afterPreCreateCallback?: (comp: Component) => void
) => void;

class CssClassApplier

class CssClassApplier {}

method addColumnClassesFromCollDef

static addColumnClassesFromCollDef: (
    classesOrFunc: string | string[] | ((params: any) => string | string[]),
    abstractColDef: AbstractColDef,
    eHeaderCell: HTMLElement,
    gridOptionsWrapper: GridOptionsWrapper,
    column: Column,
    columnGroup: ColumnGroup | OriginalColumnGroup
) => void;

method addHeaderClassesFromColDef

static addHeaderClassesFromColDef: (
    abstractColDef: AbstractColDef,
    eHeaderCell: HTMLElement,
    gridOptionsWrapper: GridOptionsWrapper,
    column: Column,
    columnGroup: ColumnGroup
) => void;

method addToolPanelClassesFromColDef

static addToolPanelClassesFromColDef: (
    abstractColDef: AbstractColDef,
    eHeaderCell: HTMLElement,
    gridOptionsWrapper: GridOptionsWrapper,
    column: Column,
    columnGroup: OriginalColumnGroup
) => void;

class CsvCreator

class CsvCreator extends BaseCreator<
    string,
    CsvSerializingSession,
    CsvExportParams
> {}

property gridOptionsWrapper

gridOptionsWrapper: GridOptionsWrapper;

method createSerializingSession

createSerializingSession: (params?: CsvExportParams) => CsvSerializingSession;

method exportDataAsCsv

exportDataAsCsv: (params?: CsvExportParams) => string;

method getDataAsCsv

getDataAsCsv: (params?: CsvExportParams) => string;

method getDefaultFileExtension

getDefaultFileExtension: () => string;

method getDefaultFileName

getDefaultFileName: () => string;

method getMimeType

getMimeType: () => string;

method isExportSuppressed

isExportSuppressed: () => boolean;

method postConstruct

postConstruct: () => void;

class DateFilter

class DateFilter extends ScalarBaseFilter<
    Date,
    IDateFilterParams,
    SerializedDateFilter
> {}

method bodyTemplate

bodyTemplate: (type: FilterConditionType) => string;

method comparator

comparator: () => Comparator<Date>;

method filterValues

filterValues: (type: FilterConditionType) => Date | Date[];

method getApplicableFilterTypes

getApplicableFilterTypes: () => string[];

method getDateFrom

getDateFrom: () => string;

method getDateTo

getDateTo: () => string;

method getFilterType

getFilterType: () => string;

method initialiseFilterBodyUi

initialiseFilterBodyUi: (type: FilterConditionType) => void;

method modelFromFloatingFilter

modelFromFloatingFilter: (from: string) => SerializedDateFilter;

method parse

parse: (model: SerializedDateFilter, type: FilterConditionType) => void;

method refreshFilterBodyUi

refreshFilterBodyUi: (type: FilterConditionType) => void;

method removeTimezone

static removeTimezone: (from: Date) => Date;

method resetState

resetState: () => void;

method serialize

serialize: (type: FilterConditionType) => SerializedDateFilter;

method setDateFrom

setDateFrom: (date: string, type: FilterConditionType) => void;

method setDateTo

setDateTo: (date: string, type: FilterConditionType) => void;

method setType

setType: (filterType: string, type: FilterConditionType) => void;

class DisplayedGroupCreator

class DisplayedGroupCreator {}

method createDisplayedGroups

createDisplayedGroups: (
    sortedVisibleColumns: Column[],
    balancedColumnTree: OriginalColumnGroupChild[],
    groupInstanceIdCreator: GroupInstanceIdCreator,
    oldDisplayedGroups?: ColumnGroupChild[]
) => ColumnGroupChild[];

class Downloader

class Downloader {}

method download

download: (fileName: string, content: string, mimeType: string) => void;

class DragAndDropService

class DragAndDropService {}

property GHOST_TEMPLATE

static GHOST_TEMPLATE: string;

property ICON_ADD

static ICON_ADD: string;

property ICON_AGGREGATE

static ICON_AGGREGATE: string;

property ICON_GROUP

static ICON_GROUP: string;

property ICON_LEFT

static ICON_LEFT: string;

property ICON_MOVE

static ICON_MOVE: string;

property ICON_NOT_ALLOWED

static ICON_NOT_ALLOWED: string;

property ICON_PINNED

static ICON_PINNED: string;

property ICON_PIVOT

static ICON_PIVOT: string;

property ICON_RIGHT

static ICON_RIGHT: string;

method addDragSource

addDragSource: (dragSource: DragSource, allowTouch?: boolean) => void;

method addDropTarget

addDropTarget: (dropTarget: DropTarget) => void;

method createDropTargetEvent

createDropTargetEvent: (
    dropTarget: DropTarget,
    event: MouseEvent,
    hDirection: HDirection,
    vDirection: VDirection,
    fromNudge: boolean
) => DraggingEvent;

method nudge

nudge: () => void;

method removeDragSource

removeDragSource: (dragSource: DragSource) => void;

method setGhostIcon

setGhostIcon: (iconName: string, shake?: boolean) => void;

method workOutHDirection

workOutHDirection: (event: MouseEvent) => HDirection;

method workOutVDirection

workOutVDirection: (event: MouseEvent) => VDirection;

class DragService

class DragService {}

Adds drag listening onto an element. In ag-Grid this is used twice, first is resizing columns, second is moving the columns and column groups around (ie the 'drag' part of Drag and Drop.

method addDragSource

addDragSource: (params: DragListenerParams, includeTouch?: boolean) => void;

method onMouseUp

onMouseUp: (mouseEvent: MouseEvent) => void;

method onTouchUp

onTouchUp: (touchEvent: TouchEvent) => void;

method onUpCommon

onUpCommon: (eventOrTouch: MouseEvent | Touch) => void;

method removeDragSource

removeDragSource: (params: DragListenerParams) => void;

class Environment

class Environment {}

method getSassVariable

getSassVariable: (theme: string, key: string) => number;

method getTheme

getTheme: () => string;

method loadSassVariables

loadSassVariables: () => void;

class Events

class Events {}

property EVENT_ANIMATION_QUEUE_EMPTY

static EVENT_ANIMATION_QUEUE_EMPTY: string;

property EVENT_BODY_HEIGHT_CHANGED

static EVENT_BODY_HEIGHT_CHANGED: string;

All items from here down are used internally by the grid, not intended for external use.

property EVENT_BODY_SCROLL

static EVENT_BODY_SCROLL: string;

Main body of grid has scrolled, either horizontally or vertically

property EVENT_CELL_CLICKED

static EVENT_CELL_CLICKED: string;

property EVENT_CELL_CONTEXT_MENU

static EVENT_CELL_CONTEXT_MENU: string;

property EVENT_CELL_DOUBLE_CLICKED

static EVENT_CELL_DOUBLE_CLICKED: string;

property EVENT_CELL_EDITING_STARTED

static EVENT_CELL_EDITING_STARTED: string;

property EVENT_CELL_EDITING_STOPPED

static EVENT_CELL_EDITING_STOPPED: string;

property EVENT_CELL_FOCUSED

static EVENT_CELL_FOCUSED: string;

property EVENT_CELL_MOUSE_DOWN

static EVENT_CELL_MOUSE_DOWN: string;

property EVENT_CELL_MOUSE_OUT

static EVENT_CELL_MOUSE_OUT: string;

property EVENT_CELL_MOUSE_OVER

static EVENT_CELL_MOUSE_OVER: string;

property EVENT_CELL_VALUE_CHANGED

static EVENT_CELL_VALUE_CHANGED: string;

property EVENT_COLUMN_AGG_FUNC_CHANGE_REQUEST

static EVENT_COLUMN_AGG_FUNC_CHANGE_REQUEST: string;

property EVENT_COLUMN_EVERYTHING_CHANGED

static EVENT_COLUMN_EVERYTHING_CHANGED: string;

Everything has changed with the columns. Either complete new set of columns set, or user called setState()

property EVENT_COLUMN_GROUP_OPENED

static EVENT_COLUMN_GROUP_OPENED: string;

A column group was opened / closed

property EVENT_COLUMN_HOVER_CHANGED

static EVENT_COLUMN_HOVER_CHANGED: string;

property EVENT_COLUMN_MOVED

static EVENT_COLUMN_MOVED: string;

A column was moved

property EVENT_COLUMN_PINNED

static EVENT_COLUMN_PINNED: string;

One or more columns was pinned / unpinned

property EVENT_COLUMN_PIVOT_CHANGE_REQUEST

static EVENT_COLUMN_PIVOT_CHANGE_REQUEST: string;

property EVENT_COLUMN_PIVOT_CHANGED

static EVENT_COLUMN_PIVOT_CHANGED: string;

A pivot column was added, removed or order changed.

property EVENT_COLUMN_PIVOT_MODE_CHANGED

static EVENT_COLUMN_PIVOT_MODE_CHANGED: string;

The pivot mode flag was changed

property EVENT_COLUMN_RESIZED

static EVENT_COLUMN_RESIZED: string;

One or more columns was resized. If just one, the column in the event is set.

property EVENT_COLUMN_ROW_GROUP_CHANGE_REQUEST

static EVENT_COLUMN_ROW_GROUP_CHANGE_REQUEST: string;

property EVENT_COLUMN_ROW_GROUP_CHANGED

static EVENT_COLUMN_ROW_GROUP_CHANGED: string;

A row group column was added, removed or order changed.

property EVENT_COLUMN_VALUE_CHANGE_REQUEST

static EVENT_COLUMN_VALUE_CHANGE_REQUEST: string;

property EVENT_COLUMN_VALUE_CHANGED

static EVENT_COLUMN_VALUE_CHANGED: string;

A value column was added, removed or agg function was changed.

property EVENT_COLUMN_VISIBLE

static EVENT_COLUMN_VISIBLE: string;

One or more columns was shown / hidden

property EVENT_COMPONENT_STATE_CHANGED

static EVENT_COMPONENT_STATE_CHANGED: string;

Only used by React, Angular 2+, Web Components, Aurelia and VueJS ag-Grid components (not used if doing plain JavaScript or Angular 1.x). If the grid receives changes due to bound properties, this event fires after the grid has finished processing the change.

property EVENT_DISPLAYED_COLUMNS_CHANGED

static EVENT_DISPLAYED_COLUMNS_CHANGED: string;

The list of displayed columns has changed, can result from columns open / close, column move, pivot, group, etc

property EVENT_DISPLAYED_COLUMNS_WIDTH_CHANGED

static EVENT_DISPLAYED_COLUMNS_WIDTH_CHANGED: string;

property EVENT_DRAG_STARTED

static EVENT_DRAG_STARTED: string;

A column drag has started, either resizing a column or moving a column.

property EVENT_DRAG_STOPPED

static EVENT_DRAG_STOPPED: string;

A column drag has stopped

property EVENT_FILTER_CHANGED

static EVENT_FILTER_CHANGED: string;

2 events for filtering. The grid LISTENS for filterChanged and afterFilterChanged

property EVENT_FILTER_MODIFIED

static EVENT_FILTER_MODIFIED: string;

Filter was change but not applied. Only useful if apply buttons are used in filters.

property EVENT_FLASH_CELLS

static EVENT_FLASH_CELLS: string;

property EVENT_GRID_COLUMNS_CHANGED

static EVENT_GRID_COLUMNS_CHANGED: string;

The list of grid columns has changed.

property EVENT_GRID_READY

static EVENT_GRID_READY: string;

Gets called once after the grid has finished initialising.

property EVENT_GRID_SIZE_CHANGED

static EVENT_GRID_SIZE_CHANGED: string;

Width of height of the main grid div has changed. Grid listens for this and does layout of grid if it's changed, so always filling the space it was given.

property EVENT_HEIGHT_SCALE_CHANGED

static EVENT_HEIGHT_SCALE_CHANGED: string;

property EVENT_MODEL_UPDATED

static EVENT_MODEL_UPDATED: string;

Model was updated - grid updates the drawn rows when this happens

property EVENT_NEW_COLUMNS_LOADED

static EVENT_NEW_COLUMNS_LOADED: string;

User has set in new columns.

property EVENT_PAGINATION_CHANGED

static EVENT_PAGINATION_CHANGED: string;

The displayed page for pagination has changed. For example the data was filtered or sorted, or the user has moved to a different page.

property EVENT_PASTE_END

static EVENT_PASTE_END: string;

property EVENT_PASTE_START

static EVENT_PASTE_START: string;

property EVENT_PINNED_ROW_DATA_CHANGED

static EVENT_PINNED_ROW_DATA_CHANGED: string;

The client has set new floating data into the grid

property EVENT_RANGE_SELECTION_CHANGED

static EVENT_RANGE_SELECTION_CHANGED: string;

Range selection has changed

property EVENT_ROW_CLICKED

static EVENT_ROW_CLICKED: string;

property EVENT_ROW_DATA_CHANGED

static EVENT_ROW_DATA_CHANGED: string;

The client has set new data into the grid

property EVENT_ROW_DATA_UPDATED

static EVENT_ROW_DATA_UPDATED: string;

The client has updated data for the grid

property EVENT_ROW_DOUBLE_CLICKED

static EVENT_ROW_DOUBLE_CLICKED: string;

property EVENT_ROW_DRAG_END

static EVENT_ROW_DRAG_END: string;

property EVENT_ROW_DRAG_ENTER

static EVENT_ROW_DRAG_ENTER: string;

property EVENT_ROW_DRAG_LEAVE

static EVENT_ROW_DRAG_LEAVE: string;

property EVENT_ROW_DRAG_MOVE

static EVENT_ROW_DRAG_MOVE: string;

property EVENT_ROW_EDITING_STARTED

static EVENT_ROW_EDITING_STARTED: string;

property EVENT_ROW_EDITING_STOPPED

static EVENT_ROW_EDITING_STOPPED: string;

property EVENT_ROW_GROUP_OPENED

static EVENT_ROW_GROUP_OPENED: string;

A row group was opened / closed

property EVENT_ROW_SELECTED

static EVENT_ROW_SELECTED: string;

property EVENT_ROW_VALUE_CHANGED

static EVENT_ROW_VALUE_CHANGED: string;

property EVENT_SCROLL_VISIBILITY_CHANGED

static EVENT_SCROLL_VISIBILITY_CHANGED: string;

property EVENT_SELECTION_CHANGED

static EVENT_SELECTION_CHANGED: string;

property EVENT_SORT_CHANGED

static EVENT_SORT_CHANGED: string;

property EVENT_TOOL_PANEL_VISIBLE_CHANGED

static EVENT_TOOL_PANEL_VISIBLE_CHANGED: string;

For when the tool panel is shown / hidden

property EVENT_VIEWPORT_CHANGED

static EVENT_VIEWPORT_CHANGED: string;

The indexes of the rows rendered has changed, eg user has scrolled to a new vertical position.

property EVENT_VIRTUAL_COLUMNS_CHANGED

static EVENT_VIRTUAL_COLUMNS_CHANGED: string;

The list of virtual columns has changed, results from viewport changing

property EVENT_VIRTUAL_ROW_REMOVED

static EVENT_VIRTUAL_ROW_REMOVED: string;

A row was removed from the dom, for any reason. Use to clean up resources (if any) used by the row.

class EventService

class EventService implements IEventEmitter {}

method addEventListener

addEventListener: (
    eventType: string,
    listener: Function,
    async?: boolean
) => void;

method addGlobalListener

addGlobalListener: (listener: Function, async?: boolean) => void;

method addModalPriorityEventListener

addModalPriorityEventListener: (
    eventType: string,
    listener: Function,
    async?: boolean
) => void;

method dispatchEvent

dispatchEvent: (event: AgEvent) => void;

method removeEventListener

removeEventListener: (
    eventType: string,
    listener: Function,
    async?: boolean
) => void;

method removeGlobalListener

removeGlobalListener: (listener: Function, async?: boolean) => void;

method setBeans

setBeans: (
    loggerFactory: LoggerFactory,
    gridOptionsWrapper: GridOptionsWrapper,
    globalEventListener?: Function
) => void;

class ExpressionService

class ExpressionService {}

method evaluate

evaluate: (expressionOrFunc: Function | string, params: any) => any;

class FilterManager

class FilterManager {}

property QUICK_FILTER_SEPARATOR

static QUICK_FILTER_SEPARATOR: string;

method cachedFilter

cachedFilter: (column: Column) => FilterWrapper;

method destroy

destroy: () => void;

method destroyFilter

destroyFilter: (column: Column, source?: ColumnEventType) => void;

method doesRowPassFilter

doesRowPassFilter: (node: any, filterToSkip?: any) => boolean;

method doesRowPassOtherFilters

doesRowPassOtherFilters: (filterToSkip: any, node: any) => boolean;

method getFilterComponent

getFilterComponent: (column: Column) => Promise<IFilterComp>;

method getFilterModel

getFilterModel: () => any;

method getOrCreateFilterWrapper

getOrCreateFilterWrapper: (column: Column) => FilterWrapper;

method init

init: () => void;

method isAdvancedFilterPresent

isAdvancedFilterPresent: () => boolean;

method isAnyFilterPresent

isAnyFilterPresent: () => boolean;

method isQuickFilterPresent

isQuickFilterPresent: () => boolean;

method onFilterChanged

onFilterChanged: () => void;

method setFilterModel

setFilterModel: (model: any) => void;

method setQuickFilter

setQuickFilter: (newFilter: any) => void;

class FilterStage

class FilterStage implements IRowNodeStage {}

method execute

execute: (params: StageExecuteParams) => void;

class FlattenStage

class FlattenStage implements IRowNodeStage {}

method execute

execute: (params: StageExecuteParams) => RowNode[];

class FocusedCellController

class FocusedCellController {}

method clearFocusedCell

clearFocusedCell: () => void;

method getFocusCellToUseAfterRefresh

getFocusCellToUseAfterRefresh: () => GridCell;

method getFocusedCell

getFocusedCell: () => GridCell;

method isAnyCellFocused

isAnyCellFocused: () => boolean;

method isCellFocused

isCellFocused: (gridCell: GridCell) => boolean;

method isRowFocused

isRowFocused: (rowIndex: number, floating: string) => boolean;

method isRowNodeFocused

isRowNodeFocused: (rowNode: RowNode) => boolean;

method setFocusedCell

setFocusedCell: (
    rowIndex: number,
    colKey: string | Column,
    floating: string,
    forceBrowserFocus?: boolean
) => void;

class Grid

class Grid {}

constructor

constructor(
    eGridDiv: HTMLElement,
    gridOptions: GridOptions,
    params?: GridParams
);

method destroy

destroy: () => void;

method setEnterpriseBeans

static setEnterpriseBeans: (
    enterpriseBeans: any[],
    rowModelClasses: any
) => void;

method setEnterpriseComponents

static setEnterpriseComponents: (components: any[]) => void;

method setFrameworkBeans

static setFrameworkBeans: (frameworkBeans: any[]) => void;

class GridApi

class GridApi {}

method addAggFunc

addAggFunc: (key: string, aggFunc: IAggFunc) => void;

method addAggFuncs

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

method addDetailGridInfo

addDetailGridInfo: (id: string, gridInfo: DetailGridInfo) => void;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method addGlobalListener

addGlobalListener: (listener: Function) => void;

method addItems

addItems: (items: any[], skipRefresh?: boolean) => void;

method addRangeSelection

addRangeSelection: (rangeSelection: AddRangeSelectionParams) => void;

method addRenderedRowListener

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

method addVirtualRowListener

addVirtualRowListener: (
    eventName: string,
    rowIndex: number,
    callback: Function
) => void;

method batchUpdateRowData

batchUpdateRowData: (
    rowDataTransaction: RowDataTransaction,
    callback?: (res: RowNodeTransaction) => void
) => void;

method camelCaseToHumanReadable

camelCaseToHumanReadable: (camelCase: string) => string;

method checkGridSize

checkGridSize: () => void;

method clearAggFuncs

clearAggFuncs: () => void;

method clearFocusedCell

clearFocusedCell: () => void;

method clearRangeSelection

clearRangeSelection: () => void;

method collapseAll

collapseAll: () => void;

method copySelectedRangeDown

copySelectedRangeDown: () => void;

method copySelectedRangeToClipboard

copySelectedRangeToClipboard: (includeHeader: boolean) => void;

method copySelectedRowsToClipboard

copySelectedRowsToClipboard: (
    includeHeader: boolean,
    columnKeys?: (string | Column)[]
) => void;

method deselectAll

deselectAll: () => void;

method deselectAllFiltered

deselectAllFiltered: () => void;

method deselectIndex

deselectIndex: (index: number, suppressEvents?: boolean) => void;

method deselectNode

deselectNode: (node: RowNode, suppressEvents?: boolean) => void;

method destroy

destroy: () => void;

method destroyFilter

destroyFilter: (key: string | Column) => void;

method dispatchEvent

dispatchEvent: (event: AgEvent) => void;

method doLayout

doLayout: () => void;

method ensureColIndexVisible

ensureColIndexVisible: (index: any) => void;

method ensureColumnVisible

ensureColumnVisible: (key: string | Column) => void;

method ensureIndexVisible

ensureIndexVisible: (index: any, position?: string) => void;

method ensureNodeVisible

ensureNodeVisible: (comparator: any, position?: string) => void;

method expandAll

expandAll: () => void;

method expireValueCache

expireValueCache: () => void;

method exportDataAsCsv

exportDataAsCsv: (params?: CsvExportParams) => void;

method exportDataAsExcel

exportDataAsExcel: (params?: ExcelExportParams) => void;

method flashCells

flashCells: (params?: FlashCellsParams) => void;

method forEachDetailGridInfo

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

method forEachLeafNode

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

method forEachNode

forEachNode: (callback: (rowNode: RowNode) => void) => void;

method forEachNodeAfterFilter

forEachNodeAfterFilter: (callback: (rowNode: RowNode) => void) => void;

method forEachNodeAfterFilterAndSort

forEachNodeAfterFilterAndSort: (callback: (rowNode: RowNode) => void) => void;

method getBestCostNodeSelection

getBestCostNodeSelection: () => any;

method getCacheBlockState

getCacheBlockState: () => any;

method getCellEditorInstances

getCellEditorInstances: (
    params?: GetCellEditorInstancesParams
) => ICellEditorComp[];

method getCellRendererInstances

getCellRendererInstances: (
    params?: GetCellRendererInstancesParams
) => ICellRendererComp[];

method getColumnDef

getColumnDef: (key: string | Column) => ColDef;

method getDataAsCsv

getDataAsCsv: (params?: CsvExportParams) => string;

method getDataAsExcel

getDataAsExcel: (params?: ExcelExportParams) => string;

method getDetailGridInfo

getDetailGridInfo: (id: string) => DetailGridInfo;

method getDisplayedRowAtIndex

getDisplayedRowAtIndex: (index: number) => RowNode;

method getDisplayedRowCount

getDisplayedRowCount: () => number;

method getEditingCells

getEditingCells: () => GridCellDef[];

method getFilterApi

getFilterApi: (key: string | Column) => IFilterComp;

method getFilterApiForColDef

getFilterApiForColDef: (colDef: any) => any;

method getFilterInstance

getFilterInstance: (key: string | Column) => IFilterComp;

method getFilterModel

getFilterModel: () => any;

method getFirstDisplayedRow

getFirstDisplayedRow: () => number;

method getFirstRenderedRow

getFirstRenderedRow: () => number;

method getFloatingBottomRow

getFloatingBottomRow: (index: number) => RowNode;

method getFloatingBottomRowCount

getFloatingBottomRowCount: () => number;

method getFloatingTopRow

getFloatingTopRow: (index: number) => RowNode;

method getFloatingTopRowCount

getFloatingTopRowCount: () => number;

method getFocusedCell

getFocusedCell: () => GridCell;

method getInfinitePageState

getInfinitePageState: () => any;

method getInfiniteRowCount

getInfiniteRowCount: () => number;

method getLastDisplayedRow

getLastDisplayedRow: () => number;

method getLastRenderedRow

getLastRenderedRow: () => number;

method getModel

getModel: () => IRowModel;

method getPinnedBottomRow

getPinnedBottomRow: (index: number) => RowNode;

method getPinnedBottomRowCount

getPinnedBottomRowCount: () => number;

method getPinnedTopRow

getPinnedTopRow: (index: number) => RowNode;

method getPinnedTopRowCount

getPinnedTopRowCount: () => number;

method getPreferredWidth

getPreferredWidth: () => number;

method getRangeSelections

getRangeSelections: () => RangeSelection[];

method getRenderedNodes

getRenderedNodes: () => RowNode[];

method getRowNode

getRowNode: (id: string) => RowNode;

method getSelectedNodes

getSelectedNodes: () => RowNode[];

method getSelectedNodesById

getSelectedNodesById: () => { [nodeId: number]: RowNode };

method getSelectedRows

getSelectedRows: () => any[];

method getSortModel

getSortModel: () => { colId: string; sort: string }[];

method getValue

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

method getVerticalPixelRange

getVerticalPixelRange: () => any;

method getVirtualPageState

getVirtualPageState: () => any;

method getVirtualRowCount

getVirtualRowCount: () => number;

method hideOverlay

hideOverlay: () => void;

method hidePopupMenu

hidePopupMenu: () => void;

method insertItemsAtIndex

insertItemsAtIndex: (index: number, items: any[], skipRefresh?: boolean) => void;

method isAdvancedFilterPresent

isAdvancedFilterPresent: () => boolean;

method isAnimationFrameQueueEmpty

isAnimationFrameQueueEmpty: () => boolean;

method isAnyFilterPresent

isAnyFilterPresent: () => boolean;

method isMaxRowFound

isMaxRowFound: () => boolean;

method isNodeSelected

isNodeSelected: (node: any) => any;

method isQuickFilterPresent

isQuickFilterPresent: () => boolean;

method isToolPanelShowing

isToolPanelShowing: () => boolean;

method onFilterChanged

onFilterChanged: () => void;

method onGroupExpandedOrCollapsed

onGroupExpandedOrCollapsed: (deprecated_refreshFromIndex?: any) => void;

method onRowHeightChanged

onRowHeightChanged: () => void;

method onSortChanged

onSortChanged: () => void;

method paginationGetCurrentPage

paginationGetCurrentPage: () => number;

method paginationGetPageSize

paginationGetPageSize: () => number;

method paginationGetRowCount

paginationGetRowCount: () => number;

method paginationGetTotalPages

paginationGetTotalPages: () => number;

method paginationGoToFirstPage

paginationGoToFirstPage: () => void;

method paginationGoToLastPage

paginationGoToLastPage: () => void;

method paginationGoToNextPage

paginationGoToNextPage: () => void;

method paginationGoToPage

paginationGoToPage: (page: number) => void;

method paginationGoToPreviousPage

paginationGoToPreviousPage: () => void;

method paginationIsLastPageFound

paginationIsLastPageFound: () => boolean;

method paginationSetPageSize

paginationSetPageSize: (size: number) => void;

method purgeEnterpriseCache

purgeEnterpriseCache: (route?: string[]) => void;

method purgeInfiniteCache

purgeInfiniteCache: () => void;

method purgeInfinitePageCache

purgeInfinitePageCache: () => void;

method purgeServerSideCache

purgeServerSideCache: (route?: string[]) => void;

method purgeVirtualPageCache

purgeVirtualPageCache: () => void;

method recomputeAggregates

recomputeAggregates: () => void;

method redrawRows

redrawRows: (params?: RedrawRowsParams) => void;

method refreshCells

refreshCells: (params?: RefreshCellsParams) => void;

method refreshClientSideRowModel

refreshClientSideRowModel: (step?: string) => any;

method refreshGroupRows

refreshGroupRows: () => void;

method refreshHeader

refreshHeader: () => void;

method refreshInfiniteCache

refreshInfiniteCache: () => void;

method refreshInfinitePageCache

refreshInfinitePageCache: () => void;

method refreshInMemoryRowModel

refreshInMemoryRowModel: (step?: string) => any;

method refreshRows

refreshRows: (rowNodes: RowNode[]) => void;

method refreshToolPanel

refreshToolPanel: () => void;

method refreshView

refreshView: () => void;

method refreshVirtualPageCache

refreshVirtualPageCache: () => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method registerHeaderRootComp

registerHeaderRootComp: (headerRootComp: HeaderRootComp) => void;

method removeDetailGridInfo

removeDetailGridInfo: (id: string) => void;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

method removeGlobalListener

removeGlobalListener: (listener: Function) => void;

method removeItems

removeItems: (rowNodes: RowNode[], skipRefresh?: boolean) => void;

method resetQuickFilter

resetQuickFilter: () => void;

method resetRowHeights

resetRowHeights: () => void;

method rowDataChanged

rowDataChanged: (rows: any) => void;

method selectAll

selectAll: () => void;

method selectAllFiltered

selectAllFiltered: () => void;

method selectIndex

selectIndex: (index: any, tryMulti: any, suppressEvents: any) => void;

method selectNode

selectNode: (
    node: RowNode,
    tryMulti?: boolean,
    suppressEvents?: boolean
) => void;

method setColumnDefs

setColumnDefs: (
    colDefs: (ColDef | ColGroupDef)[],
    source?: ColumnEventType
) => void;

method setDatasource

setDatasource: (datasource: IDatasource) => void;

method setEnterpriseDatasource

setEnterpriseDatasource: (datasource: IServerSideDatasource) => void;

method setFilterModel

setFilterModel: (model: any) => void;

method setFloatingBottomRowData

setFloatingBottomRowData: (rows: any[]) => void;

method setFloatingFiltersHeight

setFloatingFiltersHeight: (headerHeight: number) => void;

method setFloatingTopRowData

setFloatingTopRowData: (rows: any[]) => void;

method setFocusedCell

setFocusedCell: (
    rowIndex: number,
    colKey: string | Column,
    floating?: string
) => void;

method setFunctionsReadOnly

setFunctionsReadOnly: (readOnly: boolean) => void;

method setGridAutoHeight

setGridAutoHeight: (gridAutoHeight: boolean) => void;

method setGroupHeaderHeight

setGroupHeaderHeight: (headerHeight: number) => void;

method setGroupRemoveLowestSingleChildren

setGroupRemoveLowestSingleChildren: (value: boolean) => void;

method setGroupRemoveSingleChildren

setGroupRemoveSingleChildren: (value: boolean) => void;

method setHeaderHeight

setHeaderHeight: (headerHeight: number) => void;

method setInfiniteRowCount

setInfiniteRowCount: (rowCount: number, maxRowFound?: boolean) => void;

method setPinnedBottomRowData

setPinnedBottomRowData: (rows: any[]) => void;

method setPinnedTopRowData

setPinnedTopRowData: (rows: any[]) => void;

method setPivotGroupHeaderHeight

setPivotGroupHeaderHeight: (headerHeight: number) => void;

method setPivotHeaderHeight

setPivotHeaderHeight: (headerHeight: number) => void;

method setPopupParent

setPopupParent: (ePopupParent: HTMLElement) => void;

method setQuickFilter

setQuickFilter: (newFilter: any) => void;

method setRowData

setRowData: (rowData: any[]) => void;

method setServerSideDatasource

setServerSideDatasource: (datasource: IServerSideDatasource) => void;

method setSortModel

setSortModel: (sortModel: any, source?: ColumnEventType) => void;

method setSuppressClipboardPaste

setSuppressClipboardPaste: (value: boolean) => void;

method setSuppressRowDrag

setSuppressRowDrag: (value: boolean) => void;

method setViewportDatasource

setViewportDatasource: (viewportDatasource: IViewportDatasource) => void;

method setVirtualRowCount

setVirtualRowCount: (rowCount: number, maxRowFound?: boolean) => void;

method showColumnMenuAfterButtonClick

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

method showColumnMenuAfterMouseClick

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

method showLoadingOverlay

showLoadingOverlay: () => void;

method showNoRowsOverlay

showNoRowsOverlay: () => void;

method showToolPanel

showToolPanel: (show: any) => void;

method sizeColumnsToFit

sizeColumnsToFit: () => void;

method softRefreshView

softRefreshView: () => void;

method startEditingCell

startEditingCell: (params: StartEditingCellParams) => void;

method stopEditing

stopEditing: (cancel?: boolean) => void;

method tabToNextCell

tabToNextCell: () => boolean;

method tabToPreviousCell

tabToPreviousCell: () => boolean;

method timeFullRedraw

timeFullRedraw: (count?: number) => void;

method updateRowData

updateRowData: (rowDataTransaction: RowDataTransaction) => RowNodeTransaction;

class GridCell

class GridCell {}

constructor

constructor(gridCellDef: GridCellDef);

property column

column: Column;

property floating

floating: string;

property rowIndex

rowIndex: number;

method createId

createId: () => string;

method equals

equals: (other: GridCell) => boolean;

method getGridCellDef

getGridCellDef: () => GridCellDef;

method getGridRow

getGridRow: () => GridRow;

method toString

toString: () => string;

class GridCore

class GridCore extends Component {}

constructor

constructor();

property loggerFactory

loggerFactory: LoggerFactory;

method destroy

destroy: () => void;

method ensureNodeVisible

ensureNodeVisible: (comparator: any, position?: string) => void;

method getPreferredWidth

getPreferredWidth: () => number;

method getRootGui

getRootGui: () => HTMLElement;

method init

init: () => void;

method isToolPanelShowing

isToolPanelShowing: () => boolean;

method showToolPanel

showToolPanel: (show: any) => void;

class GridOptionsWrapper

class GridOptionsWrapper {}

property PROP_FLOATING_FILTERS_HEIGHT

static PROP_FLOATING_FILTERS_HEIGHT: string;

property PROP_GRID_AUTO_HEIGHT

static PROP_GRID_AUTO_HEIGHT: string;

property PROP_GROUP_HEADER_HEIGHT

static PROP_GROUP_HEADER_HEIGHT: string;

property PROP_GROUP_REMOVE_LOWEST_SINGLE_CHILDREN

static PROP_GROUP_REMOVE_LOWEST_SINGLE_CHILDREN: string;

property PROP_GROUP_REMOVE_SINGLE_CHILDREN

static PROP_GROUP_REMOVE_SINGLE_CHILDREN: string;

property PROP_HEADER_HEIGHT

static PROP_HEADER_HEIGHT: string;

property PROP_PIVOT_GROUP_HEADER_HEIGHT

static PROP_PIVOT_GROUP_HEADER_HEIGHT: string;

property PROP_PIVOT_HEADER_HEIGHT

static PROP_PIVOT_HEADER_HEIGHT: string;

property PROP_POPUP_PARENT

static PROP_POPUP_PARENT: string;

property PROP_SUPPRESS_CLIPBOARD_PASTE

static PROP_SUPPRESS_CLIPBOARD_PASTE: string;

property PROP_SUPPRESS_ROW_DRAG

static PROP_SUPPRESS_ROW_DRAG: string;

method addEventListener

addEventListener: (key: string, listener: Function) => void;

method addLayoutElement

addLayoutElement: (element: HTMLElement) => void;

method checkEventDeprecation

static checkEventDeprecation: (eventName: string) => void;

method doesExternalFilterPass

doesExternalFilterPass: (node: RowNode) => boolean;

method getAggFuncs

getAggFuncs: () => { [key: string]: IAggFunc };

method getAlignedGrids

getAlignedGrids: () => GridOptions[];

method getApi

getApi: () => GridApi;

method getAutoGroupColumnDef

getAutoGroupColumnDef: () => ColDef;

method getAutoSizePadding

getAutoSizePadding: () => number;

method getBatchUpdateWaitMillis

getBatchUpdateWaitMillis: () => number;

method getBusinessKeyForNodeFunc

getBusinessKeyForNodeFunc: () => (node: RowNode) => string;

method getCacheBlockSize

getCacheBlockSize: () => number;

method getCacheOverflowSize

getCacheOverflowSize: () => number;

method getChildCountFunc

getChildCountFunc: () => (dataItem: any) => number;

method getClipboardDeliminator

getClipboardDeliminator: () => string;

method getColResizeDefault

getColResizeDefault: () => string;

method getColumnApi

getColumnApi: () => ColumnApi;

method getColumnDefs

getColumnDefs: () => (ColDef | ColGroupDef)[];

method getColumnTypes

getColumnTypes: () => { [key: string]: ColDef };

method getColWidth

getColWidth: () => number;

method getContext

getContext: () => any;

method getContextMenuItemsFunc

getContextMenuItemsFunc: () => GetContextMenuItems;

method getDataPathFunc

getDataPathFunc: () => (dataItem: any) => string[];

method getDatasource

getDatasource: () => IDatasource;

method getDefaultColDef

getDefaultColDef: () => ColDef;

method getDefaultColGroupDef

getDefaultColGroupDef: () => ColGroupDef;

method getDefaultExportParams

getDefaultExportParams: () => BaseExportParams;

method getDefaultGroupSortComparator

getDefaultGroupSortComparator: () => (nodeA: RowNode, nodeB: RowNode) => number;

method getDocument

getDocument: () => Document;

method getDoesDataFlowerFunc

getDoesDataFlowerFunc: () => (data: any) => boolean;

method getDomData

getDomData: (element: Node, key: string) => any;

method getFloatingFiltersHeight

getFloatingFiltersHeight: () => number;

method getFullWidthCellRendererParams

getFullWidthCellRendererParams: () => any;

method getGroupDefaultExpanded

getGroupDefaultExpanded: () => number;

method getGroupHeaderHeight

getGroupHeaderHeight: () => number;

method getGroupRowAggNodesFunc

getGroupRowAggNodesFunc: () => (nodes: RowNode[]) => any;

method getGroupRowRendererParams

getGroupRowRendererParams: () => any;

method getHeaderHeight

getHeaderHeight: () => number;

method getIcons

getIcons: () => any;

method getInfiniteInitialRowCount

getInfiniteInitialRowCount: () => number;

method getIsFullWidthCellFunc

getIsFullWidthCellFunc: () => (rowNode: RowNode) => boolean;

method getIsRowMasterFunc

getIsRowMasterFunc: () => IsRowMaster;

method getIsRowSelectableFunc

getIsRowSelectableFunc: () => IsRowSelectable;

method getLocaleTextFunc

getLocaleTextFunc: () => Function;

method getMainMenuItemsFunc

getMainMenuItemsFunc: () => GetMainMenuItems;

method getMaxBlocksInCache

getMaxBlocksInCache: () => number;

method getMaxColWidth

getMaxColWidth: () => number;

method getMaxConcurrentDatasourceRequests

getMaxConcurrentDatasourceRequests: () => number;

method getMinColWidth

getMinColWidth: () => number;

method getNavigateToNextCellFunc

getNavigateToNextCellFunc: () => (
    params: NavigateToNextCellParams
) => GridCellDef;

method getNodeChildDetailsFunc

getNodeChildDetailsFunc: () => (dataItem: any) => NodeChildDetails;

method getOverlayLoadingTemplate

getOverlayLoadingTemplate: () => string;

method getOverlayNoRowsTemplate

getOverlayNoRowsTemplate: () => string;

method getPaginationNumberFormatterFunc

getPaginationNumberFormatterFunc: () => (
    params: PaginationNumberFormatterParams
) => string;

method getPaginationPageSize

getPaginationPageSize: () => number;

method getPinnedBottomRowData

getPinnedBottomRowData: () => any[];

method getPinnedTopRowData

getPinnedTopRowData: () => any[];

method getPivotColumnGroupTotals

getPivotColumnGroupTotals: () => string;

method getPivotGroupHeaderHeight

getPivotGroupHeaderHeight: () => number;

method getPivotHeaderHeight

getPivotHeaderHeight: () => number;

method getPivotPanelShow

getPivotPanelShow: () => string;

method getPivotRowTotals

getPivotRowTotals: () => string;

method getPopupParent

getPopupParent: () => HTMLElement;

method getPostProcessPopupFunc

getPostProcessPopupFunc: () => (params: PostProcessPopupParams) => void;

method getPostSortFunc

getPostSortFunc: () => (rowNodes: RowNode[]) => void;

method getProcessCellForClipboardFunc

getProcessCellForClipboardFunc: () => (
    params: ProcessCellForExportParams
) => any;

method getProcessCellFromClipboardFunc

getProcessCellFromClipboardFunc: () => (
    params: ProcessCellForExportParams
) => any;

method getProcessDataFromClipboardFunc

getProcessDataFromClipboardFunc: () => (
    params: ProcessDataFromClipboardParams
) => string[][];

method getProcessHeaderForClipboardFunc

getProcessHeaderForClipboardFunc: () => (
    params: ProcessHeaderForExportParams
) => any;

method getProcessRowPostCreateFunc

getProcessRowPostCreateFunc: () => any;

method getProcessSecondaryColDefFunc

getProcessSecondaryColDefFunc: () => (colDef: ColDef) => void;

method getProcessSecondaryColGroupDefFunc

getProcessSecondaryColGroupDefFunc: () => (colGroupDef: ColGroupDef) => void;

method getQuickFilterText

getQuickFilterText: () => string;

method getRowBuffer

getRowBuffer: () => number;

method getRowClass

getRowClass: () => string | string[];

method getRowClassFunc

getRowClassFunc: () => (params: any) => string | string[];

method getRowData

getRowData: () => any[];

method getRowGroupPanelShow

getRowGroupPanelShow: () => string;

method getRowHeightAsNumber

getRowHeightAsNumber: () => number;

method getRowHeightForNode

getRowHeightForNode: (rowNode: RowNode) => number;

method getRowNodeIdFunc

getRowNodeIdFunc: () => GetRowNodeIdFunc;

method getRowStyle

getRowStyle: () => any;

method getRowStyleFunc

getRowStyleFunc: () => Function;

method getScrollbarWidth

getScrollbarWidth: () => number;

method getSendToClipboardFunc

getSendToClipboardFunc: () => (params: any) => void;

method getServerSideDatasource

getServerSideDatasource: () => IServerSideDatasource;

method getSortingOrder

getSortingOrder: () => string[];

method getTabToNextCellFunc

getTabToNextCellFunc: () => (params: TabToNextCellParams) => GridCellDef;

method getViewportDatasource

getViewportDatasource: () => IViewportDatasource;

method getViewportRowModelBufferSize

getViewportRowModelBufferSize: () => number;

method getViewportRowModelPageSize

getViewportRowModelPageSize: () => number;

method getVirtualItemHeight

getVirtualItemHeight: () => number;

method globalEventHandler

globalEventHandler: (eventName: string, event?: any) => void;

method init

init: () => void;

method isAccentedSort

isAccentedSort: () => boolean;

method isAggregateOnlyChangedColumns

isAggregateOnlyChangedColumns: () => boolean;

method isAllowContextMenuWithControlKey

isAllowContextMenuWithControlKey: () => boolean;

method isAlwaysShowStatusBar

isAlwaysShowStatusBar: () => boolean;

method isAngularCompileFilters

isAngularCompileFilters: () => boolean;

method isAngularCompileHeaders

isAngularCompileHeaders: () => boolean;

method isAngularCompileRows

isAngularCompileRows: () => boolean;

method isAnimateRows

isAnimateRows: () => boolean;

method isCacheQuickFilter

isCacheQuickFilter: () => boolean;

method isContractColumnSelection

isContractColumnSelection: () => boolean;

method isDebug

isDebug: () => boolean;

method isDeltaRowDataMode

isDeltaRowDataMode: () => boolean;

method isDynamicRowHeight

isDynamicRowHeight: () => boolean;

method isEmbedFullWidthRows

isEmbedFullWidthRows: () => boolean;

method isEnableCellChangeFlash

isEnableCellChangeFlash: () => boolean;

method isEnableCellExpressions

isEnableCellExpressions: () => boolean;

method isEnableColResize

isEnableColResize: () => boolean;

method isEnableFilter

isEnableFilter: () => boolean;

method isEnableGroupEdit

isEnableGroupEdit: () => boolean;

method isEnableOldSetFilterModel

isEnableOldSetFilterModel: () => boolean;

method isEnableRangeSelection

isEnableRangeSelection: () => boolean;

method isEnableRtl

isEnableRtl: () => boolean;

method isEnableServerSideFilter

isEnableServerSideFilter: () => boolean;

method isEnableServerSideSorting

isEnableServerSideSorting: () => boolean;

method isEnableSorting

isEnableSorting: () => boolean;

method isEnableStatusBar

isEnableStatusBar: () => boolean;

method isEnsureDomOrder

isEnsureDomOrder: () => boolean;

method isEnterMovesDown

isEnterMovesDown: () => boolean;

method isEnterMovesDownAfterEdit

isEnterMovesDownAfterEdit: () => boolean;

method isEnterprise

isEnterprise: () => boolean;

method isExternalFilterPresent

isExternalFilterPresent: () => boolean;

method isFloatingFilter

isFloatingFilter: () => boolean;

method isFullRowEdit

isFullRowEdit: () => boolean;

method isFunctionsPassive

isFunctionsPassive: () => boolean;

method isFunctionsReadOnly

isFunctionsReadOnly: () => boolean;

method isGridAutoHeight

isGridAutoHeight: () => boolean;

method isGroupHideOpenParents

isGroupHideOpenParents: () => boolean;

method isGroupIncludeFooter

isGroupIncludeFooter: () => boolean;

method isGroupIncludeTotalFooter

isGroupIncludeTotalFooter: () => boolean;

method isGroupMultiAutoColumn

isGroupMultiAutoColumn: () => boolean;

method isGroupRemoveLowestSingleChildren

isGroupRemoveLowestSingleChildren: () => boolean;

method isGroupRemoveSingleChildren

isGroupRemoveSingleChildren: () => boolean;

method isGroupSelectsChildren

isGroupSelectsChildren: () => boolean;

method isGroupSelectsFiltered

isGroupSelectsFiltered: () => boolean;

method isGroupSuppressAutoColumn

isGroupSuppressAutoColumn: () => boolean;

method isGroupSuppressBlankHeader

isGroupSuppressBlankHeader: () => boolean;

method isGroupSuppressRow

isGroupSuppressRow: () => boolean;

method isGroupUseEntireRow

isGroupUseEntireRow: () => boolean;

method isMasterDetail

isMasterDetail: () => boolean;

method isMultiSortKeyCtrl

isMultiSortKeyCtrl: () => boolean;

method isPagination

isPagination: () => boolean;

method isPaginationAutoPageSize

isPaginationAutoPageSize: () => boolean;

method isPivotMode

isPivotMode: () => boolean;

method isPivotTotals

isPivotTotals: () => boolean;

method isPurgeClosedRowNodes

isPurgeClosedRowNodes: () => boolean;

method isRememberGroupStateWhenNewData

isRememberGroupStateWhenNewData: () => boolean;

method isRowDeselection

isRowDeselection: () => boolean;

method isRowDragManaged

isRowDragManaged: () => boolean;

method isRowModelDefault

isRowModelDefault: () => boolean;

method isRowModelInfinite

isRowModelInfinite: () => boolean;

method isRowModelServerSide

isRowModelServerSide: () => boolean;

method isRowModelViewport

isRowModelViewport: () => boolean;

method isRowMultiSelectWithClick

isRowMultiSelectWithClick: () => boolean;

method isRowSelection

isRowSelection: () => boolean;

method isRowSelectionMulti

isRowSelectionMulti: () => boolean;

method isServerSideSortingAlwaysResets

isServerSideSortingAlwaysResets: () => boolean;

method isShowToolPanel

isShowToolPanel: () => boolean;

method isSingleClickEdit

isSingleClickEdit: () => boolean;

method isStopEditingWhenGridLosesFocus

isStopEditingWhenGridLosesFocus: () => boolean;

method isSuppressAggAtRootLevel

isSuppressAggAtRootLevel: () => boolean;

method isSuppressAggFuncInHeader

isSuppressAggFuncInHeader: () => boolean;

method isSuppressAnimationFrame

isSuppressAnimationFrame: () => boolean;

method isSuppressAutoSize

isSuppressAutoSize: () => boolean;

method isSuppressCellSelection

isSuppressCellSelection: () => boolean;

method isSuppressChangeDetection

isSuppressChangeDetection: () => boolean;

method isSuppressClickEdit

isSuppressClickEdit: () => boolean;

method isSuppressClipboardPaste

isSuppressClipboardPaste: () => boolean;

method isSuppressColumnMoveAnimation

isSuppressColumnMoveAnimation: () => boolean;

method isSuppressColumnVirtualisation

isSuppressColumnVirtualisation: () => boolean;

method isSuppressContextMenu

isSuppressContextMenu: () => boolean;

method isSuppressCopyRowsToClipboard

isSuppressCopyRowsToClipboard: () => boolean;

method isSuppressCsvExport

isSuppressCsvExport: () => boolean;

method isSuppressDragLeaveHidesColumns

isSuppressDragLeaveHidesColumns: () => boolean;

method isSuppressEnterpriseResetOnNewColumns

isSuppressEnterpriseResetOnNewColumns: () => boolean;

method isSuppressExcelExport

isSuppressExcelExport: () => boolean;

method isSuppressFieldDotNotation

isSuppressFieldDotNotation: () => boolean;

method isSuppressFocusAfterRefresh

isSuppressFocusAfterRefresh: () => boolean;

method isSuppressHorizontalScroll

isSuppressHorizontalScroll: () => boolean;

method isSuppressLoadingOverlay

isSuppressLoadingOverlay: () => boolean;

method isSuppressMakeColumnVisibleAfterUnGroup

isSuppressMakeColumnVisibleAfterUnGroup: () => boolean;

method isSuppressMenuHide

isSuppressMenuHide: () => boolean;

method isSuppressMiddleClickScrolls

isSuppressMiddleClickScrolls: () => boolean;

method isSuppressMovableColumns

isSuppressMovableColumns: () => boolean;

method isSuppressMultiRangeSelection

isSuppressMultiRangeSelection: () => boolean;

method isSuppressMultiSort

isSuppressMultiSort: () => boolean;

method isSuppressNoRowsOverlay

isSuppressNoRowsOverlay: () => boolean;

method isSuppressPaginationPanel

isSuppressPaginationPanel: () => boolean;

method isSuppressParentsInRowNodes

isSuppressParentsInRowNodes: () => boolean;

method isSuppressPreventDefaultOnMouseWheel

isSuppressPreventDefaultOnMouseWheel: () => boolean;

method isSuppressRowClickSelection

isSuppressRowClickSelection: () => boolean;

method isSuppressRowDrag

isSuppressRowDrag: () => boolean;

method isSuppressRowHoverHighlight

isSuppressRowHoverHighlight: () => boolean;

method isSuppressRowTransform

isSuppressRowTransform: () => boolean;

method isSuppressScrollOnNewData

isSuppressScrollOnNewData: () => boolean;

method isSuppressTabbing

isSuppressTabbing: () => boolean;

method isSuppressTouch

isSuppressTouch: () => boolean;

method isToolPanelSuppressColumnExpandAll

isToolPanelSuppressColumnExpandAll: () => boolean;

method isToolPanelSuppressColumnFilter

isToolPanelSuppressColumnFilter: () => boolean;

method isToolPanelSuppressColumnSelectAll

isToolPanelSuppressColumnSelectAll: () => boolean;

method isToolPanelSuppressPivotMode

isToolPanelSuppressPivotMode: () => boolean;

method isToolPanelSuppressPivots

isToolPanelSuppressPivots: () => boolean;

method isToolPanelSuppressRowGroups

isToolPanelSuppressRowGroups: () => boolean;

method isToolPanelSuppressSideButtons

isToolPanelSuppressSideButtons: () => boolean;

method isToolPanelSuppressValues

isToolPanelSuppressValues: () => boolean;

method isTreeData

isTreeData: () => boolean;

method isUnSortIcon

isUnSortIcon: () => boolean;

method isValueCache

isValueCache: () => boolean;

method isValueCacheNeverExpires

isValueCacheNeverExpires: () => boolean;

method removeEventListener

removeEventListener: (key: string, listener: Function) => void;

method rowClassRules

rowClassRules: () => { [cssClassName: string]: string | Function };

method setDomData

setDomData: (element: Element, key: string, value: any) => any;

method setProperty

setProperty: (key: string, value: any) => void;

method useAsyncEvents

useAsyncEvents: () => boolean;

class GridPanel

class GridPanel extends Component {}

constructor

constructor();

property headerRootComp

headerRootComp: HeaderRootComp;

method addScrollEventListener

addScrollEventListener: (listener: () => void) => void;

method checkViewportAndScrolls

checkViewportAndScrolls: () => void;

method destroy

destroy: () => void;

method ensureColumnVisible

ensureColumnVisible: (key: any) => void;

method ensureIndexVisible

ensureIndexVisible: (index: any, position?: string) => void;

method executeFrame

executeFrame: () => boolean;

method getBodyClientRect

getBodyClientRect: () => ClientRect;

method getBodyContainer

getBodyContainer: () => HTMLElement;

method getBodyHeight

getBodyHeight: () => number;

method getBodyViewportScrollLeft

getBodyViewportScrollLeft: () => number;

method getCenterWidth

getCenterWidth: () => number;

method getDropTargetBodyContainers

getDropTargetBodyContainers: () => HTMLElement[];

method getDropTargetLeftContainers

getDropTargetLeftContainers: () => HTMLElement[];

method getDropTargetRightContainers

getDropTargetRightContainers: () => HTMLElement[];

method getHScrollPosition

getHScrollPosition: () => { left: number; right: number };

method getRowContainers

getRowContainers: () => RowContainerComponents;

method getVScrollPosition

getVScrollPosition: () => { top: number; bottom: number };

method hideOverlay

hideOverlay: () => void;

method horizontallyScrollHeaderCenterAndFloatingCenter

horizontallyScrollHeaderCenterAndFloatingCenter: () => void;

method isHorizontalScrollShowing

isHorizontalScrollShowing: () => boolean;

method onDisplayedColumnsChanged

onDisplayedColumnsChanged: () => void;

method removeScrollEventListener

removeScrollEventListener: (listener: () => void) => void;

method scrollHorizontally

scrollHorizontally: (pixels: number) => number;

method scrollToTop

scrollToTop: () => void;

method scrollVertically

scrollVertically: (pixels: number) => number;

method setBodyAndHeaderHeights

setBodyAndHeaderHeights: () => void;

method setBodyViewportScrollLeft

setBodyViewportScrollLeft: (value: number) => void;

method setColumnMovingCss

setColumnMovingCss: (moving: boolean) => void;

method setHorizontalScrollPosition

setHorizontalScrollPosition: (hScrollPosition: number) => void;

method setVerticalScrollPosition

setVerticalScrollPosition: (vScrollPosition: number) => void;

method showLoadingOverlay

showLoadingOverlay: () => void;

method showNoRowsOverlay

showNoRowsOverlay: () => void;

method sizeColumnsToFit

sizeColumnsToFit: (nextTimeout?: number) => void;

class GridRow

class GridRow {}

constructor

constructor(rowIndex: number, floating: string);

property floating

floating: string;

property rowIndex

rowIndex: number;

method before

before: (otherSelection: GridRow) => boolean;

method equals

equals: (otherSelection: GridRow) => boolean;

method getGridCell

getGridCell: (column: Column) => GridCell;

method isFloatingBottom

isFloatingBottom: () => boolean;

method isFloatingTop

isFloatingTop: () => boolean;

method isNotFloating

isNotFloating: () => boolean;

method toString

toString: () => string;

class GridSerializer

class GridSerializer {}

method recursivelyAddHeaderGroups

recursivelyAddHeaderGroups: <T>(
    displayedGroups: ColumnGroupChild[],
    gridSerializingSession: GridSerializingSession<T>
) => void;

method serialize

serialize: <T>(
    gridSerializingSession: GridSerializingSession<T>,
    params?: ExportParams<T>
) => string;

class GroupCellRenderer

class GroupCellRenderer extends Component implements ICellRenderer {}

constructor

constructor();

method destroy

destroy: () => void;

method init

init: (params: GroupCellRendererParams) => void;

method onCellDblClicked

onCellDblClicked: (mouseEvent: MouseEvent) => void;

method onExpandClicked

onExpandClicked: (mouseEvent: MouseEvent) => void;

method onExpandOrContract

onExpandOrContract: () => void;

method refresh

refresh: () => boolean;

class GroupInstanceIdCreator

class GroupInstanceIdCreator {}

method getInstanceIdForKey

getInstanceIdForKey: (key: string) => number;

class HeaderContainer

class HeaderContainer {}

constructor

constructor(eContainer: HTMLElement, eViewport: HTMLElement, pinned: string);

method destroy

destroy: () => void;

method forEachHeaderElement

forEachHeaderElement: (
    callback: (renderedHeaderElement: Component) => void
) => void;

method refresh

refresh: () => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

class HeaderRootComp

class HeaderRootComp extends Component {}

constructor

constructor();

method destroy

destroy: () => void;

method forEachHeaderElement

forEachHeaderElement: (
    callback: (renderedHeaderElement: Component) => void
) => void;

method refreshHeader

refreshHeader: () => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method setHeight

setHeight: (height: number) => void;

method setHorizontalScroll

setHorizontalScroll: (offset: number) => void;

method setLeftVisible

setLeftVisible: (visible: boolean) => void;

method setRightVisible

setRightVisible: (visible: boolean) => void;

class HeaderRowComp

class HeaderRowComp extends Component {}

constructor

constructor(
    dept: number,
    type: HeaderRowType,
    pinned: string,
    dropTarget: DropTarget
);

method destroy

destroy: () => void;

method forEachHeaderElement

forEachHeaderElement: (callback: (comp: IComponent<any>) => void) => void;

class HorizontalResizeService

class HorizontalResizeService {}

method addResizeBar

addResizeBar: (params: HorizontalResizeParams) => () => void;

class InfiniteRowModel

class InfiniteRowModel extends BeanStub implements IRowModel {}

method destroy

destroy: () => void;

method forEachNode

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

method getBlockState

getBlockState: () => any;

method getCurrentPageHeight

getCurrentPageHeight: () => number;

method getNodesInRangeForSelection

getNodesInRangeForSelection: (
    firstInRange: RowNode,
    lastInRange: RowNode
) => RowNode[];

method getPageFirstRow

getPageFirstRow: () => number;

method getPageLastRow

getPageLastRow: () => number;

method getRow

getRow: (rowIndex: number) => RowNode;

method getRowBounds

getRowBounds: (index: number) => RowBounds;

method getRowCount

getRowCount: () => number;

method getRowIndexAtPixel

getRowIndexAtPixel: (pixel: number) => number;

method getRowNode

getRowNode: (id: string) => RowNode;

method getType

getType: () => string;

method getVirtualRowCount

getVirtualRowCount: () => number;

method init

init: () => void;

method isEmpty

isEmpty: () => boolean;

method isLastRowFound

isLastRowFound: () => boolean;

method isMaxRowFound

isMaxRowFound: () => boolean;

method isRowPresent

isRowPresent: (rowNode: RowNode) => boolean;

method isRowsToRender

isRowsToRender: () => boolean;

method purgeCache

purgeCache: () => void;

method refreshCache

refreshCache: () => void;

method setDatasource

setDatasource: (datasource: IDatasource) => void;

method setVirtualRowCount

setVirtualRowCount: (rowCount: number, maxRowFound?: boolean) => void;

method updateRowData

updateRowData: (transaction: RowDataTransaction) => void;

class LargeTextCellEditor

class LargeTextCellEditor extends Component implements ICellEditorComp {}

constructor

constructor();

method afterGuiAttached

afterGuiAttached: () => void;

method getValue

getValue: () => any;

method init

init: (params: ILargeTextEditorParams) => void;

method isPopup

isPopup: () => boolean;

class Logger

class Logger {}

constructor

constructor(name: string, isLoggingFunc: () => boolean);

method isLogging

isLogging: () => boolean;

method log

log: (message: string) => void;

class LoggerFactory

class LoggerFactory {}

method create

create: (name: string) => Logger;

method isLogging

isLogging: () => boolean;

class MouseEventService

class MouseEventService {}

method getGridCellForEvent

getGridCellForEvent: (event: MouseEvent | KeyboardEvent) => GridCell;

method getRenderedCellForEvent

getRenderedCellForEvent: (event: Event) => CellComp;

method isEventFromThisGrid

isEventFromThisGrid: (event: MouseEvent | KeyboardEvent) => boolean;

class MoveColumnController

class MoveColumnController implements DropListener {}

constructor

constructor(pinned: string, eContainer: HTMLElement);

method getIconName

getIconName: () => string;

method init

init: () => void;

method onDragEnter

onDragEnter: (draggingEvent: DraggingEvent) => void;

method onDragging

onDragging: (draggingEvent: DraggingEvent, fromEnter?: boolean) => void;

method onDragLeave

onDragLeave: (draggingEvent: DraggingEvent) => void;

method onDragStop

onDragStop: () => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method setColumnsPinned

setColumnsPinned: (
    columns: Column[],
    pinned: string,
    source?: ColumnEventType
) => void;

method setColumnsVisible

setColumnsVisible: (
    columns: Column[],
    visible: boolean,
    source?: ColumnEventType
) => void;

class NumberFilter

class NumberFilter extends ScalarBaseFilter<
    number,
    INumberFilterParams,
    SerializedNumberFilter
> {}

property filterNumber

filterNumber: any;

property filterNumberCondition

filterNumberCondition: any;

property filterNumberConditionTo

filterNumberConditionTo: any;

property filterNumberTo

filterNumberTo: any;

property LESS_THAN

static LESS_THAN: string;

method afterGuiAttached

afterGuiAttached: () => void;

method bodyTemplate

bodyTemplate: (type: FilterConditionType) => string;

method comparator

comparator: () => Comparator<number>;

method filterValues

filterValues: (type: FilterConditionType) => number | number[];

method getApplicableFilterTypes

getApplicableFilterTypes: () => string[];

method getFilter

getFilter: (type: FilterConditionType) => any;

method initialiseFilterBodyUi

initialiseFilterBodyUi: (type: FilterConditionType) => void;

method modelFromFloatingFilter

modelFromFloatingFilter: (from: string) => SerializedNumberFilter;

method parse

parse: (model: SerializedNumberFilter, type: FilterConditionType) => void;

method refreshFilterBodyUi

refreshFilterBodyUi: (type: FilterConditionType) => void;

method resetState

resetState: () => void;

method serialize

serialize: (type: FilterConditionType) => SerializedNumberFilter;

method setFilter

setFilter: (filter: any, type: FilterConditionType) => void;

method setFilterTo

setFilterTo: (filter: any, type: FilterConditionType) => void;

method setType

setType: (filterType: string, type: FilterConditionType) => void;

class NumberSequence

class NumberSequence {}

constructor

constructor(initValue?: number, step?: number);

method next

next: () => number;

method peek

peek: () => number;

method skip

skip: (count: number) => void;

class OriginalColumnGroup

class OriginalColumnGroup implements OriginalColumnGroupChild, IEventEmitter {}

constructor

constructor(
    colGroupDef: ColGroupDef,
    groupId: string,
    padding: boolean,
    level: number
);

property EVENT_EXPANDABLE_CHANGED

static EVENT_EXPANDABLE_CHANGED: string;

property EVENT_EXPANDED_CHANGED

static EVENT_EXPANDED_CHANGED: string;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method getChildren

getChildren: () => OriginalColumnGroupChild[];

method getColGroupDef

getColGroupDef: () => ColGroupDef;

method getColumnGroupShow

getColumnGroupShow: () => string;

method getGroupId

getGroupId: () => string;

method getId

getId: () => string;

method getLeafColumns

getLeafColumns: () => Column[];

method getLevel

getLevel: () => number;

method isExpandable

isExpandable: () => boolean;

method isExpanded

isExpanded: () => boolean;

method isPadding

isPadding: () => boolean;

method isVisible

isVisible: () => boolean;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

method setChildren

setChildren: (children: OriginalColumnGroupChild[]) => void;

method setExpandable

setExpandable: () => void;

method setExpanded

setExpanded: (expanded: boolean) => void;

method setupExpandable

setupExpandable: () => void;

class PinnedRowModel

class PinnedRowModel {}

method forEachPinnedBottomRow

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

method forEachPinnedTopRow

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

method getPinnedBottomRow

getPinnedBottomRow: (index: number) => RowNode;

method getPinnedBottomRowCount

getPinnedBottomRowCount: () => number;

method getPinnedBottomRowData

getPinnedBottomRowData: () => RowNode[];

method getPinnedBottomTotalHeight

getPinnedBottomTotalHeight: () => number;

method getPinnedTopRow

getPinnedTopRow: (index: number) => RowNode;

method getPinnedTopRowCount

getPinnedTopRowCount: () => number;

method getPinnedTopRowData

getPinnedTopRowData: () => RowNode[];

method getPinnedTopTotalHeight

getPinnedTopTotalHeight: () => number;

method getRowAtPixel

getRowAtPixel: (pixel: number, floating: string) => number;

method init

init: () => void;

method isEmpty

isEmpty: (floating: string) => boolean;

method isRowsToRender

isRowsToRender: (floating: string) => boolean;

method setPinnedBottomRowData

setPinnedBottomRowData: (rowData: any[]) => void;

method setPinnedTopRowData

setPinnedTopRowData: (rowData: any[]) => void;

class PopupEditorWrapper

class PopupEditorWrapper extends Component implements ICellEditorComp {}

constructor

constructor(cellEditor: ICellEditorComp);

property DOM_KEY_POPUP_EDITOR_WRAPPER

static DOM_KEY_POPUP_EDITOR_WRAPPER: string;

property gridOptionsWrapper

gridOptionsWrapper: GridOptionsWrapper;

method afterGuiAttached

afterGuiAttached: () => void;

method focusIn

focusIn: () => void;

method focusOut

focusOut: () => void;

method getGui

getGui: () => HTMLElement;

method getValue

getValue: () => any;

method init

init: (params: ICellEditorParams) => void;

method isCancelAfterEnd

isCancelAfterEnd: () => boolean;

method isCancelBeforeStart

isCancelBeforeStart: () => boolean;

method isPopup

isPopup: () => boolean;

class PopupSelectCellEditor

class PopupSelectCellEditor extends SelectCellEditor {}

method isPopup

isPopup: () => boolean;

class PopupService

class PopupService {}

method addAsModalPopup

addAsModalPopup: (
    eChild: any,
    closeOnEsc: boolean,
    closedCallback?: () => void,
    click?: MouseEvent | Touch
) => (event?: any) => void;

method positionPopupForMenu

positionPopupForMenu: (params: {
    eventSource: any;
    ePopup: HTMLElement;
}) => void;

method positionPopupOverComponent

positionPopupOverComponent: (params: {
    type: string;
    eventSource: HTMLElement;
    ePopup: HTMLElement;
    column: Column;
    rowNode: RowNode;
    minWidth?: number;
    nudgeX?: number;
    nudgeY?: number;
    keepWithinBounds?: boolean;
}) => void;

method positionPopupUnderComponent

positionPopupUnderComponent: (params: {
    type: string;
    eventSource: HTMLElement;
    ePopup: HTMLElement;
    column?: Column;
    rowNode?: RowNode;
    minWidth?: number;
    nudgeX?: number;
    nudgeY?: number;
    keepWithinBounds?: boolean;
}) => void;

method positionPopupUnderMouseEvent

positionPopupUnderMouseEvent: (params: {
    rowNode?: RowNode;
    column?: Column;
    type: string;
    mouseEvent: MouseEvent | Touch;
    ePopup: HTMLElement;
}) => void;

class PopupTextCellEditor

class PopupTextCellEditor extends TextCellEditor {}

method isPopup

isPopup: () => boolean;

class Promise

class Promise<T> {}

constructor

constructor(callback: ResolveAndRejectCallback<T>);

method all

static all: <T>(toCombine: Promise<T>[]) => Promise<T[]>;

method external

static external: <T>() => ExternalPromise<T>;

method firstOneOnly

firstOneOnly: (func: (result: any) => void) => void;

method map

map: <Z>(adapter: (from: T) => Z) => Promise<Z>;

method resolve

static resolve: <T>(value: T) => Promise<T>;

method resolveNow

resolveNow: <Z>(ifNotResolvedValue: Z, ifResolved: (current: T) => Z) => Z;

method then

then: (func: (result: any) => void) => void;

class RowComp

class RowComp extends Component {}

constructor

constructor(
    parentScope: any,
    bodyContainerComp: RowContainerComponent,
    pinnedLeftContainerComp: RowContainerComponent,
    pinnedRightContainerComp: RowContainerComponent,
    fullWidthContainerComp: RowContainerComponent,
    rowNode: RowNode,
    beans: Beans,
    animateIn: boolean,
    useAnimationFrameForCreate: boolean
);

property DOM_DATA_KEY_RENDERED_ROW

static DOM_DATA_KEY_RENDERED_ROW: string;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method afterFlush

afterFlush: () => void;

method destroy

destroy: (animate?: boolean) => void;

method ensureDomOrder

ensureDomOrder: () => void;

method forEachCellComp

forEachCellComp: (callback: (renderedCell: CellComp) => void) => void;

method getAndClearDelayedDestroyFunctions

getAndClearDelayedDestroyFunctions: () => Function[];

method getAndClearNextVMTurnFunctions

getAndClearNextVMTurnFunctions: () => Function[];

method getBodyRowElement

getBodyRowElement: () => HTMLElement;

method getCellForCol

getCellForCol: (column: Column) => HTMLElement;

method getFullWidthRowElement

getFullWidthRowElement: () => HTMLElement;

method getPinnedLeftRowElement

getPinnedLeftRowElement: () => HTMLElement;

method getPinnedRightRowElement

getPinnedRightRowElement: () => HTMLElement;

method getRenderedCellForColumn

getRenderedCellForColumn: (column: Column) => CellComp;

method getRowNode

getRowNode: () => RowNode;

method init

init: () => void;

method isEditing

isEditing: () => boolean;

method isFullWidth

isFullWidth: () => boolean;

method onMouseEvent

onMouseEvent: (eventName: string, mouseEvent: MouseEvent) => void;

method onRowClick

onRowClick: (mouseEvent: MouseEvent) => void;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

method startRowEditing

startRowEditing: (
    keyPress?: number,
    charPress?: string,
    sourceRenderedCell?: CellComp
) => void;

method stopEditing

stopEditing: (cancel?: boolean) => void;

method stopRowEditing

stopRowEditing: (cancel: boolean) => void;

class RowNode

class RowNode implements IEventEmitter {}

property aggData

aggData: any;

The aggregated data

property allChildrenCount

allChildrenCount: number;

Groups only - Number of children and grand children

property allLeafChildren

allLeafChildren: RowNode[];

All user provided nodes

property canFlower

canFlower: boolean;

Same as master, kept for legacy reasons

property childFlower

childFlower: RowNode;

Same as detailNode, kept for legacy reasons

property childIndex

childIndex: number;

The index of this node in the group

property childrenAfterFilter

childrenAfterFilter: RowNode[];

Groups only - Filtered children of this group

property childrenAfterGroup

childrenAfterGroup: RowNode[];

Groups only - Children of this group

property childrenAfterSort

childrenAfterSort: RowNode[];

Groups only - Sorted children of this group

property childrenCache

childrenCache: RowNodeCache<RowNodeBlock, RowNodeCacheParams>;

Server Side Row Model Only - the children are in an infinite cache

property childrenMapped

childrenMapped: { [key: string]: any };

Children mapped by the pivot columns

property daemon

daemon: boolean;

True if this node is a daemon. This means row is not part of the model. Can happen when then the row is selected and then the user sets a different ID onto the node. The nodes is then representing a different entity, so the selection controller, if the node is selected, takes a copy where daemon=true.

property data

data: any;

The user provided data

property detail

detail: boolean;

True if this row is a detail row, part of master / detail (ie child row of an expanded master row)

property detailGridInfo

detailGridInfo: DetailGridInfo;

If master detail, this contains details about the detail grid

property detailNode

detailNode: RowNode;

If this row is a master row that was expanded, this points to the associated detail row.

property dragging

dragging: boolean;

True if this row is getting dragged

property EVENT_ALL_CHILDREN_COUNT_CHANGED

static EVENT_ALL_CHILDREN_COUNT_CHANGED: string;

property EVENT_CELL_CHANGED

static EVENT_CELL_CHANGED: string;

property EVENT_CHILD_INDEX_CHANGED

static EVENT_CHILD_INDEX_CHANGED: string;

property EVENT_DATA_CHANGED

static EVENT_DATA_CHANGED: string;

property EVENT_DRAGGING_CHANGED

static EVENT_DRAGGING_CHANGED: string;

property EVENT_EXPANDED_CHANGED

static EVENT_EXPANDED_CHANGED: string;

property EVENT_FIRST_CHILD_CHANGED

static EVENT_FIRST_CHILD_CHANGED: string;

property EVENT_HEIGHT_CHANGED

static EVENT_HEIGHT_CHANGED: string;

property EVENT_LAST_CHILD_CHANGED

static EVENT_LAST_CHILD_CHANGED: string;

property EVENT_MOUSE_ENTER

static EVENT_MOUSE_ENTER: string;

property EVENT_MOUSE_LEAVE

static EVENT_MOUSE_LEAVE: string;

property EVENT_ROW_INDEX_CHANGED

static EVENT_ROW_INDEX_CHANGED: string;

property EVENT_ROW_SELECTED

static EVENT_ROW_SELECTED: string;

property EVENT_SELECTABLE_CHANGED

static EVENT_SELECTABLE_CHANGED: string;

property EVENT_TOP_CHANGED

static EVENT_TOP_CHANGED: string;

property EVENT_UI_LEVEL_CHANGED

static EVENT_UI_LEVEL_CHANGED: string;

property expanded

expanded: boolean;

Groups only - True if group is expanded, otherwise false

property field

field: string;

Groups only - The field we are grouping on eg Country

property firstChild

firstChild: boolean;

True if this is the first child in this group

property flower

flower: boolean;

Same as detail, kept for legacy reasons

footer: boolean;

Groups only - True if row is a footer. Footers have group = true and footer = true

property group

group: boolean;

True if this node is a group node (ie has children)

property groupData

groupData: any;

The group data

property id

id: string;

Unique ID for the node. Either provided by the grid, or user can set to match the primary key in the database (or whatever data source is used).

property key

key: any;

Groups only - The key for the group eg Ireland, UK, USA

property lastChild

lastChild: boolean;

True if this is the last child in this group

property leafGroup

leafGroup: boolean;

True if this node is a group and the group is the bottom level in the tree

property level

level: number;

How many levels this node is from the top

property master

master: boolean;

True if this row is a master row, part of master / detail (ie row can be expanded to show detail)

property oldRowTop

oldRowTop: number;

The top pixel for this row last time, makes sense if data set was ordered or filtered, it is used so new rows can animate in from their old position.

property parent

parent: RowNode;

The parent node to this node, or empty if top level

property quickFilterAggregateText

quickFilterAggregateText: string;

If using quick filter, stores a string representation of the row for searching against

property rowGroupColumn

rowGroupColumn: Column;

Groups only - the row group column for this group

property rowGroupIndex

rowGroupIndex: number;

If doing in memory grouping, this is the index of the group column this cell is for. This will always be the same as the level, unless we are collapsing groups ie groupRemoveSingleChildren = true

property rowHeight

rowHeight: number;

The height, in pixels, of this row

property rowIndex

rowIndex: number;

The index of this node in the grid, only valid if node is displayed in the grid, otherwise it should be ignored as old index may be present

property rowPinned

rowPinned: string;

Either 'top' or 'bottom' if row pinned, otherwise undefined or null

property rowTop

rowTop: number;

The top pixel for this row

property selectable

selectable: boolean;

True by default - can be overridden via gridOptions.isRowSelectable(rowNode)

property sibling

sibling: RowNode;

Groups only - If doing footers, reference to the footer node for this group

property stub

stub: boolean;

Used by server side row model, true if this row node is a stub

property uiLevel

uiLevel: number;

How many levels this node is from the top in the UI (different to the level when removing parents)

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method calculateSelectedFromChildren

calculateSelectedFromChildren: () => void;

method clearRowTop

clearRowTop: () => void;

method depthFirstSearch

depthFirstSearch: (callback: (rowNode: RowNode) => void) => void;

method getFirstChildOfFirstChild

getFirstChildOfFirstChild: (rowGroupColumn: Column) => RowNode;

method getRowIndexString

getRowIndexString: () => string;

method hasChildren

hasChildren: () => boolean;

method isEmptyFillerNode

isEmptyFillerNode: () => boolean;

method isExpandable

isExpandable: () => boolean;

method isParentOfNode

isParentOfNode: (potentialParent: RowNode) => boolean;

method isPixelInRange

isPixelInRange: (pixel: number) => boolean;

method isRowPinned

isRowPinned: () => boolean;

method isSelected

isSelected: () => boolean;

method onMouseEnter

onMouseEnter: () => void;

method onMouseLeave

onMouseLeave: () => void;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

method resetQuickFilterAggregateText

resetQuickFilterAggregateText: () => void;

method selectThisNode

selectThisNode: (newValue: boolean) => boolean;

method setAggData

setAggData: (newAggData: any) => void;

method setAllChildrenCount

setAllChildrenCount: (allChildrenCount: number) => void;

method setChildIndex

setChildIndex: (childIndex: number) => void;

method setData

setData: (data: any) => void;

method setDataAndId

setDataAndId: (data: any, id: string) => void;

method setDataValue

setDataValue: (colKey: string | Column, newValue: any) => void;

method setDragging

setDragging: (dragging: boolean) => void;

method setExpanded

setExpanded: (expanded: boolean) => void;

method setFirstChild

setFirstChild: (firstChild: boolean) => void;

method setGroupValue

setGroupValue: (colKey: string | Column, newValue: any) => void;

method setId

setId: (id: string) => void;

method setLastChild

setLastChild: (lastChild: boolean) => void;

method setRowHeight

setRowHeight: (rowHeight: number) => void;

method setRowIndex

setRowIndex: (rowIndex: number) => void;

method setRowSelectable

setRowSelectable: (newVal: boolean) => void;

method setRowTop

setRowTop: (rowTop: number) => void;

method setSelected

setSelected: (
    newValue: boolean,
    clearSelection?: boolean,
    suppressFinishActions?: boolean
) => void;

method setSelectedInitialValue

setSelectedInitialValue: (selected: boolean) => void;

method setSelectedParams

setSelectedParams: (params: SetSelectedParams) => number;

method setUiLevel

setUiLevel: (uiLevel: number) => void;

method updateData

updateData: (data: any) => void;

class RowNodeBlock

abstract class RowNodeBlock extends BeanStub {}

constructor

protected constructor(
    blockNumber: number,
    rowNodeCacheParams: RowNodeCacheParams
);

property EVENT_LOAD_COMPLETE

static EVENT_LOAD_COMPLETE: string;

property rowNodes

rowNodes: RowNode[];

property STATE_DIRTY

static STATE_DIRTY: string;

property STATE_FAILED

static STATE_FAILED: string;

property STATE_LOADED

static STATE_LOADED: string;

property STATE_LOADING

static STATE_LOADING: string;

method createBlankRowNode

protected createBlankRowNode: (rowIndex: number) => RowNode;

method createRowNodes

protected createRowNodes: () => void;

method destroy

destroy: () => void;

method forEachNodeDeep

forEachNodeDeep: (
    callback: (rowNode: RowNode, index: number) => void,
    sequence: NumberSequence,
    rowCount: number
) => void;

method forEachNodeShallow

forEachNodeShallow: (
    callback: (rowNode: RowNode, index: number) => void,
    sequence: NumberSequence,
    rowCount: number
) => void;

method getBlockNumber

getBlockNumber: () => number;

method getEndRow

getEndRow: () => number;

method getLastAccessed

getLastAccessed: () => number;

method getNodeIdPrefix

abstract getNodeIdPrefix: () => string;

method getRow

abstract getRow: (displayIndex: number) => RowNode;

method getRowUsingLocalIndex

getRowUsingLocalIndex: (
    rowIndex: number,
    dontTouchLastAccessed?: boolean
) => RowNode;

method getStartRow

getStartRow: () => number;

method getState

getState: () => string;

method getVersion

getVersion: () => number;

method init

protected init: (beans: RowNodeBlockBeans) => void;

method isAnyNodeOpen

isAnyNodeOpen: (rowCount: number) => boolean;

method load

load: () => void;

method loadFromDatasource

protected abstract loadFromDatasource: () => void;

method pageLoaded

protected pageLoaded: (version: number, rows: any[], lastRow: number) => void;

method pageLoadFailed

protected pageLoadFailed: () => void;

method setBlankRowNode

setBlankRowNode: (rowIndex: number) => RowNode;

method setDataAndId

protected abstract setDataAndId: (
    rowNode: RowNode,
    data: any,
    index: number
) => void;

method setDirty

setDirty: () => void;

method setDirtyAndPurge

setDirtyAndPurge: () => void;

method setNewData

setNewData: (rowIndex: number, dataItem: any) => RowNode;

method setRowNode

setRowNode: (rowIndex: number, rowNode: RowNode) => void;

class RowNodeBlockLoader

class RowNodeBlockLoader {}

constructor

constructor(maxConcurrentRequests: number);

method addBlock

addBlock: (block: RowNodeBlock) => void;

method checkBlockToLoad

checkBlockToLoad: () => void;

method destroy

destroy: () => void;

method getBlockState

getBlockState: () => any;

method loadComplete

loadComplete: () => void;

method removeBlock

removeBlock: (block: RowNodeBlock) => void;

class RowNodeCache

abstract class RowNodeCache<
    T extends RowNodeBlock,
    P extends RowNodeCacheParams
> extends BeanStub {}

constructor

protected constructor(cacheParams: RowNodeCacheParams);

property blocks

blocks: { [blockNumber: string]: T };

property cacheParams

protected cacheParams: RowNodeCacheParams;

property EVENT_CACHE_UPDATED

static EVENT_CACHE_UPDATED: string;

property logger

protected logger: Logger;

method checkBlockToLoad

protected checkBlockToLoad: () => void;

method checkVirtualRowCount

protected checkVirtualRowCount: (block: T, lastRow: any) => void;

method destroy

destroy: () => void;

method destroyBlock

protected destroyBlock: (block: T) => void;

method forEachBlockInOrder

forEachBlockInOrder: (callback: (block: T, id: number) => void) => void;

method forEachBlockInReverseOrder

protected forEachBlockInReverseOrder: (
    callback: (block: T, id: number) => void
) => void;

method forEachNodeDeep

forEachNodeDeep: (
    callback: (rowNode: RowNode, index: number) => void,
    sequence: NumberSequence
) => void;

method getBlock

protected getBlock: (blockId: string | number) => T;

method getBlockIdsSorted

protected getBlockIdsSorted: () => number[];

method getRow

abstract getRow: (rowIndex: number) => RowNode;

method getRowNodesInRange

getRowNodesInRange: (firstInRange: RowNode, lastInRange: RowNode) => RowNode[];

method getVirtualRowCount

getVirtualRowCount: () => number;

method hack_setVirtualRowCount

hack_setVirtualRowCount: (virtualRowCount: number) => void;

method init

protected init: () => void;

method isActive

isActive: () => boolean;

method isMaxRowFound

isMaxRowFound: () => boolean;

method onCacheUpdated

protected onCacheUpdated: () => void;

method onPageLoaded

protected onPageLoaded: (event: any) => void;

method postCreateBlock

protected postCreateBlock: (newBlock: T) => void;

method purgeCache

purgeCache: () => void;

method removeBlockFromCache

protected removeBlockFromCache: (blockToRemove: T) => void;

method setBlock

protected setBlock: (id: number, block: T) => void;

method setVirtualRowCount

setVirtualRowCount: (rowCount: number, maxRowFound?: boolean) => void;

class RowRenderer

class RowRenderer extends BeanStub {}

method addRenderedRowListener

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

method agWire

agWire: (loggerFactory: LoggerFactory) => void;

method destroy

destroy: () => void;

method ensureCellVisible

ensureCellVisible: (gridCell: GridCell) => void;

method flashCells

flashCells: (params?: FlashCellsParams) => void;

method forEachCellComp

forEachCellComp: (callback: (cellComp: CellComp) => void) => void;

method getAllCellsForColumn

getAllCellsForColumn: (column: Column) => HTMLElement[];

method getCellEditorInstances

getCellEditorInstances: (
    params: GetCellRendererInstancesParams
) => ICellEditorComp[];

method getCellRendererInstances

getCellRendererInstances: (
    params: GetCellRendererInstancesParams
) => ICellRendererComp[];

method getEditingCells

getEditingCells: () => GridCellDef[];

method getFirstVirtualRenderedRow

getFirstVirtualRenderedRow: () => number;

method getLastVirtualRenderedRow

getLastVirtualRenderedRow: () => number;

method getRenderedNodes

getRenderedNodes: () => RowNode[];

method navigateToNextCell

navigateToNextCell: (
    event: KeyboardEvent,
    key: number,
    previousCell: GridCell,
    allowUserOverride: boolean
) => void;

method onTabKeyDown

onTabKeyDown: (
    previousRenderedCell: CellComp,
    keyboardEvent: KeyboardEvent
) => void;

method redrawAfterModelUpdate

redrawAfterModelUpdate: (params?: RefreshViewParams) => void;

method redrawAfterScroll

redrawAfterScroll: () => void;

method redrawRows

redrawRows: (rowNodes: RowNode[]) => void;

method refreshCells

refreshCells: (params?: RefreshCellsParams) => void;

method refreshFloatingRowComps

refreshFloatingRowComps: () => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method startEditingCell

startEditingCell: (
    gridCell: GridCell,
    keyPress: number,
    charPress: string
) => void;

method stopEditing

stopEditing: (cancel?: boolean) => void;

method tabToNextCell

tabToNextCell: (backwards: boolean) => boolean;

class ScrollVisibleService

class ScrollVisibleService {}

method isBodyHorizontalScrollShowing

isBodyHorizontalScrollShowing: () => boolean;

method isLeftVerticalScrollShowing

isLeftVerticalScrollShowing: () => boolean;

method isRightVerticalScrollShowing

isRightVerticalScrollShowing: () => boolean;

method setScrollsVisible

setScrollsVisible: (params: SetScrollsVisibleParams) => void;

class SelectableService

class SelectableService {}

method init

init: () => void;

method updateSelectableAfterFiltering

updateSelectableAfterFiltering: (rowNode: RowNode) => void;

method updateSelectableAfterGrouping

updateSelectableAfterGrouping: (rowNode: RowNode) => void;

class SelectCellEditor

class SelectCellEditor extends Component implements ICellEditorComp {}

constructor

constructor();

method afterGuiAttached

afterGuiAttached: () => void;

method focusIn

focusIn: () => void;

method getValue

getValue: () => any;

method init

init: (params: ISelectCellEditorParams) => void;

class SelectionController

class SelectionController {}

method clearOtherNodes

clearOtherNodes: (rowNodeToKeepSelected: RowNode) => number;

method deselectAllRowNodes

deselectAllRowNodes: (justFiltered?: boolean) => void;

method deselectIndex

deselectIndex: (rowIndex: number) => void;

method deselectNode

deselectNode: (rowNode: RowNode) => void;

method getBestCostNodeSelection

getBestCostNodeSelection: () => any;

method getLastSelectedNode

getLastSelectedNode: () => RowNode;

method getNodeForIdIfSelected

getNodeForIdIfSelected: (id: number) => RowNode;

method getSelectedNodes

getSelectedNodes: () => RowNode[];

method getSelectedRows

getSelectedRows: () => any[];

method init

init: () => void;

method isEmpty

isEmpty: () => boolean;

method removeGroupsFromSelection

removeGroupsFromSelection: () => void;

method reset

reset: () => void;

method selectAllRowNodes

selectAllRowNodes: (justFiltered?: boolean) => void;

method selectIndex

selectIndex: (index: any, tryMulti: boolean) => void;

method selectNode

selectNode: (rowNode: RowNode, tryMulti: boolean) => void;

method setLastSelectedNode

setLastSelectedNode: (rowNode: RowNode) => void;

method setRowModel

setRowModel: (rowModel: any) => void;

method syncInRowNode

syncInRowNode: (rowNode: RowNode, oldNode: RowNode) => void;

method updateGroupsFromChildrenSelections

updateGroupsFromChildrenSelections: () => void;

class SetLeftFeature

class SetLeftFeature extends BeanStub {}

constructor

constructor(
    columnOrGroup: ColumnGroupChild,
    eCell: HTMLElement,
    beans: Beans,
    colsSpanning?: Column[]
);

method getColumnOrGroup

getColumnOrGroup: () => ColumnGroupChild;

method init

init: () => void;

method setColsSpanning

setColsSpanning: (colsSpanning: Column[]) => void;

class SortController

class SortController {}

method getColumnsWithSortingOrdered

getColumnsWithSortingOrdered: () => Column[];

method getSortForRowController

getSortForRowController: () => any[];

method getSortModel

getSortModel: () => { colId: string; sort: string }[];

method onSortChanged

onSortChanged: () => void;

method progressSort

progressSort: (
    column: Column,
    multiSort: boolean,
    source?: ColumnEventType
) => void;

method setSortForColumn

setSortForColumn: (
    column: Column,
    sort: string,
    multiSort: boolean,
    source?: ColumnEventType
) => void;

method setSortModel

setSortModel: (sortModel: any, source?: ColumnEventType) => void;

class SortStage

class SortStage {}

method execute

execute: (params: StageExecuteParams) => void;

class StandardMenuFactory

class StandardMenuFactory implements IMenuFactory {}

method hideActiveMenu

hideActiveMenu: () => void;

method isMenuEnabled

isMenuEnabled: (column: Column) => boolean;

method showMenuAfterButtonClick

showMenuAfterButtonClick: (column: Column, eventSource: HTMLElement) => void;

method showMenuAfterMouseEvent

showMenuAfterMouseEvent: (
    column: Column,
    mouseEvent: MouseEvent | Touch
) => void;

method showPopup

showPopup: (
    column: Column,
    positionCallback: (eMenu: HTMLElement) => void
) => void;

class StylingService

class StylingService {}

method processAllCellClasses

processAllCellClasses: (
    colDef: ColDef,
    params: any,
    onApplicableClass: (className: string) => void,
    onNotApplicableClass?: (className: string) => void
) => void;

method processClassRules

processClassRules: (
    classRules: { [cssClassName: string]: string | Function },
    params: CellClassParams,
    onApplicableClass: (className: string) => void,
    onNotApplicableClass?: (className: string) => void
) => void;

method processStaticCellClasses

processStaticCellClasses: (
    colDef: ColDef,
    params: CellClassParams,
    onApplicableClass: (className: string) => void
) => void;

class TabbedLayout

class TabbedLayout {}

constructor

constructor(params: TabbedLayoutParams);

method getGui

getGui: () => HTMLElement;

method getMinWidth

getMinWidth: () => number;

method setAfterAttachedParams

setAfterAttachedParams: (params: any) => void;

method showFirstItem

showFirstItem: () => void;

method showItem

showItem: (tabbedItem: TabbedItem) => void;

class TemplateService

class TemplateService {}

method getTemplate

getTemplate: (url: any, callback: any) => any;

method handleHttpResult

handleHttpResult: (httpResult: any, url: any) => void;

class TextCellEditor

class TextCellEditor extends Component implements ICellEditorComp {}

constructor

constructor();

method afterGuiAttached

afterGuiAttached: () => void;

method focusIn

focusIn: () => void;

method getValue

getValue: () => any;

method init

init: (params: ITextCellEditorParams) => void;

class TextFilter

class TextFilter extends ComparableBaseFilter<
    string,
    ITextFilterParams,
    SerializedTextFilter
> {}

property DEFAULT_COMPARATOR

static DEFAULT_COMPARATOR: TextComparator;

property DEFAULT_FORMATTER

static DEFAULT_FORMATTER: TextFormatter;

property DEFAULT_LOWERCASE_FORMATTER

static DEFAULT_LOWERCASE_FORMATTER: TextFormatter;

method afterGuiAttached

afterGuiAttached: () => void;

method bodyTemplate

bodyTemplate: (type: FilterConditionType) => string;

method customInit

customInit: () => void;

method filterValues

filterValues: (type: FilterConditionType) => string;

method getApplicableFilterTypes

getApplicableFilterTypes: () => string[];

method getDefaultType

getDefaultType: () => string;

method getFilter

getFilter: () => string;

method individualFilterPasses

individualFilterPasses: (
    params: IDoesFilterPassParams,
    type: FilterConditionType
) => boolean;

method initialiseFilterBodyUi

initialiseFilterBodyUi: (type: FilterConditionType) => void;

method modelFromFloatingFilter

modelFromFloatingFilter: (from: string) => SerializedTextFilter;

method parse

parse: (model: SerializedTextFilter, type: FilterConditionType) => void;

method refreshFilterBodyUi

refreshFilterBodyUi: (type: FilterConditionType) => void;

method resetState

resetState: () => void;

method serialize

serialize: (type: FilterConditionType) => SerializedTextFilter;

method setFilter

setFilter: (filter: string, type: FilterConditionType) => void;

method setType

setType: (filterType: string, type: FilterConditionType) => void;

class TouchListener

class TouchListener implements IEventEmitter {}

constructor

constructor(eElement: HTMLElement, preventMouseClick?: boolean);

property EVENT_DOUBLE_TAP

static EVENT_DOUBLE_TAP: string;

property EVENT_LONG_TAP

static EVENT_LONG_TAP: string;

property EVENT_TAP

static EVENT_TAP: string;

method addEventListener

addEventListener: (eventType: string, listener: Function) => void;

method destroy

destroy: () => void;

method removeEventListener

removeEventListener: (eventType: string, listener: Function) => void;

class Utils

class Utils {}

property iconNameClassMap

static iconNameClassMap: { [key: string]: string };

property passiveEvents

static passiveEvents: string[];

property string_similarity

static string_similarity: (str1: string, str2: string) => number;

method addAgGridEventPath

static addAgGridEventPath: (event: Event) => void;

method addChangeListener

static addChangeListener: (
    element: HTMLElement,
    listener: EventListener
) => void;

method addCssClass

static addCssClass: (element: HTMLElement, className: string) => void;

method addOrRemoveCssClass

static addOrRemoveCssClass: (
    element: HTMLElement,
    className: string,
    addOrRemove: boolean
) => void;

method addSafePassiveEventListener

static addSafePassiveEventListener: (
    eElement: HTMLElement,
    event: string,
    listener: (event?: any) => void
) => void;

method addStylesToElement

static addStylesToElement: (eElement: any, styles: any) => void;

method anyExists

static anyExists: (values: any[]) => boolean;

method appendHtml

static appendHtml: (eContainer: HTMLElement, htmlTemplate: string) => void;

method areEventsNear

static areEventsNear: (
    e1: MouseEvent | Touch,
    e2: MouseEvent | Touch,
    pixelCount: number
) => boolean;

method assign

static assign: (object: any, ...sources: any[]) => any;

method callIfPresent

static callIfPresent: (func: Function) => void;

method camelCaseToHumanText

static camelCaseToHumanText: (camelCase: string) => string;

method camelCaseToHyphen

static camelCaseToHyphen: (str: string) => string;

method cleanNumber

static cleanNumber: (value: any) => number;

method cloneObject

static cloneObject: <T>(object: T) => T;

method compareArrays

static compareArrays: (array1: any[], array2: any[]) => boolean;

method containsClass

static containsClass: (element: any, className: string) => boolean;

method copyNodeList

static copyNodeList: (nodeList: NodeList) => Node[];

method createArrayOfNumbers

static createArrayOfNumbers: (first: number, last: number) => number[];

method createEventPath

static createEventPath: (event: Event) => EventTarget[];

method createIcon

static createIcon: (
    iconName: string,
    gridOptionsWrapper: GridOptionsWrapper,
    column: Column
) => HTMLElement;

If icon provided, use this (either a string, or a function callback). if not, then use the default icon from the theme

method createIconNoSpan

static createIconNoSpan: (
    iconName: string,
    gridOptionsWrapper: GridOptionsWrapper,
    column: Column
) => HTMLElement;

method cssStyleObjectToMarkup

static cssStyleObjectToMarkup: (stylesToUse: any) => string;

method debounce

static debounce: (
    func: () => void,
    wait: number,
    immediate?: boolean
) => () => void;

https://stackoverflow.com/questions/24004791/can-someone-explain-the-debounce-function-in-javascript

method defaultComparator

static defaultComparator: (
    valueA: any,
    valueB: any,
    accentedCompare?: boolean
) => number;

method doOnce

static doOnce: (func: () => void, key: string) => void;

method ensureDomOrder

static ensureDomOrder: (
    eContainer: HTMLElement,
    eChild: HTMLElement,
    eChildBefore: HTMLElement
) => void;

method escape

static escape: (toEscape: string) => string;

method every

static every: <T>(items: T[], callback: (item: T) => boolean) => boolean;

method executeAfter

static executeAfter: (funcs: Function[], millis: number) => void;

method executeInAWhile

static executeInAWhile: (funcs: Function[]) => void;

method executeNextVMTurn

static executeNextVMTurn: (funcs: Function[]) => void;

method exists

static exists: (value: any) => boolean;

method existsAndNotEmpty

static existsAndNotEmpty: (value: any[]) => boolean;

method filter

static filter: <T>(array: T[], callback: (item: T) => boolean) => T[];

method find

static find: <T>(
    collection: T[] | { [id: string]: T },
    predicate: string | boolean | ((item: T) => void),
    value?: any
) => T;

method firstExistingValue

static firstExistingValue: <A>(...values: A[]) => A;

method forEach

static forEach: <T>(
    array: T[],
    callback: (item: T, index: number) => void
) => void;

method forEachSnapshotFirst

static forEachSnapshotFirst: (
    list: any[],
    callback: (item: any) => void
) => void;

method formatNumberCommas

static formatNumberCommas: (value: number) => string;

method formatNumberTwoDecimalPlacesAndCommas

static formatNumberTwoDecimalPlacesAndCommas: (value: number) => string;

method formatWidth

static formatWidth: (width: number | string) => string;

method fuzzyCheckStrings

static fuzzyCheckStrings: (
    inputValues: string[],
    validValues: string[],
    allSuggestions: string[]
) => { [p: string]: string[] };

method fuzzySuggestions

static fuzzySuggestions: (
    inputValue: string,
    validValues: string[],
    allSuggestions: string[]
) => string[];

method get

static get: (
    source: { [p: string]: any },
    expression: string,
    defaultValue: any
) => any;

method get_bigrams

static get_bigrams: (from: string) => any[];

method getAllKeysInObjects

static getAllKeysInObjects: (objects: any[]) => string[];

method getBodyHeight

static getBodyHeight: () => number;

method getBodyWidth

static getBodyWidth: () => number;

method getElementAttribute

static getElementAttribute: (element: any, attributeName: string) => string;

method getEventPath

static getEventPath: (event: Event) => EventTarget[];

method getFunctionParameters

static getFunctionParameters: (func: any) => any;

method getMaxDivHeight

static getMaxDivHeight: () => number;

method getNameOfClass

static getNameOfClass: (TheClass: any) => string;

method getScrollbarWidth

static getScrollbarWidth: () => number;

method getScrollLeft

static getScrollLeft: (element: HTMLElement, rtl: boolean) => number;

method getTarget

static getTarget: (event: Event) => Element;

method getValueUsingField

static getValueUsingField: (
    data: any,
    field: string,
    fieldContainsDots: boolean
) => any;

method hyphenToCamelCase

static hyphenToCamelCase: (str: string) => string;

method insertArrayIntoArray

static insertArrayIntoArray: <T>(dest: T[], src: T[], toIndex: number) => void;

method insertIntoArray

static insertIntoArray: <T>(array: T[], object: T, toIndex: number) => void;

method insertTemplateWithDomOrder

static insertTemplateWithDomOrder: (
    eContainer: HTMLElement,
    htmlTemplate: string,
    eChildBefore: HTMLElement
) => HTMLElement;

method insertWithDomOrder

static insertWithDomOrder: (
    eContainer: HTMLElement,
    eChild: HTMLElement,
    eChildBefore: HTMLElement
) => void;

method isBrowserChrome

static isBrowserChrome: () => boolean;

method isBrowserEdge

static isBrowserEdge: () => boolean;

method isBrowserFirefox

static isBrowserFirefox: () => boolean;

method isBrowserIE

static isBrowserIE: () => boolean;

method isBrowserSafari

static isBrowserSafari: () => boolean;

method isElement

static isElement: (o: any) => boolean;

method isElementInEventPath

static isElementInEventPath: (element: HTMLElement, event: Event) => boolean;

method isEventFromPrintableCharacter

static isEventFromPrintableCharacter: (event: KeyboardEvent) => boolean;

method isHorizontalScrollShowing

static isHorizontalScrollShowing: (element: HTMLElement) => boolean;

method isKeyPressed

static isKeyPressed: (event: KeyboardEvent, keyToCheck: number) => boolean;

method isNode

static isNode: (o: any) => boolean;

method isNodeOrElement

static isNodeOrElement: (o: any) => boolean;

method isNumeric

static isNumeric: (value: any) => boolean;

From http://stackoverflow.com/questions/9716468/is-there-any-function-like-isnumeric-in-javascript-to-validate-numbers

method isStopPropagationForAgGrid

static isStopPropagationForAgGrid: (event: Event) => boolean;

method isUserAgentIPad

static isUserAgentIPad: () => boolean;

method isVerticalScrollShowing

static isVerticalScrollShowing: (element: HTMLElement) => boolean;

method isVisible

static isVisible: (element: HTMLElement) => boolean;

method iterateArray

static iterateArray: <T>(
    array: T[],
    callback: (item: T, index: number) => void
) => void;

method iterateNamedNodeMap

static iterateNamedNodeMap: (
    map: NamedNodeMap,
    callback: (key: string, value: string) => void
) => void;

method iterateObject

static iterateObject: <T>(
    object: { [p: string]: T } | T[],
    callback: (key: string, value: T) => void
) => void;

method loadTemplate

static loadTemplate: (template: string) => HTMLElement;

loads the template and returns it as an element. makes up for no simple way in the dom api to load html directly, eg we cannot do this: document.createElement(template)

method makeNull

static makeNull: <T>(value: T) => T;

method map

static map: <TItem, TResult>(
    array: TItem[],
    callback: (item: TItem) => TResult
) => TResult[];

method mapObject

static mapObject: <TResult>(
    object: any,
    callback: (item: any) => TResult
) => TResult[];

method mergeDeep

static mergeDeep: (dest: any, source: any) => void;

method message

static message: (msg: string) => void;

method missing

static missing: (value: any) => boolean;

method missingOrEmpty

static missingOrEmpty: (value: any[] | string) => boolean;

method missingOrEmptyObject

static missingOrEmptyObject: (value: any) => boolean;

method moveInArray

static moveInArray: <T>(array: T[], objectsToMove: T[], toIndex: number) => void;

method normalizeWheel

static normalizeWheel: (event: any) => any;

Mouse wheel (and 2-finger trackpad) support on the web sucks. It is complicated, thus this doc is long and (hopefully) detailed enough to answer your questions.
If you need to react to the mouse wheel in a predictable way, this code is like your bestest friend. * hugs *
As of today, there are 4 DOM event types you can listen to:
'wheel' -- Chrome(31+), FF(17+), IE(9+) 'mousewheel' -- Chrome, IE(6+), Opera, Safari 'MozMousePixelScroll' -- FF(3.5 only!) (2010-2013) -- don't bother! 'DOMMouseScroll' -- FF(0.9.7+) since 2003
So what to do? The is the best:
normalizeWheel.getEventType();
In your event callback, use this code to get sane interpretation of the deltas. This code will return an object with properties:
spinX -- normalized spin speed (use for zoom) - x plane spinY -- " - y plane pixelX -- normalized distance (to pixels) - x plane pixelY -- " - y plane
Wheel values are provided by the browser assuming you are using the wheel to scroll a web page by a number of lines or pixels (or pages). Values can vary significantly on different platforms and browsers, forgetting that you can scroll at different speeds. Some devices (like trackpads) emit more events at smaller increments with fine granularity, and some emit massive jumps with linear speed or acceleration.
This code does its best to normalize the deltas for you:
- spin is trying to normalize how far the wheel was spun (or trackpad dragged). This is super useful for zoom support where you want to throw away the chunky scroll steps on the PC and make those equal to the slow and smooth tiny steps on the Mac. Key data: This code tries to resolve a single slow step on a wheel to 1.
- pixel is normalizing the desired scroll delta in pixel units. You'll get the crazy differences between browsers, but at least it'll be in pixels!
- positive value indicates scrolling DOWN/RIGHT, negative UP/LEFT. This should translate to positive value zooming IN, negative zooming OUT. This matches the newer 'wheel' event.
Why are there spinX, spinY (or pixels)?
- spinX is a 2-finger side drag on the trackpad, and a shift + wheel turn with a mouse. It results in side-scrolling in the browser by default.
- spinY is what you expect -- it's the classic axis of a mouse wheel.
- I dropped spinZ/pixelZ. It is supported by the DOM 3 'wheel' event and probably is by browsers in conjunction with fancy 3D controllers .. but you know.
Implementation info:
Examples of 'wheel' event if you scroll slowly (down) by one step with an average mouse:
OS X + Chrome (mouse) - 4 pixel delta (wheelDelta -120) OS X + Safari (mouse) - N/A pixel delta (wheelDelta -12) OS X + Firefox (mouse) - 0.1 line delta (wheelDelta N/A) Win8 + Chrome (mouse) - 100 pixel delta (wheelDelta -120) Win8 + Firefox (mouse) - 3 line delta (wheelDelta -120)
On the trackpad:
OS X + Chrome (trackpad) - 2 pixel delta (wheelDelta -6) OS X + Firefox (trackpad) - 1 pixel delta (wheelDelta N/A)
On other/older browsers.. it's more complicated as there can be multiple and also missing delta values.
The 'wheel' event is more standard:
http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
The basics is that it includes a unit, deltaMode (pixels, lines, pages), and deltaX, deltaY and deltaZ. Some browsers provide other values to maintain backward compatibility with older events. Those other values help us better normalize spin speed. Example of what the browsers provide:
| event.wheelDelta | event.detail ------------------+------------------+-------------- Safari v5/OS X | -120 | 0 Safari v5/Win7 | -120 | 0 Chrome v17/OS X | -120 | 0 Chrome v17/Win7 | -120 | 0 IE9/Win7 | -120 | undefined Firefox v4/OS X | undefined | 1 Firefox v4/Win7 | undefined | 3

method offsetHeight

static offsetHeight: (element: HTMLElement) => number;

method offsetWidth

static offsetWidth: (element: HTMLElement) => number;

method pad

static pad: (num: number, totalStringSize: number) => string;

method parseYyyyMmDdToDate

static parseYyyyMmDdToDate: (yyyyMmDd: string, separator: string) => Date;

method prependDC

static prependDC: (
    parent: HTMLElement,
    documentFragment: DocumentFragment
) => void;

method pushAll

static pushAll: (target: any[], source: any[]) => void;

method referenceCompare

static referenceCompare: (left: any, right: any) => boolean;

method removeAllChildren

static removeAllChildren: (node: HTMLElement) => void;

method removeAllFromArray

static removeAllFromArray: <T>(array: T[], toRemove: T[]) => void;

method removeCssClass

static removeCssClass: (element: HTMLElement, className: string) => void;

method removeElement

static removeElement: (parent: HTMLElement, cssSelector: string) => void;

method removeFromArray

static removeFromArray: <T>(array: T[], object: T) => void;

method removeFromParent

static removeFromParent: (node: Element) => void;

method removeRepeatsFromArray

static removeRepeatsFromArray: <T>(array: T[], object: T) => void;

method serializeDateToYyyyMmDd

static serializeDateToYyyyMmDd: (date: Date, separator: string) => string;

method setCheckboxState

static setCheckboxState: (eCheckbox: any, state: any) => void;

method setHidden

static setHidden: (element: HTMLElement, hidden: boolean) => void;

method setScrollLeft

static setScrollLeft: (
    element: HTMLElement,
    value: number,
    rtl: boolean
) => void;

method setVisible

static setVisible: (element: HTMLElement, visible: boolean) => void;

method shallowCompare

static shallowCompare: (arr1: any[], arr2: any[]) => boolean;

method sortNumberArray

static sortNumberArray: (numberArray: number[]) => void;

method sortRowNodesByOrder

static sortRowNodesByOrder: (
    rowNodes: RowNode[],
    rowNodeOrder: { [id: string]: number }
) => void;

method stopPropagationForAgGrid

static stopPropagationForAgGrid: (event: Event) => void;

method toStringOrNull

static toStringOrNull: (value: any) => string;

method toStrings

static toStrings: <T>(array: T[]) => string[];

method traverseNodesWithKey

static traverseNodesWithKey: (
    nodes: RowNode[],
    callback: (node: RowNode, key: string) => void
) => void;

method values

static values: <T>(object: { [key: string]: T }) => T[];

class ValueFormatterService

class ValueFormatterService {}

method formatValue

formatValue: (
    column: Column,
    rowNode: RowNode,
    $scope: any,
    value: any
) => string;

class ValueService

class ValueService {}

method getKeyForNode

getKeyForNode: (col: Column, rowNode: RowNode) => any;

method getValue

getValue: (
    column: Column,
    rowNode: RowNode,
    forFilter?: boolean,
    ignoreAggData?: boolean
) => any;

method init

init: () => void;

method setValue

setValue: (rowNode: RowNode, colKey: string | Column, newValue: any) => void;

class VerticalStack

class VerticalStack {}

constructor

constructor();

property childPanels

childPanels: any;

property eGui

eGui: any;

property isLayoutPanel

isLayoutPanel: any;

method addPanel

addPanel: (panel: any, height: any) => void;

method doLayout

doLayout: () => void;

method getGui

getGui: () => any;

class XmlFactory

class XmlFactory {}

method createXml

createXml: (
    xmlElement: XmlElement,
    booleanTransformer?: (currentValue: boolean) => string
) => string;

Interfaces

interface AddRangeSelectionParams

interface AddRangeSelectionParams {}

property columnEnd

columnEnd: string | Column;

property columnStart

columnStart: string | Column;

property floatingEnd

floatingEnd: string;

property floatingStart

floatingStart: string;

property rowEnd

rowEnd: number;

property rowStart

rowStart: number;

interface AgEvent

interface AgEvent {}

property type

type: string;

interface AgGridEvent

interface AgGridEvent extends AgEvent {}

property api

api: GridApi;

property columnApi

columnApi: ColumnApi;

interface BodyHeightChangedEvent

interface BodyHeightChangedEvent extends AgGridEvent {}

interface BodyScrollEvent

interface BodyScrollEvent extends AgGridEvent {}

property direction

direction: string;

property left

left: number;

property top

top: number;

interface CellClickedEvent

interface CellClickedEvent extends CellEvent {}

interface CellContextMenuEvent

interface CellContextMenuEvent extends CellEvent {}

interface CellDoubleClickedEvent

interface CellDoubleClickedEvent extends CellEvent {}

interface CellEditingStartedEvent

interface CellEditingStartedEvent extends CellEvent {}

interface CellEditingStoppedEvent

interface CellEditingStoppedEvent extends CellEvent {}

interface CellEvent

interface CellEvent extends RowEvent {}

------------

property colDef

colDef: ColDef;

property column

column: Column;

property value

value: any;

interface CellFocusedEvent

interface CellFocusedEvent extends AgGridEvent {}

property column

column: Column;

property floating

floating: string;

property forceBrowserFocus

forceBrowserFocus: boolean;

property rowIndex

rowIndex: number;

property rowPinned

rowPinned: string;

interface CellMouseDownEvent

interface CellMouseDownEvent extends CellEvent {}

interface CellMouseOutEvent

interface CellMouseOutEvent extends CellEvent {}

interface CellMouseOverEvent

interface CellMouseOverEvent extends CellEvent {}

interface CellValueChangedEvent

interface CellValueChangedEvent extends CellEvent {}

property newValue

newValue: any;

property oldValue

oldValue: any;

interface ColDef

interface ColDef extends AbstractColDef {}

************************************************************** Don't forget to update ComponentUtil if changing this class. PLEASE!* **************************************************************

property aggFunc

aggFunc?: string | IAggFunc;

Name of function to use for aggregation. One of [sum,min,max,first,last] or a function.

property allowedAggFuncs

allowedAggFuncs?: string[];

Agg funcs allowed on this column. If missing, all installed agg funcs are allowed. Can be eg ['sum','avg']. This will restrict what the GUI allows to select only.

property autoHeight

autoHeight?: boolean;

True if this column should stretch rows height to fit contents

property cellClass

cellClass?:
    | string
    | string[]
    | ((cellClassParams: CellClassParams) => string | string[]);

Class to use for the cell. Can be string, array of strings, or function.

property cellClassRules

cellClassRules?: {
    [cssClassName: string]: Function | string;
};

Rules for applying css classes

property cellEditor

cellEditor?:
    | {
          new (): ICellEditorComp;
      }
    | string;

Cell editor

property cellEditorFramework

cellEditorFramework?: any;

property cellEditorParams

cellEditorParams?: any;

property cellEditorSelector

cellEditorSelector?: (params: DynamicComponentParams) => DynamicComponentDef;

property cellRenderer

cellRenderer?:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

A function for rendering a cell.

property cellRendererFramework

cellRendererFramework?: any;

property cellRendererParams

cellRendererParams?: any;

property cellRendererSelector

cellRendererSelector?: (params: DynamicComponentParams) => DynamicComponentDef;

property cellStyle

cellStyle?: {} | ((params: any) => {});

An object of css values. Or a function returning an object of css values.

property checkboxSelection

checkboxSelection?: boolean | ((params: any) => boolean);

Set to true to render a selection checkbox in the column.

property colId

colId?: string;

The unique ID to give the column. This is optional. If missing, the ID will default to the field. If both field and colId are missing, a unique ID will be generated. This ID is used to identify the column in the API for sorting, filtering etc.

property colSpan

colSpan?: (params: ColSpanParams) => number;

property comparator

comparator?: (
    valueA: any,
    valueB: any,
    nodeA?: RowNode,
    nodeB?: RowNode,
    isInverted?: boolean
) => number;

Comparator function for custom sorting.

property editable

editable?: boolean | IsColumnFunc;

Set to true if this col is editable, otherwise false. Can also be a function to have different rows editable.

property enableCellChangeFlash

enableCellChangeFlash?: boolean;

If true, grid will flash cell after cell is refreshed

property enablePivot

enablePivot?: boolean;

If true, GUI will allow adding this columns as a pivot

property enableRowGroup

enableRowGroup?: boolean;

If true, GUI will allow adding this columns as a row group

property enableValue

enableValue?: boolean;

If true, GUI will allow adding this columns as a value

property equals

equals?: (valueA: any, valueB: any) => boolean;

Comparator for values, used by renderer to know if values have changed. Cells who's values have not changed don't get refreshed.

property field

field?: string;

The field of the row to get the cells data from

property filter

filter?:
    | string
    | {
          new (): IFilterComp;
      };

one of the built in filter names: [set, number, text], or a filter function

property filterFramework

filterFramework?: any;

property filterParams

filterParams?: any;

The filter params are specific to each filter!

property filterValueGetter

filterValueGetter?: ((params: ValueGetterParams) => any) | string;

Expression or function to get the cells value for filtering.

property floatingFilterComponent

floatingFilterComponent?: {
    new (): IFloatingFilterComp<any, any, any>;
};

The custom header component to be used for rendering the floating filter. If none specified the default ag-Grid is used*

property floatingFilterComponentFramework

floatingFilterComponentFramework?: {
    new (): any;
};

property floatingFilterComponentParams

floatingFilterComponentParams?: any;

property getQuickFilterText

getQuickFilterText?: (params: GetQuickFilterTextParams) => string;

To create the quick filter text for this column, if toString is not good enough on the value.

property headerCheckboxSelection

headerCheckboxSelection?: boolean | ((params: any) => boolean);

If true, a 'select all' checkbox will be put into the header

property headerCheckboxSelectionFilteredOnly

headerCheckboxSelectionFilteredOnly?: boolean;

If true, the header checkbox selection will work on filtered items

property headerComponent

headerComponent?:
    | string
    | {
          new (): any;
      };

The custom header component to be used for rendering the component header. If none specified the default ag-Grid is used*

property headerComponentFramework

headerComponentFramework?: {
    new (): any;
};

The custom header component to be used for rendering the component header in the hosting framework (ie: React/Angular). If none specified the default ag-Grid is used*

property headerComponentParams

headerComponentParams?: any;

The custom header component parameters*

property hide

hide?: boolean;

Set to true for this column to be hidden. Naturally you might think, it would make more sense to call this field 'visible' and mark it false to hide, however we want all default values to be false and we want columns to be visible by default.

property icons

icons?: {
    [key: string]: string;
};

Icons for this column. Leave blank to use default.

property keyCreator

keyCreator?: Function;

Function to return the key for a value - use this if the value is an object (not a primitive type) and you want to a) group by this field or b) use set filter on this field.

property lockPinned

lockPinned?: boolean;

Set to true to block the user pinning the column, the column can only be pinned via definitions or API

property lockPosition

lockPosition?: boolean;

Set to true to make sure this column is always first. Other columns, if movable, cannot move before this column.

property lockVisible

lockVisible?: boolean;

Set to true to block the user showing / hiding the column, the column can only be shown / hidden via definitions or API

property maxWidth

maxWidth?: number;

Max width, in pixels, of the cell

property menuTabs

menuTabs?: string[];

The menu tabs to show, and in which order, the valid values for this property are: filterMenuTab, generalMenuTab, columnsMenuTab *

property minWidth

minWidth?: number;

Min width, in pixels, of the cell

property newValueHandler

newValueHandler?: (params: any) => boolean;

Callbacks for editing. See editing section for further details. Return true if the update was successful, or false if not. If false, then skips the UI refresh and no events are emitted. Return false if the values are the same (ie no update).

property onCellClicked

onCellClicked?: (event: CellClickedEvent) => void;

Function callback, gets called when a cell is clicked.

property onCellContextMenu

onCellContextMenu?: (event: CellContextMenuEvent) => void;

Function callback, gets called when a cell is right clicked.

property onCellDoubleClicked

onCellDoubleClicked?: (event: CellDoubleClickedEvent) => void;

Function callback, gets called when a cell is double clicked.

property onCellValueChanged

onCellValueChanged?: Function;

Callbacks for editing.See editing section for further details.

property pinned

pinned?: boolean | string;

Whether this column is pinned or not.

property pinnedRowCellRenderer

pinnedRowCellRenderer?:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

A function for rendering a pinned row cell.

property pinnedRowCellRendererFramework

pinnedRowCellRendererFramework?: any;

property pinnedRowCellRendererParams

pinnedRowCellRendererParams?: any;

property pinnedRowValueFormatter

pinnedRowValueFormatter?: (params: ValueFormatterParams) => string | string;

A function to format a pinned row value, should return a string. Not used for CSV export or copy to clipboard, only for UI cell rendering.

property pivot

pivot?: boolean;

property pivotComparator

pivotComparator?: (valueA: string, valueB: string) => number;

Comparator for ordering the pivot columns

property pivotIndex

pivotIndex?: number;

To pivot by this column by default, either provide an index (eg pivotIndex=1), or set pivot=true.

property pivotTotalColumnIds

pivotTotalColumnIds?: string[];

Never set this, it is used internally by grid when doing in-grid pivoting

property pivotValueColumn

pivotValueColumn?: Column;

Never set this, it is used internally by grid when doing in-grid pivoting

property refData

refData?: {
    [key: string]: string;
};

property rowDrag

rowDrag?: boolean | ((params: any) => boolean);

property rowGroup

rowGroup?: boolean;

property rowGroupIndex

rowGroupIndex?: number;

To group by this column by default, either provide an index (eg rowGroupIndex=1), or set rowGroup=true.

property rowSpan

rowSpan?: (params: RowSpanParams) => number;

property showRowGroup

showRowGroup?: string | boolean;

Set to true to have the grid place the values for the group into the cell, or put the name of a grouped column to just show that group.

property singleClickEdit

singleClickEdit?: boolean;

If true, this cell will be in editing mode after first click.

property sort

sort?: string;

If sorting by default, set it here. Set to 'asc' or 'desc'

property sortedAt

sortedAt?: number;

If sorting more than one column by default, the milliseconds when this column was sorted, so we know what order to sort the columns in.

property sortingOrder

sortingOrder?: string[];

The sort order, provide an array with any of the following in any order ['asc','desc',null]

property suppressAutoSize

suppressAutoSize?: boolean;

Set to true if you do not want this column to be auto-resizable by double clicking it's edge.

property suppressCellFlash

suppressCellFlash?: boolean;

Set to true to not flash this column for value changes

property suppressFilter

suppressFilter?: boolean;

Set to true to not allow filter on this column

property suppressKeyboardEvent

suppressKeyboardEvent?: (params: SuppressKeyboardEventParams) => boolean;

property suppressMenu

suppressMenu?: boolean;

Set to true if no menu should be shown for this column header.

property suppressMovable

suppressMovable?: boolean;

Set to true to not allow moving this column via dragging it's header

property suppressNavigable

suppressNavigable?: boolean | IsColumnFunc;

Set to tru if this col should not be navigable with the tab key. Can also be a function to have different rows editable.

property suppressPaste

suppressPaste?: boolean | IsColumnFunc;

Set to true if this col should not be allowed take new values from teh clipboard .

property suppressResize

suppressResize?: boolean;

Set to true if you do not want this column to be resizable by dragging it's edge.

property suppressSizeToFit

suppressSizeToFit?: boolean;

Set to true if you want this columns width to be fixed during 'size to fit' operation.

property suppressSorting

suppressSorting?: boolean;

Set to true if no sorting should be done for this column.

property template

template?: string;

Cell template to use for cell. Useful for AngularJS cells.

property templateUrl

templateUrl?: string;

Cell template URL to load template from to use for cell. Useful for AngularJS cells.

property tooltip

tooltip?: (params: TooltipParams) => string;

The function used to calculate the tooltip of the object, tooltipField takes precedence

property tooltipField

tooltipField?: string;

The field where we get the tooltip on the object

property type

type?: string | string[];

A comma separated string or array of strings containing ColumnType keys which can be used as a template for a column. This helps to reduce duplication of properties when you have a lot of common column properties.

property unSortIcon

unSortIcon?: boolean;

Set to true if you want the unsorted icon to be shown when no sort is applied to this column.

property valueFormatter

valueFormatter?: (params: ValueFormatterParams) => string | string;

A function to format a value, should return a string. Not used for CSV export or copy to clipboard, only for UI cell rendering.

property valueGetter

valueGetter?: ((params: ValueGetterParams) => any) | string;

Expression or function to get the cells value.

property valueParser

valueParser?: (params: ValueParserParams) => any | string;

Gets called after editing, converts the value in the cell.

property valueSetter

valueSetter?: ((params: ValueSetterParams) => boolean) | string;

If not using a field, then this puts the value into the cell

property width

width?: number;

Initial width, in pixels, of the cell

interface ColGroupDef

interface ColGroupDef extends AbstractColDef {}

property children

children: (ColDef | ColGroupDef)[];

Columns in this group

property groupId

groupId?: string;

Group ID

property headerGroupComponent

headerGroupComponent?:
    | string
    | {
          new (): IHeaderGroupComp;
      };

The custom header group component to be used for rendering the component header. If none specified the default ag-Grid is used*

property headerGroupComponentFramework

headerGroupComponentFramework?: {
    new (): any;
};

The custom header group component to be used for rendering the component header in the hosting framework (ie: React/Angular). If none specified the default ag-Grid is used*

property headerGroupComponentParams

headerGroupComponentParams?: any;

The custom header group component to be used for rendering the component header. If none specified the default ag-Grid is used*

property marryChildren

marryChildren?: boolean;

If true, group cannot be broken up by column moving, child columns will always appear side by side, however you can rearrange child columns within the group

property openByDefault

openByDefault?: boolean;

Open by Default

interface ColumnAggFuncChangeRequestEvent

interface ColumnAggFuncChangeRequestEvent extends ColumnRequestEvent {}

property aggFunc

aggFunc: any;

interface ColumnEvent

interface ColumnEvent extends AgGridEvent {}

property column

column: Column;

property columns

columns: Column[];

property source

source: ColumnEventType;

interface ColumnEverythingChangedEvent

interface ColumnEverythingChangedEvent extends AgGridEvent {}

property source

source: string;

interface ColumnGroupOpenedEvent

interface ColumnGroupOpenedEvent extends AgGridEvent {}

property columnGroup

columnGroup: OriginalColumnGroup;

interface ColumnHoverChangedEvent

interface ColumnHoverChangedEvent extends AgGridEvent {}

interface ColumnMovedEvent

interface ColumnMovedEvent extends ColumnEvent {}

property toIndex

toIndex: number;

interface ColumnPinnedEvent

interface ColumnPinnedEvent extends ColumnEvent {}

property pinned

pinned: string;

interface ColumnPivotChangedEvent

interface ColumnPivotChangedEvent extends ColumnEvent {}

interface ColumnPivotChangeRequestEvent

interface ColumnPivotChangeRequestEvent extends ColumnRequestEvent {}

interface ColumnPivotModeChangedEvent

interface ColumnPivotModeChangedEvent extends AgGridEvent {}

interface ColumnRequestEvent

interface ColumnRequestEvent extends AgGridEvent {}

property columns

columns: Column[];

interface ColumnResizedEvent

interface ColumnResizedEvent extends ColumnEvent {}

property finished

finished: boolean;

interface ColumnRowGroupChangedEvent

interface ColumnRowGroupChangedEvent extends ColumnEvent {}

interface ColumnRowGroupChangeRequestEvent

interface ColumnRowGroupChangeRequestEvent extends ColumnRequestEvent {}

interface ColumnValueChangedEvent

interface ColumnValueChangedEvent extends ColumnEvent {}

interface ColumnValueChangeRequestEvent

interface ColumnValueChangeRequestEvent extends ColumnRequestEvent {}

interface ColumnVisibleEvent

interface ColumnVisibleEvent extends ColumnEvent {}

property visible

visible: boolean;

interface ColumnVO

interface ColumnVO {}

property aggFunc

aggFunc: string;

property displayName

displayName: string;

property field

field: string;

property id

id: string;

interface ComponentStateChangedEvent

interface ComponentStateChangedEvent extends AgGridEvent {}

interface CsvExportParams

interface CsvExportParams extends ExportParams<string> {}

property columnSeparator

columnSeparator?: string;

interface DetailGridInfo

interface DetailGridInfo {}

property api

api: GridApi;

property columnApi

columnApi: ColumnApi;

property id

id: string;

interface DisplayedColumnsChangedEvent

interface DisplayedColumnsChangedEvent extends AgGridEvent {}

interface DisplayedColumnsWidthChangedEvent

interface DisplayedColumnsWidthChangedEvent extends AgGridEvent {}

interface DraggingEvent

interface DraggingEvent {}

property dragItem

dragItem: DragItem;

property dragSource

dragSource: DragSource;

property event

event: MouseEvent;

property fromNudge

fromNudge: boolean;

property hDirection

hDirection: HDirection;

property vDirection

vDirection: VDirection;

property x

x: number;

property y

y: number;

interface DragSource

interface DragSource {}

property dragItemCallback

dragItemCallback: () => DragItem;

If eElement is dragged, then the dragItem is the object that gets passed around.

property dragItemName

dragItemName: string;

This name appears in the ghost icon when dragging

property dragSourceDropTarget

dragSourceDropTarget?: DropTarget;

The drop target associated with this dragSource. So when dragging starts, this target does not get onDragEnter event.

property dragStarted

dragStarted?: () => void;

Callback for drag started

property dragStartPixels

dragStartPixels?: number;

After how many pixels of dragging should the drag operation start. Default is 4px.

property dragStopped

dragStopped?: () => void;

Callback for drag stopped

property eElement

eElement: HTMLElement;

Element which, when dragged, will kick off the DnD process

property type

type: DragSourceType;

So the drop target knows what type of event it is, useful for columns, we we re-ordering or moving dropping from toolPanel

interface DragStartedEvent

interface DragStartedEvent extends DragEvent {}

interface DragStoppedEvent

interface DragStoppedEvent extends DragEvent {}

interface DropTarget

interface DropTarget {}

method getContainer

getContainer: () => HTMLElement;

The main container that will get the drop.

method getIconName

getIconName: () => string;

Icon to show when drag is over

method getSecondaryContainers

getSecondaryContainers: () => HTMLElement[];

If any secondary containers. For example when moving columns in ag-Grid, we listen for drops in the header as well as the body (main rows and pinned rows) of the grid.

method isInterestedIn

isInterestedIn: (type: DragSourceType) => boolean;

method onDragEnter

onDragEnter: (params: DraggingEvent) => void;

Callback for when drag enters

method onDragging

onDragging: (params: DraggingEvent) => void;

Callback for when dragging

method onDragLeave

onDragLeave: (params: DraggingEvent) => void;

Callback for when drag leaves

method onDragStop

onDragStop: (params: DraggingEvent) => void;

Callback for when drag stops

interface ExcelBorder

interface ExcelBorder {}

property color

color: string;

property lineStyle

lineStyle: string;

property weight

weight: number;

interface ExcelCell

interface ExcelCell {}

property data

data: ExcelData;

property mergeAcross

mergeAcross?: number;

property styleId

styleId: string;

interface ExcelColumn

interface ExcelColumn {}

property width

width: number;

interface ExcelData

interface ExcelData {}

property type

type: ExcelDataType;

property value

value: string;

interface ExcelExportParams

interface ExcelExportParams extends ExportParams<ExcelCell[][]> {}

property sheetName

sheetName?: string;

property suppressTextAsCDATA

suppressTextAsCDATA?: boolean;

interface ExcelRow

interface ExcelRow {}

property cells

cells: ExcelCell[];

interface ExcelStyle

interface ExcelStyle {}

property alignment

alignment?: ExcelAlignment;

property borders

borders?: ExcelBorders;

property dataType

dataType?: string;

property font

font?: ExcelFont;

property id

id?: string;

property interior

interior?: ExcelInterior;

property name

name?: string;

property numberFormat

numberFormat?: ExcelNumberFormat;

property protection

protection?: ExcelProtection;

interface ExcelWorksheet

interface ExcelWorksheet {}

property name

name: string;

property table

table: ExcelTable;

interface ExportParams

interface ExportParams<T> extends BaseExportParams {}

property customFooter

customFooter?: T;

property customHeader

customHeader?: T;

interface ExternalPromise

interface ExternalPromise<T> {}

property promise

promise: Promise<T>;

property resolve

resolve: (value: T) => void;

interface FilterChangedEvent

interface FilterChangedEvent extends AgGridEvent {}

interface FilterModifiedEvent

interface FilterModifiedEvent extends AgGridEvent {}

interface FilterWrapper {}

column: Column;

compiledElement: any;

filterPromise: Promise<IFilterComp>;

guiPromise: ExternalPromise<HTMLElement>;

scope: any;

interface FlashCellsEvent

interface FlashCellsEvent extends AgGridEvent {}

property cells

cells: any;

interface FrameworkComponentWrapper

interface FrameworkComponentWrapper {}

B the business interface (ie IHeader) A the agGridComponent interface (ie IHeaderComp). The final object acceptable by ag-grid

method wrap

wrap: <A extends IComponent<any>>(
    frameworkComponent: { new (): any },
    methodList: string[],
    optionalMethodList?: string[],
    componentName?: string
) => A;

interface GetContextMenuItems

interface GetContextMenuItems {}

call signature

(params: GetContextMenuItemsParams): (string | MenuItemDef)[];

interface GetContextMenuItemsParams

interface GetContextMenuItemsParams {}

property api

api: GridApi;

property column

column: Column;

property columnApi

columnApi: ColumnApi;

property context

context: any;

property defaultItems

defaultItems: string[];

property node

node: RowNode;

property value

value: any;

interface GetDataPath

interface GetDataPath {}

call signature

(data: any): string[];

interface GetMainMenuItems

interface GetMainMenuItems {}

call signature

(params: GetMainMenuItemsParams): (string | MenuItemDef)[];

interface GetMainMenuItemsParams

interface GetMainMenuItemsParams {}

property api

api: GridApi;

property column

column: Column;

property columnApi

columnApi: ColumnApi;

property context

context: any;

property defaultItems

defaultItems: string[];

interface GetNodeChildDetails

interface GetNodeChildDetails {}

call signature

(dataItem: any): NodeChildDetails;

interface GetQuickFilterTextParams

interface GetQuickFilterTextParams {}

property colDef

colDef: ColDef;

property column

column: Column;

property data

data: any;

property node

node: RowNode;

property value

value: any;

interface GetRowNodeIdFunc

interface GetRowNodeIdFunc {}

call signature

(data: any): string;

interface GridCellDef

interface GridCellDef {}

property column

column: Column;

property floating

floating: string;

property rowIndex

rowIndex: number;

interface GridColumnsChangedEvent

interface GridColumnsChangedEvent extends AgGridEvent {}

interface GridOptions

interface GridOptions {}

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

property accentedSort

accentedSort?: boolean;

property aggFuncs

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

property aggregateOnlyChangedColumns

aggregateOnlyChangedColumns?: boolean;

property alignedGrids

alignedGrids?: GridOptions[];

property allowContextMenuWithControlKey

allowContextMenuWithControlKey?: boolean;

property alwaysShowStatusBar

alwaysShowStatusBar?: boolean;

property angularCompileFilters

angularCompileFilters?: boolean;

property angularCompileHeaders

angularCompileHeaders?: boolean;

property angularCompileRows

angularCompileRows?: boolean;

property animateRows

animateRows?: boolean;

property api

api?: GridApi;

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

property autoGroupColumnDef

autoGroupColumnDef?: ColDef;

property autoSizePadding

autoSizePadding?: number;

property batchUpdateWaitMillis

batchUpdateWaitMillis?: number;

property cacheBlockSize

cacheBlockSize?: number;

property cacheOverflowSize

cacheOverflowSize?: number;

property cacheQuickFilter

cacheQuickFilter?: boolean;

property clipboardDeliminator

clipboardDeliminator?: string;

property colResizeDefault

colResizeDefault?: string;

property columnApi

columnApi?: ColumnApi;

property columnDefs

columnDefs?: (ColDef | ColGroupDef)[];

property columnTypes

columnTypes?: {
    [key: string]: ColDef;
};

property colWidth

colWidth?: number;

property components

components?: {
    [p: string]: AgGridRegisteredComponentInput<IComponent<any>>;
};

property context

context?: any;

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

property contractColumnSelection

contractColumnSelection?: boolean;

property datasource

datasource?: IDatasource;

property dateComponent

dateComponent?: {
    new (): IDateComp;
};

property dateComponentFramework

dateComponentFramework?: any;

property debug

debug?: boolean;

property defaultColDef

defaultColDef?: ColDef;

property defaultColGroupDef

defaultColGroupDef?: ColGroupDef;

property defaultExportParams

defaultExportParams?: CsvExportParams;

property defaultGroupSortComparator

defaultGroupSortComparator?: (nodeA: RowNode, nodeB: RowNode) => number;

property deltaRowDataMode

deltaRowDataMode?: boolean;

property detailCellRenderer

detailCellRenderer?:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

property detailCellRendererFramework

detailCellRendererFramework?: any;

property detailCellRendererParams

detailCellRendererParams?: any;

property detailRowHeight

detailRowHeight?: number;

property domLayout

domLayout?: string;

property editType

editType?: string;

property embedFullWidthRows

embedFullWidthRows?: boolean;

property enableCellChangeFlash

enableCellChangeFlash?: boolean;

property enableCellExpressions

enableCellExpressions?: boolean;

property enableColResize

enableColResize?: boolean;

property enableFilter

enableFilter?: boolean;

property enableGroupEdit

enableGroupEdit?: boolean;

property enableOldSetFilterModel

enableOldSetFilterModel?: boolean;

property enableRangeSelection

enableRangeSelection?: boolean;

property enableRtl

enableRtl?: boolean;

property enableServerSideFilter

enableServerSideFilter?: boolean;

property enableServerSideSorting

enableServerSideSorting?: boolean;

property enableSorting

enableSorting?: boolean;

property enableStatusBar

enableStatusBar?: boolean;

property ensureDomOrder

ensureDomOrder?: boolean;

property enterMovesDown

enterMovesDown?: boolean;

property enterMovesDownAfterEdit

enterMovesDownAfterEdit?: boolean;

property excelStyles

excelStyles?: any[];

property floatingFilter

floatingFilter?: boolean;

property floatingFiltersHeight

floatingFiltersHeight?: number;

property forPrint

forPrint?: boolean;

property frameworkComponents

frameworkComponents?: {
    [p: string]: {
        new (): any;
    };
};

property fullWidthCellRenderer

fullWidthCellRenderer?:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

property fullWidthCellRendererFramework

fullWidthCellRendererFramework?: any;

property fullWidthCellRendererParams

fullWidthCellRendererParams?: any;

property functionsPassive

functionsPassive?: boolean;

property functionsReadOnly

functionsReadOnly?: boolean;

property getContextMenuItems

getContextMenuItems?: GetContextMenuItems;

property getDataPath

getDataPath?: GetDataPath;

property getDocument

getDocument?: () => Document;

property getMainMenuItems

getMainMenuItems?: GetMainMenuItems;

property getNodeChildDetails

getNodeChildDetails?: GetNodeChildDetails;

property getRowClass

getRowClass?: (params: any) => string | string[];

property getRowHeight

getRowHeight?: Function;

property getRowNodeId

getRowNodeId?: GetRowNodeIdFunc;

property getRowStyle

getRowStyle?: Function;

property gridAutoHeight

gridAutoHeight?: boolean;

property groupColumnDef

groupColumnDef?: ColDef;

property groupDefaultExpanded

groupDefaultExpanded?: number;

property groupHeaderHeight

groupHeaderHeight?: number;

property groupHideOpenParents

groupHideOpenParents?: boolean;

property groupIncludeFooter

groupIncludeFooter?: boolean;

property groupIncludeTotalFooter

groupIncludeTotalFooter?: boolean;

property groupMultiAutoColumn

groupMultiAutoColumn?: boolean;

property groupRemoveLowestSingleChildren

groupRemoveLowestSingleChildren?: boolean;

property groupRemoveSingleChildren

groupRemoveSingleChildren?: boolean;

property groupRowInnerRenderer

groupRowInnerRenderer?:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

property groupRowInnerRendererFramework

groupRowInnerRendererFramework?: any;

property groupRowRenderer

groupRowRenderer?:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

property groupRowRendererFramework

groupRowRendererFramework?: any;

property groupRowRendererParams

groupRowRendererParams?: any;

property groupSelectsChildren

groupSelectsChildren?: boolean;

property groupSelectsFiltered

groupSelectsFiltered?: boolean;

property groupSuppressAutoColumn

groupSuppressAutoColumn?: boolean;

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

property groupSuppressBlankHeader

groupSuppressBlankHeader?: boolean;

property groupSuppressRow

groupSuppressRow?: boolean;

property groupUseEntireRow

groupUseEntireRow?: boolean;

property headerHeight

headerHeight?: number;

property icons

icons?: any;

property infiniteInitialRowCount

infiniteInitialRowCount?: number;

property isRowMaster

isRowMaster?: IsRowMaster;

property isRowSelectable

isRowSelectable?: IsRowSelectable;

property loadingOverlayComponent

loadingOverlayComponent?:
    | {
          new (): ILoadingOverlayComp;
      }
    | string;

property loadingOverlayComponentFramework

loadingOverlayComponentFramework?: any;

property localeText

localeText?: any;

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

property localeTextFunc

localeTextFunc?: Function;

property masterDetail

masterDetail?: boolean;

property maxBlocksInCache

maxBlocksInCache?: number;

property maxColWidth

maxColWidth?: number;

property maxConcurrentDatasourceRequests

maxConcurrentDatasourceRequests?: number;

property minColWidth

minColWidth?: number;

property multiSortKey

multiSortKey?: string;

property navigateToNextCell

navigateToNextCell?: (params: NavigateToNextCellParams) => GridCellDef;

property noRowsOverlayComponent

noRowsOverlayComponent?:
    | {
          new (): INoRowsOverlayComp;
      }
    | string;

property noRowsOverlayComponentFramework

noRowsOverlayComponentFramework?: any;

property overlayLoadingTemplate

overlayLoadingTemplate?: string;

property overlayNoRowsTemplate

overlayNoRowsTemplate?: string;

property pagination

pagination?: boolean;

property paginationAutoPageSize

paginationAutoPageSize?: boolean;

property paginationNumberFormatter

paginationNumberFormatter?: (params: PaginationNumberFormatterParams) => string;

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

property paginationPageSize

paginationPageSize?: number;

property paginationStartPage

paginationStartPage?: number;

property pinnedBottomRowData

pinnedBottomRowData?: any[];

property pinnedTopRowData

pinnedTopRowData?: any[];

property pivotColumnGroupTotals

pivotColumnGroupTotals?: string;

property pivotGroupHeaderHeight

pivotGroupHeaderHeight?: number;

property pivotHeaderHeight

pivotHeaderHeight?: number;

property pivotMode

pivotMode?: boolean;

property pivotPanelShow

pivotPanelShow?: string;

property pivotRowTotals

pivotRowTotals?: string;

property pivotTotals

pivotTotals?: boolean;

property popupParent

popupParent?: HTMLElement;

property postProcessPopup

postProcessPopup?: (params: PostProcessPopupParams) => void;

property processDataFromClipboard

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

property purgeClosedRowNodes

purgeClosedRowNodes?: boolean;

property quickFilterText

quickFilterText?: string;

property rememberGroupStateWhenNewData

rememberGroupStateWhenNewData?: boolean;

property rowBuffer

rowBuffer?: number;

property rowClass

rowClass?: string | string[];

property rowClassRules

rowClassRules?: {
    [cssClassName: string]: Function | string;
};

property rowData

rowData?: any[];

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

property rowDeselection

rowDeselection?: boolean;

property rowDragManaged

rowDragManaged?: boolean;

************************************************************** Don't forget to update ComponentUtil if changing this class. PLEASE!* **************************************************************

property rowGroupPanelShow

rowGroupPanelShow?: string;

property rowHeight

rowHeight?: number;

property rowModelType

rowModelType?: string;

property rowMultiSelectWithClick

rowMultiSelectWithClick?: boolean;

property rowSelection

rowSelection?: string;

property rowStyle

rowStyle?: any;

property scrollbarWidth

scrollbarWidth?: number;

property sendToClipboard

sendToClipboard?: (params: any) => void;

property serverSideDatasource

serverSideDatasource?: IServerSideDatasource;

property serverSideSortingAlwaysResets

serverSideSortingAlwaysResets?: boolean;

property showToolPanel

showToolPanel?: boolean;

property singleClickEdit

singleClickEdit?: boolean;

property slaveGrids

slaveGrids?: GridOptions[];

property sortingOrder

sortingOrder?: string[];

property stopEditingWhenGridLosesFocus

stopEditingWhenGridLosesFocus?: boolean;

property suppressAggAtRootLevel

suppressAggAtRootLevel?: boolean;

property suppressAggFuncInHeader

suppressAggFuncInHeader?: boolean;

property suppressAnimationFrame

suppressAnimationFrame?: boolean;

property suppressAsyncEvents

suppressAsyncEvents?: boolean;

property suppressAutoSize

suppressAutoSize?: boolean;

property suppressCellSelection

suppressCellSelection?: boolean;

property suppressChangeDetection

suppressChangeDetection?: boolean;

property suppressClickEdit

suppressClickEdit?: boolean;

property suppressClipboardPaste

suppressClipboardPaste?: boolean;

property suppressColumnMoveAnimation

suppressColumnMoveAnimation?: boolean;

property suppressColumnVirtualisation

suppressColumnVirtualisation?: boolean;

property suppressContextMenu

suppressContextMenu?: boolean;

property suppressCopyRowsToClipboard

suppressCopyRowsToClipboard?: boolean;

property suppressCsvExport

suppressCsvExport?: boolean;

property suppressDragLeaveHidesColumns

suppressDragLeaveHidesColumns?: boolean;

property suppressEnterpriseResetOnNewColumns

suppressEnterpriseResetOnNewColumns?: boolean;

property suppressExcelExport

suppressExcelExport?: boolean;

property suppressFieldDotNotation

suppressFieldDotNotation?: boolean;

property suppressFocusAfterRefresh

suppressFocusAfterRefresh?: boolean;

property suppressHorizontalScroll

suppressHorizontalScroll?: boolean;

property suppressLoadingOverlay

suppressLoadingOverlay?: boolean;

property suppressMakeColumnVisibleAfterUnGroup

suppressMakeColumnVisibleAfterUnGroup?: boolean;

property suppressMenuHide

suppressMenuHide?: boolean;

property suppressMiddleClickScrolls

suppressMiddleClickScrolls?: boolean;

property suppressMovableColumns

suppressMovableColumns?: boolean;

property suppressMultiRangeSelection

suppressMultiRangeSelection?: boolean;

property suppressMultiSort

suppressMultiSort?: boolean;

property suppressNoRowsOverlay

suppressNoRowsOverlay?: boolean;

property suppressPaginationPanel

suppressPaginationPanel?: boolean;

property suppressParentsInRowNodes

suppressParentsInRowNodes?: boolean;

property suppressPreventDefaultOnMouseWheel

suppressPreventDefaultOnMouseWheel?: boolean;

property suppressPropertyNamesCheck

suppressPropertyNamesCheck?: boolean;

property suppressRowClickSelection

suppressRowClickSelection?: boolean;

property suppressRowDrag

suppressRowDrag?: boolean;

property suppressRowHoverHighlight

suppressRowHoverHighlight?: boolean;

property suppressRowTransform

suppressRowTransform?: boolean;

property suppressScrollOnNewData

suppressScrollOnNewData?: boolean;

property suppressTabbing

suppressTabbing?: boolean;

property suppressTouch

suppressTouch?: boolean;

property tabToNextCell

tabToNextCell?: (params: TabToNextCellParams) => GridCellDef;

property toolPanelSuppressColumnExpandAll

toolPanelSuppressColumnExpandAll?: boolean;

property toolPanelSuppressColumnFilter

toolPanelSuppressColumnFilter?: boolean;

property toolPanelSuppressColumnSelectAll

toolPanelSuppressColumnSelectAll?: boolean;

property toolPanelSuppressPivotMode

toolPanelSuppressPivotMode?: boolean;

property toolPanelSuppressPivots

toolPanelSuppressPivots?: boolean;

property toolPanelSuppressRowGroups

toolPanelSuppressRowGroups?: boolean;

property toolPanelSuppressSideButtons

toolPanelSuppressSideButtons?: boolean;

property toolPanelSuppressValues

toolPanelSuppressValues?: boolean;

property treeData

treeData?: boolean;

property unSortIcon

unSortIcon?: boolean;

property valueCache

valueCache?: boolean;

property valueCacheNeverExpires

valueCacheNeverExpires?: boolean;

property viewportDatasource

viewportDatasource?: IViewportDatasource;

property viewportRowModelBufferSize

viewportRowModelBufferSize?: number;

property viewportRowModelPageSize

viewportRowModelPageSize?: number;

method doesDataFlower

doesDataFlower: (dataItem: any) => boolean;

method doesExternalFilterPass

doesExternalFilterPass: (node: RowNode) => boolean;

method getBusinessKeyForNode

getBusinessKeyForNode: (node: RowNode) => string;

method getChildCount

getChildCount: (dataItem: any) => number;

method groupRowAggNodes

groupRowAggNodes: (nodes: RowNode[]) => any;

method isExternalFilterPresent

isExternalFilterPresent: () => boolean;

method isFullWidthCell

isFullWidthCell: (rowNode: RowNode) => boolean;

method onBodyScroll

onBodyScroll: (event: BodyScrollEvent) => void;

method onCellClicked

onCellClicked: (event: CellClickedEvent) => void;

method onCellContextMenu

onCellContextMenu: (event: CellContextMenuEvent) => void;

method onCellDoubleClicked

onCellDoubleClicked: (event: CellDoubleClickedEvent) => void;

method onCellEditingStarted

onCellEditingStarted: (event: CellEditingStartedEvent) => void;

method onCellEditingStopped

onCellEditingStopped: (event: CellEditingStoppedEvent) => void;

method onCellFocused

onCellFocused: (event: CellFocusedEvent) => void;

method onCellMouseDown

onCellMouseDown: (event: CellMouseDownEvent) => void;

method onCellMouseOut

onCellMouseOut: (event: CellMouseOutEvent) => void;

method onCellMouseOver

onCellMouseOver: (event: CellMouseOverEvent) => void;

method onCellValueChanged

onCellValueChanged: (event: CellValueChangedEvent) => void;

method onColumnAggFuncChangeRequest

onColumnAggFuncChangeRequest: (event: ColumnAggFuncChangeRequestEvent) => void;

method onColumnEverythingChanged

onColumnEverythingChanged: (event: ColumnEverythingChangedEvent) => void;

************************************************************** Don't forget to update ComponentUtil if changing this class. * **************************************************************

method onColumnGroupOpened

onColumnGroupOpened: (event: ColumnGroupOpenedEvent) => void;

method onColumnMoved

onColumnMoved: (event: ColumnMovedEvent) => void;

method onColumnPinned

onColumnPinned: (event: ColumnPinnedEvent) => void;

method onColumnPivotChanged

onColumnPivotChanged: (event: ColumnPivotChangedEvent) => void;

method onColumnPivotChangeRequest

onColumnPivotChangeRequest: (event: ColumnPivotChangeRequestEvent) => void;

method onColumnPivotModeChanged

onColumnPivotModeChanged: (event: ColumnPivotModeChangedEvent) => void;

method onColumnResized

onColumnResized: (event: ColumnResizedEvent) => void;

method onColumnRowGroupChanged

onColumnRowGroupChanged: (event: ColumnRowGroupChangedEvent) => void;

method onColumnRowGroupChangeRequest

onColumnRowGroupChangeRequest: (event: ColumnRowGroupChangeRequestEvent) => void;

method onColumnValueChanged

onColumnValueChanged: (event: ColumnValueChangedEvent) => void;

method onColumnValueChangeRequest

onColumnValueChangeRequest: (event: ColumnValueChangeRequestEvent) => void;

method onColumnVisible

onColumnVisible: (event: ColumnVisibleEvent) => void;

method onDisplayedColumnsChanged

onDisplayedColumnsChanged: (event: DisplayedColumnsChangedEvent) => void;

method onDragStarted

onDragStarted: (event: DragStartedEvent) => void;

method onDragStopped

onDragStopped: (event: DragStoppedEvent) => void;

method onFilterChanged

onFilterChanged: (event: FilterChangedEvent) => void;

method onFilterModified

onFilterModified: (event: FilterModifiedEvent) => void;

method onGridColumnsChanged

onGridColumnsChanged: (event: GridColumnsChangedEvent) => void;

method onGridReady

onGridReady: (event: GridReadyEvent) => void;

method onGridSizeChanged

onGridSizeChanged: (event: any) => void;

method onModelUpdated

onModelUpdated: (event: ModelUpdatedEvent) => void;

method onNewColumnsLoaded

onNewColumnsLoaded: (event: NewColumnsLoadedEvent) => void;

method onPaginationChanged

onPaginationChanged: (event: PaginationChangedEvent) => void;

method onPasteEnd

onPasteEnd: (event: PasteEndEvent) => void;

method onPasteStart

onPasteStart: (event: PasteStartEvent) => void;

method onPinnedRowDataChanged

onPinnedRowDataChanged: (event: PinnedRowDataChangedEvent) => void;

method onRangeSelectionChanged

onRangeSelectionChanged: (event: RangeSelectionChangedEvent) => void;

method onRowClicked

onRowClicked: (event: RowClickedEvent) => void;

method onRowDataChanged

onRowDataChanged: (event: RowDataChangedEvent) => void;

method onRowDataUpdated

onRowDataUpdated: (event: RowDataUpdatedEvent) => void;

method onRowDoubleClicked

onRowDoubleClicked: (event: RowDoubleClickedEvent) => void;

method onRowDragEnd

onRowDragEnd: (event: RowDragEvent) => void;

method onRowDragEnter

onRowDragEnter: (event: RowDragEvent) => void;

method onRowDragLeave

onRowDragLeave: (event: RowDragEvent) => void;

method onRowDragMove

onRowDragMove: (event: RowDragEvent) => void;

method onRowEditingStarted

onRowEditingStarted: (event: RowEditingStartedEvent) => void;

method onRowEditingStopped

onRowEditingStopped: (event: RowEditingStoppedEvent) => void;

method onRowGroupOpened

onRowGroupOpened: (event: RowGroupOpenedEvent) => void;

method onRowSelected

onRowSelected: (event: RowSelectedEvent) => void;

method onRowValueChanged

onRowValueChanged: (event: RowValueChangedEvent) => void;

method onSelectionChanged

onSelectionChanged: (event: SelectionChangedEvent) => void;

method onSortChanged

onSortChanged: (event: SortChangedEvent) => void;

method onViewportChanged

onViewportChanged: (event: ViewportChangedEvent) => void;

method onVirtualColumnsChanged

onVirtualColumnsChanged: (event: VirtualColumnsChangedEvent) => void;

method onVirtualRowRemoved

onVirtualRowRemoved: (event: VirtualRowRemovedEvent) => void;

method postSort

postSort: (nodes: RowNode[]) => void;

method processCellForClipboard

processCellForClipboard: (params: ProcessCellForExportParams) => any;

method processCellFromClipboard

processCellFromClipboard: (params: ProcessCellForExportParams) => any;

method processHeaderForClipboard

processHeaderForClipboard: (params: ProcessHeaderForExportParams) => any;

method processRowPostCreate

processRowPostCreate: (params: ProcessRowParams) => void;

method processSecondaryColDef

processSecondaryColDef: (colDef: ColDef) => void;

method processSecondaryColGroupDef

processSecondaryColGroupDef: (colGroupDef: ColGroupDef) => void;

interface GridParams

interface GridParams {}

property $compile

$compile?: any;

property $scope

$scope?: any;

property frameworkFactory

frameworkFactory?: IFrameworkFactory;

property globalEventListener

globalEventListener?: Function;

property quickFilterOnScope

quickFilterOnScope?: any;

property seedBeanInstances

seedBeanInstances?: {
    [key: string]: any;
};

interface GridReadyEvent

interface GridReadyEvent extends AgGridEvent {}

interface GridSizeChangedEvent

interface GridSizeChangedEvent extends AgGridEvent {}

property clientHeight

clientHeight: number;

property clientWidth

clientWidth: number;

interface IAfterGuiAttachedParams

interface IAfterGuiAttachedParams {}

property hidePopup

hidePopup: () => void;

interface IAggFunc

interface IAggFunc {}

call signature

(input: any[]): any;

interface IAggFuncService

interface IAggFuncService {}

method addAggFunc

addAggFunc: (key: string, aggFunc: IAggFunc) => void;

method addAggFuncs

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

method clear

clear: () => void;

method getDefaultAggFunc

getDefaultAggFunc: (column: Column) => string;

interface ICellEditor

interface ICellEditor {}

method focusIn

focusIn: () => void;

If doing full line edit, then gets called when focus should be put into the editor

method focusOut

focusOut: () => void;

If doing full line edit, then gets called when focus is leaving the editor

method getValue

getValue: () => any;

Return the final value - called by the grid once after editing is complete

method isCancelAfterEnd

isCancelAfterEnd: () => 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.

method isCancelBeforeStart

isCancelBeforeStart: () => boolean;

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.

method isPopup

isPopup: () => boolean;

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

interface ICellEditorComp

interface ICellEditorComp extends ICellEditor, IComponent<ICellEditorParams> {}

interface ICellEditorParams

interface ICellEditorParams {}

property $scope

$scope: any;

property api

api: GridApi;

property cellStartedEdit

cellStartedEdit: boolean;

property charPress

charPress: string;

property column

column: Column;

property columnApi

columnApi: ColumnApi;

property context

context: any;

property eGridCell

eGridCell: HTMLElement;

property formatValue

formatValue: (value: any) => any;

property keyPress

keyPress: number;

property node

node: RowNode;

property onKeyDown

onKeyDown: (event: KeyboardEvent) => void;

property parseValue

parseValue: (value: any) => any;

property rowIndex

rowIndex: number;

property stopEditing

stopEditing: (suppressNavigateAfterEdit?: boolean) => void;

property value

value: any;

interface ICellRenderer

interface ICellRenderer {}

method refresh

refresh: (params: any) => boolean;

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.

interface ICellRendererComp

interface ICellRendererComp extends ICellRenderer, IComponent<ICellRendererParams> {}

interface ICellRendererFunc

interface ICellRendererFunc {}

call signature

(params: any): HTMLElement | string;

interface ICellRendererParams

interface ICellRendererParams {}

property $scope

$scope: any;

property addRenderedRowListener

addRenderedRowListener: (eventType: string, listener: Function) => void;

property api

api: GridApi;

property colDef

colDef: ColDef;

property column

column: Column;

property columnApi

columnApi: ColumnApi;

property context

context: any;

property data

data: any;

property eGridCell

eGridCell: HTMLElement;

property eParentOfValue

eParentOfValue: HTMLElement;

property formatValue

formatValue: (value: any) => any;

property getValue

getValue: () => any;

property node

node: RowNode;

property refreshCell

refreshCell: () => void;

property rowIndex

rowIndex: number;

property setValue

setValue: (value: any) => void;

property value

value: any;

property valueFormatted

valueFormatted: any;

interface IClipboardService

interface IClipboardService {}

method copyRangeDown

copyRangeDown: () => void;

method copySelectedRangeToClipboard

copySelectedRangeToClipboard: (includeHeader?: boolean) => void;

method copySelectedRowsToClipboard

copySelectedRowsToClipboard: (
    includeHeader?: boolean,
    columnKeys?: (string | Column)[]
) => void;

method copyToClipboard

copyToClipboard: (includeHeader?: boolean) => void;

method pasteFromClipboard

pasteFromClipboard: () => void;

interface ICompFactory

interface ICompFactory {}

method create

create: () => Component;

interface IComponent

interface IComponent<T> {}

method afterGuiAttached

afterGuiAttached: (params?: IAfterGuiAttachedParams) => void;

A hook to perform any necessary operation just after the gui for this component has been renderer in the screen. If the filter popup is closed and reopened, this method is called each time the filter 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.

method destroy

destroy: () => void;

Gets called once by grid after editing is finished - if your editor needs to do any cleanup, do it here

method getGui

getGui: () => HTMLElement;

Return the DOM element of your editor, this is what the grid puts into the DOM

method init

init: (params: T) => Promise<void> | void;

The init(params) method is called on the filter once. See below for details on the parameters.

interface IContextMenuFactory

interface IContextMenuFactory {}

method hideActiveMenu

hideActiveMenu: () => void;

method showMenu

showMenu: (
    node: RowNode,
    column: Column,
    value: any,
    mouseEvent: MouseEvent | Touch
) => void;

interface IDatasource

interface IDatasource {}

Datasource used by both PaginationController and InfiniteRowModel

property rowCount

rowCount?: number;

If you know up front how many rows are in the dataset, set it here. Otherwise leave blank.

method destroy

destroy: () => void;

method getRows

getRows: (params: IGetRowsParams) => void;

Callback the grid calls that you implement to fetch rows from the server. See below for params.

interface IDate

interface IDate {}

method getDate

getDate: () => Date;

Returns the current date represented by this editor

method setDate

setDate: (date: Date) => void;

Sets the date represented by this component

interface IDateComp

interface IDateComp extends IComponent<IDateParams>, IDate {}

interface IDateParams

interface IDateParams {}

property filterParams

filterParams: IDateFilterParams;

property onDateChanged

onDateChanged: () => void;

Method for component to tell ag-Grid that the date has changed.

interface IDoesFilterPassParams

interface IDoesFilterPassParams {}

property data

data: any;

property node

node: RowNode;

interface IExcelCreator

interface IExcelCreator {}

method exportDataAsExcel

exportDataAsExcel: (params?: ExcelExportParams) => void;

method getDataAsExcelXml

getDataAsExcelXml: (params?: ExcelExportParams) => string;

interface IFilter

interface IFilter {}

method doesFilterPass

doesFilterPass: (params: IDoesFilterPassParams) => 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).

method getFrameworkComponentInstance

getFrameworkComponentInstance: () => any;

If using React or Angular 2, returns the underlying component instance, so you can call methods on it if you want.

method getModel

getModel: () => any;

Gets the filter state for storing

method getModelAsString

getModelAsString: (model: any) => string;

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.

method isFilterActive

isFilterActive: () => boolean;

This is used to show the filter icon in the header. If true, the filter icon will be shown.

method onFloatingFilterChanged

onFloatingFilterChanged: (change: any) => void;

Optional method used by ag-Grid when rendering floating filters.
If this method IS NOT IMPLEMENTED, when the floating filter changes, ag-Grid will automatically call IFilterParams.filterChangedCallback, triggering the filtering of the data based on the changes from the floating filter. For the simplest cases this is enough.
IF IT IS IMPLEMENTED. ag-Grid will delegate into this method the responsibility of calling IFilterParams.filterChangedCallback. This is useful if additional logic is necessary, for instance ag-Grid uses this in addition with the applyNow flag to handle the apply button logic in the default ag-Grid filters.
change: The exact same object passed on FloatingFilter.onFloatingFilterChanged

method onNewRowsLoaded

onNewRowsLoaded: () => void;

Gets called when new rows are inserted into the grid. If the filter needs to change it's state after rows are loaded, it can do it here.

method setModel

setModel: (model: any) => void;

Restores the filter state.

interface IFilterComp

interface IFilterComp extends IFilter, IComponent<IFilterParams> {}

interface IFilterParams

interface IFilterParams {}

property $scope

$scope: any;

property applyButton

applyButton?: boolean;

property clearButton

clearButton?: boolean;

property colDef

colDef: ColDef;

property column

column: Column;

property context

context: any;

property defaultOption

defaultOption?: string;

property doesRowPassOtherFilter

doesRowPassOtherFilter: (rowNode: RowNode) => boolean;

property filterChangedCallback

filterChangedCallback: () => void;

property filterModifiedCallback

filterModifiedCallback: () => void;

filterOptions?: string[];

property newRowsAction

newRowsAction?: string;

property rowModel

rowModel: IRowModel;

property textFormatter

textFormatter?: (from: string) => string;

property valueGetter

valueGetter: (rowNode: RowNode) => any;

interface IFloatingFilter

interface IFloatingFilter<
    M,
    F extends FloatingFilterChange,
    P extends IFloatingFilterParams<M, F>
> {}

method onParentModelChanged

onParentModelChanged: (
    parentModel: M,
    combinedModel?: CombinedFilter<M>
) => void;

interface IFloatingFilterParams

interface IFloatingFilterParams<M, F extends FloatingFilterChange> {}

property api

api: GridApi;

property column

column: Column;

property currentParentModel

currentParentModel: () => M;

property debounceMs

debounceMs?: number;

property onFloatingFilterChanged

onFloatingFilterChanged: (change: F | M) => boolean;

property suppressFilterButton

suppressFilterButton: boolean;

interface IFrameworkFactory

interface IFrameworkFactory {}

interface IGetRowsParams

interface IGetRowsParams {}

Params for the above IDatasource.getRows()

property context

context: any;

The grid context object

property endRow

endRow: number;

The first row index to NOT get.

property filterModel

filterModel: any;

If doing server side filtering, contains the filter model

property sortModel

sortModel: any;

If doing server side sorting, contains the sort model

property startRow

startRow: number;

The first row index to get.

method failCallback

failCallback: () => void;

Callback to call when the request fails.

method successCallback

successCallback: (rowsThisBlock: any[], lastRow?: number) => void;

Callback to call for the result when successful.

interface IHeader

interface IHeader {}

interface IHeaderGroup

interface IHeaderGroup {}

interface IHeaderGroupParams

interface IHeaderGroupParams {}

property api

api: GridApi;

property columnApi

columnApi: ColumnApi;

property columnGroup

columnGroup: ColumnGroup;

property context

context: any;

property displayName

displayName: string;

property setExpanded

setExpanded: (expanded: boolean) => void;

interface IHeaderParams

interface IHeaderParams {}

property api

api: GridApi;

property column

column: Column;

property columnApi

columnApi: ColumnApi;

property context

context: any;

property displayName

displayName: string;

property enableMenu

enableMenu: boolean;

property enableSorting

enableSorting: boolean;

property progressSort

progressSort: (multiSort?: boolean) => void;

property setSort

setSort: (sort: string, multiSort?: boolean) => void;

property showColumnMenu

showColumnMenu: (source: HTMLElement) => void;

property template

template: string;

interface ILoadingOverlayComp

interface ILoadingOverlayComp extends IComponent<ILoadingOverlayParams> {}

interface ILoadingOverlayParams

interface ILoadingOverlayParams {}

interface IMenuFactory

interface IMenuFactory {}

method hideActiveMenu

hideActiveMenu: () => void;

method isMenuEnabled

isMenuEnabled: (column: Column) => boolean;

method showMenuAfterButtonClick

showMenuAfterButtonClick: (
    column: Column,
    eventSource: HTMLElement,
    defaultTab?: string,
    restrictToTabs?: string[]
) => void;

method showMenuAfterMouseEvent

showMenuAfterMouseEvent: (
    column: Column,
    mouseEvent: MouseEvent | Touch,
    defaultTab?: string,
    restrictToTabs?: string[]
) => void;

interface InfiniteCacheParams

interface InfiniteCacheParams extends RowNodeCacheParams {}

property datasource

datasource: IDatasource;

interface INoRowsOverlayComp

interface INoRowsOverlayComp extends IComponent<INoRowsOverlayParams> {}

interface INoRowsOverlayParams

interface INoRowsOverlayParams {}

interface IRangeController

interface IRangeController {}

method addRange

addRange: (rangeSelection: AddRangeSelectionParams) => void;

method clearSelection

clearSelection: () => void;

method extendRangeInDirection

extendRangeInDirection: (cell: GridCell, key: number) => boolean;

method extendRangeToCell

extendRangeToCell: (cell: GridCell) => void;

method getCellRangeCount

getCellRangeCount: (cell: GridCell) => number;

method getCellRanges

getCellRanges: () => RangeSelection[];

method isCellInAnyRange

isCellInAnyRange: (cell: GridCell) => boolean;

method onDragging

onDragging: (mouseEvent: MouseEvent) => void;

method onDragStart

onDragStart: (mouseEvent: MouseEvent) => void;

method onDragStop

onDragStop: () => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method setRange

setRange: (rangeSelection: AddRangeSelectionParams) => void;

method setRangeToCell

setRangeToCell: (cell: GridCell, appendRange?: boolean) => void;

interface IRichCellEditorParams

interface IRichCellEditorParams extends ICellEditorParams {}

property cellHeight

cellHeight: number;

property cellRenderer

cellRenderer:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

property values

values: string[];

interface IRowModel

interface IRowModel {}

method forEachNode

forEachNode: (callback: (rowNode: RowNode) => void) => void;

Iterate through each node. What this does depends on the model type. For clientSide, goes through all nodes. For pagination, goes through current page. For virtualPage, goes through what's loaded in memory.

method getCurrentPageHeight

getCurrentPageHeight: () => number;

Returns total height of all the rows - used to size the height of the grid div that contains the rows

method getNodesInRangeForSelection

getNodesInRangeForSelection: (first: RowNode, last: RowNode) => RowNode[];

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

method getPageFirstRow

getPageFirstRow: () => number;

Returns the first and last rows to render.

method getPageLastRow

getPageLastRow: () => number;

method getRow

getRow: (index: number) => RowNode;

Returns the rowNode at the given index.

method getRowBounds

getRowBounds: (index: number) => RowBounds;

Returns row top and bottom for a given row

method getRowCount

getRowCount: () => number;

This is legacy, not used by ag-Grid, but keeping for backward compatibility

method getRowIndexAtPixel

getRowIndexAtPixel: (pixel: number) => number;

Returns the row index at the given pixel

method getRowNode

getRowNode: (id: string) => RowNode;

Returns the rowNode for given id.

method getType

getType: () => string;

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.

method isEmpty

isEmpty: () => boolean;

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.

method isLastRowFound

isLastRowFound: () => boolean;

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.

method isRowPresent

isRowPresent: (rowNode: RowNode) => boolean;

Returns true if the provided rowNode is in the list of rows to render

method isRowsToRender

isRowsToRender: () => 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.

interface IRowNodeStage

interface IRowNodeStage {}

method execute

execute: (params: StageExecuteParams) => any;

interface IsColumnFunc

interface IsColumnFunc {}

call signature

(params: IsColumnFuncParams): boolean;

interface IServerSideCache

interface IServerSideCache {}

interface IServerSideDatasource

interface IServerSideDatasource {}

method destroy

destroy: () => void;

method getRows

getRows: (params: IServerSideGetRowsParams) => void;

interface IServerSideGetRowsParams

interface IServerSideGetRowsParams {}

property parentNode

parentNode: RowNode;

property request

request: IServerSideGetRowsRequest;

method failCallback

failCallback: () => void;

method successCallback

successCallback: (rowsThisPage: any[], lastRow: number) => void;

interface IServerSideGetRowsRequest

interface IServerSideGetRowsRequest {}

property endRow

endRow: number;

property filterModel

filterModel: any;

property groupKeys

groupKeys: string[];

property pivotCols

pivotCols: ColumnVO[];

property pivotMode

pivotMode: boolean;

property rowGroupCols

rowGroupCols: ColumnVO[];

property sortModel

sortModel: any;

property startRow

startRow: number;

property valueCols

valueCols: ColumnVO[];

interface IServerSideRowModel

interface IServerSideRowModel extends IRowModel {}

method addToCache

addToCache: (route: string[], items: any[], index: number) => void;

method getBlockState

getBlockState: () => any;

method purgeCache

purgeCache: (route?: string[]) => void;

method removeFromCache

removeFromCache: (route: string[], items: any[]) => void;

interface ISetFilterParams

interface ISetFilterParams extends IFilterParams {}

property apply

apply: boolean;

property cellHeight

cellHeight: number;

property cellRenderer

cellRenderer:
    | {
          new (): ICellRendererComp;
      }
    | ICellRendererFunc
    | string;

property comparator

comparator?: (a: any, b: any) => number;

property debounceMs

debounceMs?: number;

property miniFilterSearchByRefDataKey

miniFilterSearchByRefDataKey?: boolean;

property newRowsAction

newRowsAction: string;

property selectAllOnMiniFilter

selectAllOnMiniFilter: boolean;

property suppressMiniFilter

suppressMiniFilter: boolean;

property suppressRemoveEntries

suppressRemoveEntries?: boolean;

property suppressSorting

suppressSorting: boolean;

property values

values?: SetFilterValues;

interface IsRowMaster

interface IsRowMaster {}

call signature

(dataItem: any): boolean;

interface IsRowSelectable

interface IsRowSelectable {}

call signature

(node: RowNode): boolean;

interface ItemsAddedEvent

interface ItemsAddedEvent extends AgGridEvent {}

property items

items: RowNode[];

interface IToolPanel

interface IToolPanel extends IComponent<any> {}

method getPreferredWidth

getPreferredWidth: () => number;

method isToolPanelShowing

isToolPanelShowing: () => boolean;

method refresh

refresh: () => void;

method registerGridComp

registerGridComp: (gridPanel: GridPanel) => void;

method showToolPanel

showToolPanel: (show: boolean) => void;

interface IViewportDatasource

interface IViewportDatasource {}

method destroy

destroy: () => void;

Gets called once when viewPort is no longer used. If you need to do any cleanup, do it here.

method init

init: (params: IViewportDatasourceParams) => void;

Gets called exactly once before viewPort is used. Passes methods to be used to tell viewPort of data loads / changes.

method setViewportRange

setViewportRange: (firstRow: number, lastRow: number) => void;

Tell the viewport what the scroll position of the grid is, so it knows what rows it has to get

interface IViewportDatasourceParams

interface IViewportDatasourceParams {}

property getRow

getRow: (rowIndex: number) => RowNode;

datasource calls this when it wants a row node - typically used when it wants to update the row node

property setRowCount

setRowCount: (count: number) => void;

datasource calls this method when the total row count changes. This in turn sets the height of the grids vertical scroll.

property setRowData

setRowData: (rowData: { [key: number]: any }) => void;

datasource calls this when new data arrives. The grid then updates the provided rows. The rows are mapped [rowIndex]=>rowData].

interface LongTapEvent

interface LongTapEvent extends AgEvent {}

property touchEvent

touchEvent: TouchEvent;

property touchStart

touchStart: Touch;

interface MenuItemDef

interface MenuItemDef {}

property action

action?: () => void;

property checked

checked?: boolean;

property cssClasses

cssClasses?: string[];

property disabled

disabled?: boolean;

property icon

icon?: HTMLElement | string;

property name

name: string;

property shortcut

shortcut?: string;

property subMenu

subMenu?: (MenuItemDef | string)[];

property tooltip

tooltip?: string;

interface ModelUpdatedEvent

interface ModelUpdatedEvent extends AgGridEvent {}

property animate

animate: boolean;

If true, the grid will try and animate the rows to the new positions

property keepRenderedRows

keepRenderedRows: boolean;

If true, the grid has new data loaded, eg user called setRowData(), otherwise it's the same data but sorted or filtered, in which case this is true, and rows can animate around (eg rowNode id 24 is the same row node as last time).

property newData

newData: boolean;

If true, then this update was a result of setRowData() getting called. This gets the grid to scroll to the top again.

property newPage

newPage: boolean;

True when pagination and a new page is navigated to.

interface NavigateToNextCellParams

interface NavigateToNextCellParams {}

property event

event: KeyboardEvent;

property key

key: number;

property nextCellDef

nextCellDef: GridCellDef;

property previousCellDef

previousCellDef: GridCellDef;

interface NewColumnsLoadedEvent

interface NewColumnsLoadedEvent extends AgGridEvent {}

interface NodeChildDetails

interface NodeChildDetails {}

property children

children?: any[];

property expanded

expanded?: boolean;

property field

field?: string;

property group

group: boolean;

property key

key?: any;

interface OriginalColumnGroupChild

interface OriginalColumnGroupChild {}

method getColumnGroupShow

getColumnGroupShow: () => string;

method getId

getId: () => string;

method isVisible

isVisible: () => boolean;

interface PaginationChangedEvent

interface PaginationChangedEvent extends AgGridEvent {}

property animate

animate: boolean;

property keepRenderedRows

keepRenderedRows: boolean;

property newData

newData: boolean;

property newPage

newPage: boolean;

interface PasteEndEvent

interface PasteEndEvent extends AgGridEvent {}

property source

source: string;

interface PasteStartEvent

interface PasteStartEvent extends AgGridEvent {}

property source

source: string;

interface PinnedRowDataChangedEvent

interface PinnedRowDataChangedEvent extends AgGridEvent {}

interface PostProcessPopupParams

interface PostProcessPopupParams {}

property column

column?: Column;

property ePopup

ePopup: HTMLElement;

property eventSource

eventSource?: HTMLElement;

property mouseEvent

mouseEvent?: MouseEvent | Touch;

property rowNode

rowNode?: RowNode;

property type

type: string;

interface ProcessCellForExportParams

interface ProcessCellForExportParams {}

property api

api: GridApi;

property column

column: Column;

property columnApi

columnApi: ColumnApi;

property context

context: any;

property node

node: RowNode;

property type

type: string;

property value

value: any;

interface ProcessHeaderForExportParams

interface ProcessHeaderForExportParams {}

property api

api: GridApi;

property column

column: Column;

property columnApi

columnApi: ColumnApi;

property context

context: any;

interface ProcessRowParams

interface ProcessRowParams {}

property addRenderedRowListener

addRenderedRowListener: (eventType: string, listener: Function) => void;

property api

api: GridApi;

property columnApi

columnApi: ColumnApi;

property context

context: any;

property ePinnedLeftRow

ePinnedLeftRow: HTMLElement;

property ePinnedRightRow

ePinnedRightRow: HTMLElement;

property eRow

eRow: HTMLElement;

property node

node: RowNode;

property rowIndex

rowIndex: number;

interface RangeSelection

interface RangeSelection {}

property columns

columns: Column[];

property end

end: GridCell;

property start

start: GridCell;

interface RangeSelectionChangedEvent

interface RangeSelectionChangedEvent extends AgGridEvent {}

property finished

finished: boolean;

property started

started: boolean;

interface RedrawRowsParams

interface RedrawRowsParams {}

property rowNodes

rowNodes?: RowNode[];

interface RefreshCellsParams

interface RefreshCellsParams extends GetCellsParams {}

property force

force?: boolean;

interface RowAccumulator

interface RowAccumulator {}

method onColumn

onColumn: (column: Column, index: number, node?: RowNode) => void;

interface RowBounds

interface RowBounds {}

property rowHeight

rowHeight: number;

property rowTop

rowTop: number;

interface RowClickedEvent

interface RowClickedEvent extends RowEvent {}

interface RowDataChangedEvent

interface RowDataChangedEvent extends AgGridEvent {}

interface RowDataUpdatedEvent

interface RowDataUpdatedEvent extends AgGridEvent {}

interface RowDoubleClickedEvent

interface RowDoubleClickedEvent extends RowEvent {}

interface RowDragEndEvent

interface RowDragEndEvent extends RowDragEvent {}

interface RowDragEnterEvent

interface RowDragEnterEvent extends RowDragEvent {}

interface RowDragEvent

interface RowDragEvent extends AgGridEvent {}

property event

event: MouseEvent;

property node

node: RowNode;

property overIndex

overIndex: number;

property overNode

overNode: RowNode;

property vDirection

vDirection: string;

property y

y: number;

interface RowDragLeaveEvent

interface RowDragLeaveEvent extends RowDragEvent {}

interface RowDragMoveEvent

interface RowDragMoveEvent extends RowDragEvent {}

interface RowEditingStartedEvent

interface RowEditingStartedEvent extends RowEvent {}

interface RowEditingStoppedEvent

interface RowEditingStoppedEvent extends RowEvent {}

interface RowEvent

interface RowEvent extends AgGridEvent {}

------------

property context

context: any;

property data

data: any;

property event

event?: Event;

property node

node: RowNode;

property rowIndex

rowIndex: number;

property rowPinned

rowPinned: string;

interface RowGroupOpenedEvent

interface RowGroupOpenedEvent extends RowEvent {}

interface RowNodeCacheParams

interface RowNodeCacheParams {}

property blockSize

blockSize: number;

property dynamicRowHeight

dynamicRowHeight: boolean;

property filterModel

filterModel: any;

property initialRowCount

initialRowCount: number;

property lastAccessedSequence

lastAccessedSequence: NumberSequence;

property maxBlocksInCache

maxBlocksInCache: number;

property maxConcurrentRequests

maxConcurrentRequests: number;

property overflowSize

overflowSize: number;

property rowHeight

rowHeight: number;

property rowNodeBlockLoader

rowNodeBlockLoader: RowNodeBlockLoader;

property sortModel

sortModel: any;

interface RowNodeTransaction

interface RowNodeTransaction {}

property add

add: RowNode[];

property remove

remove: RowNode[];

property update

update: RowNode[];

interface RowSelectedEvent

interface RowSelectedEvent extends RowEvent {}

interface RowSpanningAccumulator

interface RowSpanningAccumulator {}

method onColumn

onColumn: (header: string, index: number, span: number) => void;

interface RowValueChangedEvent

interface RowValueChangedEvent extends RowEvent {}

interface ScrollVisibilityChangedEvent

interface ScrollVisibilityChangedEvent extends AgGridEvent {}

interface SelectionChangedEvent

interface SelectionChangedEvent extends AgGridEvent {}

interface SerializedDateFilter

interface SerializedDateFilter extends SerializedFilter {}

property dateFrom

dateFrom: string;

property dateTo

dateTo: string;

property type

type: string;

interface SerializedFilter

interface SerializedFilter {}

property filterType

filterType: string;

interface SerializedNumberFilter

interface SerializedNumberFilter extends SerializedFilter {}

property filter

filter: number;

property filterTo

filterTo: number;

property type

type: string;

interface SerializedSetFilter

interface SerializedSetFilter extends SerializedFilter {}

property values

values: string[];

interface SerializedTextFilter

interface SerializedTextFilter extends SerializedFilter {}

property filter

filter: string;

property type

type: string;

interface SetFilterValuesFuncParams

interface SetFilterValuesFuncParams {}

property colDef

colDef: ColDef;

property success

success: (values: string[]) => void;

interface SortChangedEvent

interface SortChangedEvent extends AgGridEvent {}

interface StageExecuteParams

interface StageExecuteParams {}

property changedPath

changedPath?: ChangedPath;

property rowNode

rowNode: RowNode;

property rowNodeOrder

rowNodeOrder?: {
    [id: string]: number;
};

property rowNodeTransaction

rowNodeTransaction?: RowNodeTransaction;

interface StartEditingCellParams

interface StartEditingCellParams {}

property charPress

charPress?: string;

property colKey

colKey: string | Column;

property keyPress

keyPress?: number;

property rowIndex

rowIndex: number;

property rowPinned

rowPinned?: string;

interface TabbedItem

interface TabbedItem {}

property afterAttachedCallback

afterAttachedCallback?: Function;

property bodyPromise

bodyPromise: Promise<HTMLElement>;

property name

name: string;

property title

title: Element;

interface TabToNextCellParams

interface TabToNextCellParams {}

property backwards

backwards: boolean;

property editing

editing: boolean;

property nextCellDef

nextCellDef: GridCellDef;

property previousCellDef

previousCellDef: GridCellDef;

interface TapEvent

interface TapEvent extends AgEvent {}

property touchStart

touchStart: Touch;

interface TextAndNumberFilterParameters

interface TextAndNumberFilterParameters {}

property newRowsAction

newRowsAction?: string;

What to do when new rows are loaded. The default is to reset the filter, to keep it in line with 'set' filters. If you want to keep the selection, then set this value to 'keep'.

interface TextFormatter

interface TextFormatter {}

call signature

(from: string): string;

interface ToolPanelVisibleChangedEvent

interface ToolPanelVisibleChangedEvent extends AgGridEvent {}

interface ViewportChangedEvent

interface ViewportChangedEvent extends AgGridEvent {}

property firstRow

firstRow: number;

property lastRow

lastRow: number;

interface VirtualColumnsChangedEvent

interface VirtualColumnsChangedEvent extends AgGridEvent {}

interface VirtualRowRemovedEvent

interface VirtualRowRemovedEvent extends RowEvent {}

interface WrapableInterface

interface WrapableInterface {}

method addMethod

addMethod: (name: string, callback: Function) => void;

method callMethod

callMethod: (name: string, args: IArguments) => void;

method hasMethod

hasMethod: (name: string) => boolean;

interface XmlElement

interface XmlElement {}

property children

children?: XmlElement[];

property name

name: string;

property properties

properties?: XmlAttributes;

property textNode

textNode?: string;

Enums

enum DragSourceType

enum DragSourceType {
    ToolPanel = 0,
    HeaderCell = 1,
    RowDrag = 2,
}

member HeaderCell

HeaderCell = 1

member RowDrag

RowDrag = 2

member ToolPanel

ToolPanel = 0

enum HDirection

enum HDirection {
    Left = 0,
    Right = 1,
}

member Left

Left = 0

member Right

Right = 1

enum RowType

enum RowType {
    HEADER_GROUPING = 0,
    HEADER = 1,
    BODY = 2,
}

member BODY

BODY = 2

HEADER = 1

member HEADER_GROUPING

HEADER_GROUPING = 0

enum VDirection

enum VDirection {
    Up = 0,
    Down = 1,
}

member Down

Down = 1

member Up

Up = 0

Type Aliases

type ExcelDataType

type ExcelDataType = 'String' | 'Number' | 'Boolean' | 'DateTime' | 'Error';

type SetFilterValues

type SetFilterValues = SetFilterValuesFunc | any[];

type SetFilterValuesFunc

type SetFilterValuesFunc = (params: SetFilterValuesFuncParams) => void;

Package Files (142)

Dependencies (0)

No dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/ag-grid.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/ag-grid)

HTML

<a href="https://www.jsdocs.io/package/ag-grid"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 years ago.
Package analyzed in 23994 ms.
Missing or incorrect documentation? Open an issue for this package.