ag-grid

  • Version 18.1.2
  • Published
  • 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

Classes

Interfaces

Enums

Type Aliases

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[];
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      </