ag-grid-community 32.3.2 → 33.0.0

package/dist/types/src/interfaces/iFilter.d.ts

@@ -0,0 +1,182 @@
+import type { ColDef } from '../entities/colDef';
+import type { IFloatingFilterComp } from '../filter/floating/floatingFilter';
+import type { Column } from '../interfaces/iColumn';
+import type { AgPromise } from '../utils/promise';
+import type { IAfterGuiAttachedParams } from './iAfterGuiAttachedParams';
+import type { AgGridCommon } from './iCommon';
+import type { IComponent } from './iComponent';
+import type { IRowModel } from './iRowModel';
+import type { IRowNode } from './iRowNode';
+export type IFilterType = string | {
+    new (): IFilterComp;
+} | boolean;
+export type IFloatingFilterType = string | {
+    new (): IFloatingFilterComp;
+};
+export interface IFilterDef {
+    /**
+     * Filter component to use for this column.
+     * - Set to `true` to use the default filter.
+     * - Set to the name of a provided filter: `agNumberColumnFilter`, `agTextColumnFilter`, `agDateColumnFilter`, `agMultiColumnFilter`, `agSetColumnFilter`.
+     * - Set to a `IFilterComp`.
+     */
+    filter?: any;
+    /** Params to be passed to the filter component specified in `filter`. */
+    filterParams?: any;
+    /**
+     * The custom component to be used for rendering the floating filter.
+     * If none is specified the default AG Grid is used.
+     */
+    floatingFilterComponent?: any;
+    /** Params to be passed to `floatingFilterComponent`. */
+    floatingFilterComponentParams?: any;
+}
+export interface BaseFilter {
+    /**
+     * The grid will ask each active filter, in turn, whether each row in the grid passes. If any
+     * filter fails, then the row will be excluded from the final set. The method is provided a
+     * params object with attributes node (the rodNode the grid creates that wraps the data) and data
+     * (the data object that you provided to the grid for that row). Note that this is only called for the
+     * Client-Side Row Model, and can just return `true` if being used exclusively with other row models.
+     */
+    doesFilterPass(params: IDoesFilterPassParams): boolean;
+    /**
+     * Optional: Gets called when new rows are inserted into the grid. If the filter needs to change its
+     * state after rows are loaded, it can do it here. For example the set filters uses this
+     * to update the list of available values to select from (e.g. 'Ireland', 'UK' etc for
+     * Country filter). To get the list of available values from within this method from the
+     * Client Side Row Model, use `gridApi.forEachLeafNode(callback)`.
+     */
+    onNewRowsLoaded?(): void;
+    /** Optional: Called whenever any filter is changed. */
+    onAnyFilterChanged?(): void;
+    /**
+     * Optional: Used by AG Grid when rendering floating filters and there isn't a floating filter
+     * associated for this filter, this will happen if you create a custom filter and NOT a custom floating
+     * filter.
+     */
+    getModelAsString?(model: any): string;
+    /**
+     * Optional: A hook to perform any necessary operation just after the GUI for this component has been rendered on the screen.
+     * If a parent popup is closed and reopened (e.g. for filters), this method is called each time the component is shown.
+     * This is useful for any logic that requires attachment before executing, such as putting focus on a particular DOM element.
+     */
+    afterGuiAttached?(params?: IAfterGuiAttachedParams): void;
+    /**
+     * Optional: A hook to perform any necessary operation just after the GUI for this component has been removed from the screen.
+     * If a parent popup is opened and closed (e.g. for filters), this method is called each time the component is hidden.
+     * This is useful for any logic to reset the UI state back to the model before the component is reopened.
+     */
+    afterGuiDetached?(): void;
+}
+export interface IFilter extends BaseFilter {
+    /**
+     * Returns `true` if the filter is currently active, otherwise `false`.
+     * If active then 1) the grid will show the filter icon in the column header
+     * and 2) the filter will be included in the filtering of the data.
+     */
+    isFilterActive(): boolean;
+    /**
+     * Returns a model representing the current state of the filter, or `null` if the filter is
+     * not active. The grid calls `getModel()` on all active filters when `gridApi.getFilterModel()` is called.
+     */
+    getModel(): any;
+    /**
+     * Sets the state of the filter using the supplied model. Providing `null` as the model will
+     * de-activate the filter.
+     */
+    setModel(model: any): void | AgPromise<void>;
+    /**
+     * This method is called when the filter parameters change.
+     * The result returned by this method will determine if the filter should be refreshed and reused,
+     * or if a new filter instance should be created.
+     *
+     * This method should return `true` if the filter should be refreshed and reused instead of being destroyed.
+     * This is useful if the new params passed are compatible with the existing filter instance.
+     *
+     * When `false` is returned, the existing filter will be destroyed and a new filter will be created.
+     * This should be done if the new params passed are not compatible with the existing filter instance.
+     *
+     * @param newParams {IFilterParams} - New filter params.
+     *
+     * @returns {boolean} - `true` means that the filter should be refreshed and kept.
+     * `false` means that the filter will be destroyed and a new filter instance will be created.
+     */
+    refresh?(newParams: IFilterParams): boolean;
+}
+export interface ProvidedFilterModel {
+    filterType?: string;
+}
+export interface IFilterComp<TData = any> extends IComponent<IFilterParams<TData>>, IFilter {
+}
+export interface IDoesFilterPassParams<TData = any> {
+    /** The row node in question. */
+    node: IRowNode<TData>;
+    /** The data part of the row node in question. */
+    data: TData;
+}
+export interface IFilterOptionDef {
+    /** A unique key that does not clash with the built-in filter keys. */
+    displayKey: string;
+    /** Display name for the filter. Can be replaced by a locale-specific value using a `localeTextFunc`. */
+    displayName: string;
+    /** Custom filter logic that returns a boolean based on the `filterValues` and `cellValue`. */
+    predicate?: (filterValues: any[], cellValue: any) => boolean;
+    /** Number of inputs to display for this option. Defaults to `1` if unspecified. */
+    numberOfInputs?: 0 | 1 | 2;
+}
+export interface BaseFilterParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /** The column this filter is for. */
+    column: Column;
+    /** The column definition for the column. */
+    colDef: ColDef<TData>;
+    /**
+     * The row model, helpful for looking up data values if needed.
+     * If the filter needs to know which rows are
+     * a) in the table,
+     * b) currently visible (i.e. not already filtered),
+     * c) which groups,
+     * d) what order - all of this can be read from the rowModel.
+     */
+    rowModel: IRowModel;
+    /**
+     * Get the cell value for the given row node and column, which can be the column ID, definition, or `Column` object.
+     * If no column is provided, the column this filter is on will be used.
+     */
+    getValue: <TValue = any>(node: IRowNode<TData>, column?: string | ColDef<TData, TValue> | Column<TValue>) => TValue | null | undefined;
+    /**
+     * A function callback, call with a node to be told whether the node passes all filters except the current filter.
+     * This is useful if you want to only present to the user values that this filter can filter given the status of the other filters.
+     * The set filter uses this to remove from the list,
+     * items that are no longer available due to the state of other filters (like Excel type filtering).
+     */
+    doesRowPassOtherFilter: (rowNode: IRowNode<TData>) => boolean;
+}
+/**
+ * Parameters provided by the grid to the `init` method of an `IFilterComp`
+ */
+export interface IFilterParams<TData = any, TContext = any> extends BaseFilterParams<TData, TContext> {
+    /**
+     * A function callback to be called when the filter changes. The
+     * grid will then respond by filtering the grid data. The callback
+     * takes one optional parameter which, if included, will get merged
+     * to the FilterChangedEvent object (useful for passing additional
+     * information to anyone listening to this event, however such extra
+     * attributes are not used by the grid).
+     */
+    filterChangedCallback: (additionalEventAttributes?: any) => void;
+    /**
+     * A function callback, to be optionally called, when the filter UI changes.
+     * The grid will respond with emitting a FilterModifiedEvent.
+     * Apart from emitting the event, the grid takes no further action.
+     */
+    filterModifiedCallback: () => void;
+}
+/**
+ * FilterModel represents the filter state for all columns in the grid keyed by the column id.
+ * If using inbuilt AG Grid filters then the type of the column filter model could be one of:
+ *      `TextFilterModel`, `NumberFilterModel`, `DateFilterModel`, `SetFilterModel`, `IMultiFilterModel`, `AdvancedFilterModel`
+ */
+export interface FilterModel {
+    [colId: string]: any;
+}

package/dist/types/src/interfaces/iFooterService.d.ts

@@ -0,0 +1,7 @@
+import type { RowNode } from '../entities/rowNode';
+export interface IFooterService {
+    addNodes(params: {
+        index: number;
+    }, nodes: RowNode[], callback: (node: RowNode, index: number) => void, includeFooterNodes: boolean, rootNode: RowNode | null, position: 'top' | 'bottom'): void;
+    getTopDisplayIndex(rowsToDisplay: RowNode[], topLevelIndex: number, childrenAfterSort: RowNode[], getDefaultIndex: (adjustedIndex: number) => number): number;
+}

package/dist/types/src/interfaces/iFrameworkEventListenerService.d.ts

@@ -0,0 +1,6 @@
+export interface IFrameworkEventListenerService<TEventListener extends (e: any) => void, TGlobalEventListener extends (name: string, e: any) => void> {
+    wrap(userListener: TEventListener): TEventListener;
+    wrapGlobal(userListener: TGlobalEventListener): TGlobalEventListener;
+    unwrap(userListener: TEventListener): TEventListener;
+    unwrapGlobal(userListener: TGlobalEventListener): TGlobalEventListener;
+}

package/dist/types/src/interfaces/iFrameworkOverrides.d.ts

@@ -0,0 +1,47 @@
+import type { LocalEventService } from '../localEventService';
+import type { AgPromise } from '../utils/promise';
+import type { IFrameworkEventListenerService } from './iFrameworkEventListenerService';
+export type FrameworkOverridesIncomingSource = 'resize-observer' | 'ensureVisible' | 'popupPositioning';
+export interface IFrameworkOverrides {
+    setInterval(action: any, interval?: any): AgPromise<number>;
+    addEventListener(element: HTMLElement, type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    /**
+     * This method is to cater for Angular's change detection.
+     * Angular uses Zones, we want to run internal AG Grid outside of Zone JS so that we do not kick off
+     * Angular change detection. Any event listener or setTimeout() or setInterval() run by our code
+     * would trigger change detection in Angular.
+     *
+     * Before events are returned to the user, those functions are wrapped in Angular's zone
+     * again so that the user's code triggers change detection as normal. See wrapOutgoing() below.
+     */
+    wrapIncoming: <T>(callback: () => T, source?: FrameworkOverridesIncomingSource) => T;
+    /**
+     * This method is to cater for Angular's change detection.
+     * This is currently used for events that the user provides either via the component or via registration with the grid api.
+     * This method should not be implemented for the other frameworks to avoid unnecessary overhead.
+     */
+    wrapOutgoing: <T>(callback: () => T) => T;
+    /** Used for Angular event listener wrapping */
+    createLocalEventListenerWrapper?(existingFrameworkEventListenerService: IFrameworkEventListenerService<any, any> | undefined, localEventService: LocalEventService<any>): IFrameworkEventListenerService<any, any> | undefined;
+    /** Used for Angular event listener wrapping */
+    createGlobalEventListenerWrapper?(): IFrameworkEventListenerService<any, any>;
+    frameworkComponent(name: string, components?: any): any;
+    isFrameworkComponent(comp: any): boolean;
+    /**
+     * Which rendering engine is used for the grid components. Can be either 'vanilla' or 'react'.
+     */
+    renderingEngine: 'vanilla' | 'react';
+    /**
+     * Returns the framework specific url for linking to a documentation page.
+     * @param path Optional path to append to the base url. i.e 'aligned-grids' Does not need the leading `/`
+     */
+    getDocLink(path?: string): string;
+    /** Used by `RowRenderer` when getting lock. Allows React async refreshes to work. */
+    getLockOnRefresh?(): void;
+    /** Used by `RowRenderer` when releasing lock. Allows React async refreshes to work. */
+    releaseLockOnRefresh?(): void;
+    /** Used by the CtrlsService to decide whether to trigger the whenReady callbacks asynchronously.
+     * Required for React to work with StrictMode from v19 with the current implementation of the CtrlsService.
+     */
+    runWhenReadyAsync?(): boolean;
+}

package/dist/types/src/interfaces/iGroupHideOpenParentsService.d.ts

@@ -0,0 +1,9 @@
+import type { RowNode } from '../entities/rowNode';
+import type { ChangedPath } from '../utils/changedPath';
+import type { Column } from './iColumn';
+import type { IRowNode } from './iRowNode';
+export interface IGroupHideOpenParentsService {
+    updateGroupDataForHideOpenParents(changedPath?: ChangedPath): void;
+    pullDownGroupDataForHideOpenParents(rowNodes: RowNode[] | null, clearOperation: boolean): void;
+    isShowingValueForOpenedParent(rowNode: IRowNode, column: Column): boolean;
+}

package/dist/types/src/interfaces/iHeaderPosition.d.ts

@@ -0,0 +1,7 @@
+import type { Column, ColumnGroup } from './iColumn';
+export interface HeaderPosition {
+    /** A number from 0 to n, where n is the last header row the grid is rendering */
+    headerRowIndex: number;
+    /** The grid column or column group */
+    column: Column | ColumnGroup;
+}

package/dist/types/src/interfaces/iLoadingCellRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { ICellRendererParams } from '../rendering/cellRenderers/iCellRenderer';
+import type { IComponent } from './iComponent';
+export interface ILoadingCellRendererParams<TData = any, TContext = any> extends ICellRendererParams<TData, TContext> {
+}
+export interface ILoadingCellRenderer {
+}
+export interface ILoadingCellRendererComp extends ILoadingCellRenderer, IComponent<ILoadingCellRendererParams> {
+}

package/dist/types/src/interfaces/iModule.d.ts

@@ -0,0 +1,61 @@
+import type { GridApi } from '../api/gridApi';
+import type { ApiFunction, ApiFunctionName } from '../api/iApiFunction';
+import type { ClassImp, ComponentMeta, DynamicBeanName, SingletonBean, UserComponentName } from '../context/context';
+import type { IconName, IconValue } from '../utils/icon';
+import type { ComponentSelector } from '../widgets/component';
+import type { RowModelType } from './iRowModel';
+export type ModuleValidationValidResult = {
+    isValid: true;
+};
+export type ModuleValidationInvalidResult = {
+    isValid: false;
+    message: string;
+};
+export type ModuleValidationResult = ModuleValidationValidResult | ModuleValidationInvalidResult;
+/** A Module contains all the code related to this feature to enable tree shaking when this module is not used. */
+export interface Module {
+    moduleName: ModuleName;
+    version: string;
+    enterprise?: boolean;
+    /**
+     * Validation run when registering the module
+     *
+     * @return Whether the module is valid or not. If not, a message explaining why it is not valid
+     */
+    validate?: () => ModuleValidationResult;
+    /** singleton beans which are created once on grid init */
+    beans?: SingletonBean[];
+    /** beans which can have many instances, and can be created/destroyed at any time */
+    dynamicBeans?: Partial<Record<DynamicBeanName, ClassImp>>;
+    /** components which can be overridden by the user (e.g. cell renderers). These are the default grid provided versions */
+    userComponents?: Partial<Record<UserComponentName, ComponentMeta>>;
+    /** selectors for grid components that can be defined in templates and created by AG stack */
+    selectors?: ComponentSelector[];
+    /**
+     * icon mappings
+     * *** IMPORTANT NOTE! ***
+     * If you change the icons, copy/paste the new content into the docs page custom-icons
+     */
+    icons?: Partial<Record<IconName, IconValue>>;
+    rowModels?: RowModelType[];
+    dependsOn?: Module[];
+    css?: string[];
+}
+/** Used to define a module that contains api functions. */
+export type _ModuleWithApi<TGridApi extends Readonly<Partial<GridApi>>> = Module & {
+    apiFunctions?: {
+        [K in ApiFunctionName & keyof TGridApi]: ApiFunction<K>;
+    };
+};
+/** Used to define a module that does not contain api functions. */
+export type _ModuleWithoutApi = Module & {
+    apiFunctions?: never;
+};
+export type InternalModuleName = 'Aggregation' | 'AnimationFrame' | 'Aria' | 'AutoWidth' | 'CellRendererFunction' | 'ChangeDetection' | 'CheckboxCellRenderer' | 'ClientSideRowModelFilter' | 'ClientSideRowModelHierarchy' | 'ColumnFilter' | 'ColumnFlex' | 'ColumnGroupHeaderComp' | 'ColumnGroup' | 'ColumnHeaderComp' | 'ColumnMove' | 'ColumnResize' | 'CommunityCore' | 'CsrmSsrmSharedApi' | 'DataType' | 'Drag' | 'EditCore' | 'EnterpriseCore' | 'Expression' | 'FilterCore' | 'FilterValue' | 'GroupCellRenderer' | 'GroupColumn' | 'HorizontalResize' | 'KeyboardNavigation' | 'LoadingCellRenderer' | 'MenuCore' | 'MenuItem' | 'Overlay' | 'PinnedColumn' | 'Popup' | 'SharedAggregation' | 'SharedDragAndDrop' | 'SharedExport' | 'SharedMasterDetail' | 'SharedMenu' | 'SharedPivot' | 'SharedRowGrouping' | 'SharedRowSelection' | 'SharedTreeData' | 'SideBarShared' | 'SkeletonCellRenderer' | 'Sort' | 'SsrmInfiniteSharedApi' | 'StickyRow' | 'Touch';
+export type CommunityModuleName = 'AlignedGrids' | 'AllCommunity' | 'CellApi' | 'CellStyle' | 'CheckboxEditor' | 'ClientSideRowModelApi' | 'ClientSideRowModel' | 'ColumnApi' | 'ColumnAutoSize' | 'ColumnHover' | 'CsvExport' | 'CustomEditor' | 'CustomFilter' | 'DateEditor' | 'DateFilter' | 'DragAndDrop' | 'EventApi' | 'ExternalFilter' | 'GridState' | 'HighlightChanges' | 'InfiniteRowModel' | 'LargeTextEditor' | 'Locale' | 'NumberEditor' | 'NumberFilter' | 'Pagination' | 'PinnedRow' | 'QuickFilter' | 'RenderApi' | 'RowApi' | 'RowAutoHeight' | 'RowDrag' | 'RowSelection' | 'RowStyle' | 'ScrollApi' | 'SelectEditor' | 'TextEditor' | 'TextFilter' | 'Tooltip' | 'UndoRedoEdit' | 'Validation' | 'ValueCache';
+export type EnterpriseModuleName = 'AdvancedFilter' | 'AllEnterprise' | 'CellSelection' | 'Clipboard' | 'ColumnMenu' | 'ColumnsToolPanel' | 'ContextMenu' | 'ExcelExport' | 'FiltersToolPanel' | 'GridCharts' | 'IntegratedCharts' | 'GroupFilter' | 'MasterDetail' | 'Menu' | 'MultiFilter' | 'Pivot' | 'RangeSelection' | 'RichSelect' | 'RowGrouping' | 'RowGroupingPanel' | 'ServerSideRowModelApi' | 'ServerSideRowModel' | 'SetFilter' | 'SideBar' | 'Sparklines' | 'StatusBar' | 'TreeData' | 'ViewportRowModel';
+export type ModuleName = InternalModuleName | CommunityModuleName | EnterpriseModuleName;
+/** These are the internal modules that we have mappings for to convert into exported modules */
+export type ResolvableModuleName = Extract<InternalModuleName, 'EditCore' | 'MenuCore' | 'EnterpriseCore' | 'ColumnHeaderComp' | 'ColumnFilter' | 'ColumnGroupHeaderComp' | 'SharedDragAndDrop' | 'GroupCellRenderer' | 'MenuItem' | 'CommunityCore' | 'LoadingCellRenderer' | 'Sort' | 'SharedRowSelection' | 'KeyboardNavigation' | 'SharedMenu' | 'ColumnMove' | 'ColumnResize' | 'FilterCore' | 'CsrmSsrmSharedApi' | 'SsrmInfiniteSharedApi' | 'SharedMasterDetail' | 'SharedRowGrouping' | 'SharedAggregation' | 'SharedPivot' | 'ColumnGroup' | 'Overlay' | 'PinnedColumn' | 'ClientSideRowModelHierarchy' | 'SkeletonCellRenderer' | 'CheckboxCellRenderer' | 'SharedTreeData'>;
+/** These are the types that we can display validations for */
+export type ValidationModuleName = CommunityModuleName | EnterpriseModuleName | ResolvableModuleName;

package/dist/types/src/interfaces/iPivotResultColsService.d.ts

@@ -0,0 +1,11 @@
+import type { ColKey, ColumnCollections } from '../columns/columnModel';
+import type { AgColumn } from '../entities/agColumn';
+import type { ColDef, ColGroupDef } from '../entities/colDef';
+import type { ColumnEventType } from '../events';
+export interface IPivotResultColsService {
+    isPivotResultColsPresent(): boolean;
+    lookupPivotResultCol(pivotKeys: string[], valueColKey: ColKey): AgColumn | null;
+    getPivotResultCols(): ColumnCollections | null;
+    getPivotResultCol(key: ColKey): AgColumn | null;
+    setPivotResultCols(colDefs: (ColDef | ColGroupDef)[] | null, source: ColumnEventType): void;
+}

package/dist/types/src/interfaces/iPopup.d.ts

@@ -0,0 +1,25 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { IRowNode } from './iRowNode';
+export interface PopupPositionParams {
+    ePopup: HTMLElement;
+    column?: AgColumn | null;
+    rowNode?: IRowNode | null;
+    nudgeX?: number;
+    nudgeY?: number;
+    position?: 'over' | 'under';
+    alignSide?: 'left' | 'right';
+    keepWithinBounds?: boolean;
+    skipObserver?: boolean;
+    updatePosition?: () => {
+        x: number;
+        y: number;
+    };
+    postProcessCallback?: () => void;
+}
+export interface PopupEventParams {
+    originalMouseEvent?: MouseEvent | Touch | null;
+    mouseEvent?: MouseEvent;
+    touchEvent?: TouchEvent;
+    keyboardEvent?: KeyboardEvent;
+    forceHide?: boolean;
+}

package/dist/types/src/interfaces/iRedrawRowsParams.d.ts

@@ -0,0 +1,5 @@
+import type { IRowNode } from './iRowNode';
+export interface RedrawRowsParams<TData = any> {
+    /** Row nodes to redraw */
+    rowNodes?: IRowNode<TData>[];
+}

package/dist/types/src/interfaces/iRowChildrenService.d.ts

@@ -0,0 +1,4 @@
+import type { RowNode } from '../entities/rowNode';
+export interface IRowChildrenService {
+    getHasChildrenValue(rowNode: RowNode): boolean | null;
+}

package/dist/types/src/interfaces/iRowDragItem.d.ts

@@ -0,0 +1,5 @@
+import type { DragItem } from './iDragItem';
+export interface IRowDragItem extends DragItem {
+    /** The default text that would be applied to this Drag Element */
+    defaultTextValue: string;
+}

package/dist/types/src/interfaces/iRowModel.d.ts

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