ag-grid-community 32.3.2 → 33.0.0

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

@@ -0,0 +1,270 @@
+import type { AgEvent, SelectionEventSourceType } from '../events';
+import type { Column } from '../interfaces/iColumn';
+import type { BuildEventTypeMap } from './iEventEmitter';
+export type RowNodeEventType = 'rowSelected' | 'selectableChanged' | 'displayedChanged' | 'dataChanged' | 'cellChanged' | 'masterChanged' | 'heightChanged' | 'topChanged' | 'groupChanged' | 'allChildrenCountChanged' | 'firstChildChanged' | 'lastChildChanged' | 'childIndexChanged' | 'rowIndexChanged' | 'expandedChanged' | 'hasChildrenChanged' | 'uiLevelChanged' | 'rowHighlightChanged' | 'mouseEnter' | 'mouseLeave' | 'draggingChanged';
+export type RowNodeEventTypeMap<TData = any> = BuildEventTypeMap<RowNodeEventType, {
+    rowSelected: RowNodeSelectedEvent<TData>;
+    selectableChanged: SelectableChangedEvent<TData>;
+    displayedChanged: DisplayedChangedEvent<TData>;
+    dataChanged: DataChangedEvent<TData>;
+    cellChanged: CellChangedEvent<TData>;
+    masterChanged: MasterChangedEvent<TData>;
+    heightChanged: HeightChangedEvent<TData>;
+    topChanged: TopChangedEvent<TData>;
+    groupChanged: GroupChangedEvent<TData>;
+    allChildrenCountChanged: AllChildrenCountChangedEvent<TData>;
+    firstChildChanged: FirstChildChangedEvent<TData>;
+    lastChildChanged: LastChildChangedEvent<TData>;
+    childIndexChanged: ChildIndexChangedEvent<TData>;
+    rowIndexChanged: RowIndexChangedEvent<TData>;
+    expandedChanged: ExpandedChangedEvent<TData>;
+    hasChildrenChanged: HasChildrenChangedEvent<TData>;
+    uiLevelChanged: UiLevelChangedEvent<TData>;
+    rowHighlightChanged: RowHighlightChangedEvent<TData>;
+    mouseEnter: MouseEnterEvent<TData>;
+    mouseLeave: MouseLeaveEvent<TData>;
+    draggingChanged: DraggingChangedEvent<TData>;
+}>;
+export type AgRowNodeEventListener<TEventType extends keyof RowNodeEventTypeMap<TData>, TData = any> = (params: RowNodeEventTypeMap<TData>[TEventType]) => void;
+export interface RowNodeEvent<T extends RowNodeEventType, TData = any> extends AgEvent<T> {
+    node: IRowNode<TData>;
+}
+export interface RowNodeSelectedEvent<TData = any> extends RowNodeEvent<'rowSelected', TData> {
+}
+export interface MouseEnterEvent<TData = any> extends RowNodeEvent<'mouseEnter', TData> {
+}
+export interface MouseLeaveEvent<TData = any> extends RowNodeEvent<'mouseLeave', TData> {
+}
+export interface HeightChangedEvent<TData = any> extends RowNodeEvent<'heightChanged', TData> {
+}
+export interface RowIndexChangedEvent<TData = any> extends RowNodeEvent<'rowIndexChanged', TData> {
+}
+export interface TopChangedEvent<TData = any> extends RowNodeEvent<'topChanged', TData> {
+}
+export interface ExpandedChangedEvent<TData = any> extends RowNodeEvent<'expandedChanged', TData> {
+}
+/** @deprecated v33 Use the `modelUpdated` event instead and calculate whether the first child has changed. */
+export interface FirstChildChangedEvent<TData = any> extends RowNodeEvent<'firstChildChanged', TData> {
+}
+/** @deprecated v33 Use the `modelUpdated` event instead and calculate whether the last child has changed. */
+export interface LastChildChangedEvent<TData = any> extends RowNodeEvent<'lastChildChanged', TData> {
+}
+/** @deprecated v33 Use the `modelUpdated` event instead and calculate whether the child index has changed. */
+export interface ChildIndexChangedEvent<TData = any> extends RowNodeEvent<'childIndexChanged', TData> {
+}
+export interface AllChildrenCountChangedEvent<TData = any> extends RowNodeEvent<'allChildrenCountChanged', TData> {
+}
+export interface UiLevelChangedEvent<TData = any> extends RowNodeEvent<'uiLevelChanged', TData> {
+}
+export interface DataChangedEvent<TData = any> extends RowNodeEvent<'dataChanged', TData> {
+    oldData: TData | undefined;
+    newData: TData | undefined;
+    update: boolean;
+}
+export interface CellChangedEvent<TData = any> extends RowNodeEvent<'cellChanged', TData> {
+    column: Column;
+    newValue: TData | undefined;
+    oldValue: TData | undefined;
+}
+export interface SelectableChangedEvent<TData = any> extends RowNodeEvent<'selectableChanged', TData> {
+}
+export interface DisplayedChangedEvent<TData = any> extends RowNodeEvent<'displayedChanged', TData> {
+}
+export interface MasterChangedEvent<TData = any> extends RowNodeEvent<'masterChanged', TData> {
+}
+export interface GroupChangedEvent<TData = any> extends RowNodeEvent<'groupChanged', TData> {
+}
+export interface HasChildrenChangedEvent<TData = any> extends RowNodeEvent<'hasChildrenChanged', TData> {
+}
+export interface RowHighlightChangedEvent<TData = any> extends RowNodeEvent<'rowHighlightChanged', TData> {
+}
+export interface DraggingChangedEvent<TData = any> extends RowNodeEvent<'draggingChanged', TData> {
+}
+export type RowPinnedType = 'top' | 'bottom' | null | undefined;
+export interface VerticalScrollPosition {
+    top: number;
+    bottom: number;
+}
+interface BaseRowNode<TData = any> {
+    /** Unique ID for the node. Either provided by the application, or generated by the grid if not. */
+    id: string | undefined;
+    /**
+     * The data as provided by the application.
+     * Can be `undefined` when using row grouping or during grid initialisation.
+     */
+    data: TData | undefined;
+    /**
+     * This will be `true` if it has a rowIndex assigned, otherwise `false`.
+     */
+    displayed: boolean;
+    /** Either `'top'` or `'bottom'` if row pinned, otherwise `undefined` or `null`. */
+    rowPinned: RowPinnedType;
+    /** Is this row selectable. */
+    selectable: boolean;
+    /** The height, in pixels, of this row. */
+    rowHeight: number | null | undefined;
+    /** The row top position in pixels. */
+    rowTop: number | null;
+    /** `true` if this node is a group node (i.e. it has children) */
+    group: boolean | undefined;
+    /** @deprecated v33 Use `rowNode.parent?.childrenAfterSort?.[0] === rowNode` instead. */
+    firstChild: boolean;
+    /** @deprecated v33 Use `!!rowNode.parent?.childrenAfterSort && (rowNode.parent.childrenAfterSort[rowNode.parent.childrenAfterSort.length - 1] === rowNode)` instead. */
+    lastChild: boolean;
+    /** @deprecated v33 Use `rowNode.parent?.childrenAfterSort?.findIndex(r => r === rowNode)` instead. */
+    childIndex: number;
+    /** How many levels this node is from the top when grouping. */
+    level: number;
+    /** How many levels this node is from the top when grouping in the UI (only different to `parent` when `groupHideParentOfSingleChild=true`).*/
+    uiLevel: number;
+    /** The parent node to this node, or empty if top level. */
+    parent: IRowNode<TData> | null;
+    /** Used by server-side row model. `true` if this row node is a stub. A stub is a placeholder row with loading icon while waiting from row to be loaded. */
+    stub: boolean | undefined;
+    /** Used by server side row model, `true` if this row node failed a load. */
+    failedLoad: boolean | undefined;
+    /**
+     * The index of the row in the source rowData array including any updates via transactions.
+     * It does not change when sorting, filtering, grouping, pivoting or any other UI related operations.
+     * If this is a filler node (a visual row created by AG Grid in tree data or grouping) the value will be `-1`.
+     */
+    readonly sourceRowIndex: number;
+    /** The current row index. If the row is filtered out or in a collapsed group, this value will be `null`. */
+    rowIndex: number | null;
+    /** If using quick filter, stores a string representation of the row for searching against. */
+    quickFilterAggregateText: string | null;
+    /** `true` if this row is a master row, part of master / detail (ie row can be expanded to show detail). */
+    master: boolean;
+    /** `true` if this row is a detail row, part of master / detail (ie child row of an expanded master row). */
+    detail: boolean | undefined;
+}
+interface GroupRowNode<TData = any> {
+    /** The field we are grouping on from our row data. */
+    field: string | null;
+    /** The key value for this group. */
+    key: string | null;
+    /** If using row grouping, contains the group values for this group. */
+    groupData: {
+        [key: string]: any | null;
+    } | null;
+    /** If using row grouping and aggregation, contains the aggregation data. */
+    aggData: any;
+    /** The row group column used for this group. */
+    rowGroupColumn: Column | null;
+    /**
+     * If doing in-memory (client-side) grouping, this is the index of the group column this cell is for.
+     * This will always be the same as the level, unless we are collapsing groups, i.e. `groupHideParentOfSingleChild=true`.
+     */
+    rowGroupIndex: number | null;
+    /** `true` if group is expanded, otherwise `false`. */
+    expanded: boolean;
+    /** `true` if this node is a group and the group is the bottom level in the tree. */
+    leafGroup: boolean | undefined;
+    /** All lowest level nodes beneath this node, no groups. */
+    allLeafChildren: IRowNode<TData>[] | null;
+    /** Number of children and grand children. */
+    allChildrenCount: number | null;
+    /** Children of this group. If multi levels of grouping, shows only immediate children. */
+    childrenAfterGroup: IRowNode<TData>[] | null;
+    /** Sorted children of this group. */
+    childrenAfterSort: IRowNode<TData>[] | null;
+    /** Filtered children of this group. */
+    childrenAfterFilter: IRowNode<TData>[] | null;
+    /** `true` if row is a footer. Footers have `group = true` and `footer = true`. */
+    footer: boolean | undefined;
+    /** If using footers, reference to the footer node for this group. */
+    sibling: IRowNode<TData>;
+}
+export interface IRowNode<TData = any> extends BaseRowNode<TData>, GroupRowNode<TData> {
+    /**
+     * Select (or deselect) the node.
+     * @param newValue -`true` for selection, `false` for deselection.
+     * @param clearSelection - If selecting, then passing `true` will select the node exclusively (i.e. NOT do multi select). If doing deselection, `clearSelection` has no impact. Default: `false`
+     * @param source - Source property that will appear in the `selectionChanged` event. Default: `'api'`
+     */
+    setSelected(newValue: boolean, clearSelection?: boolean, source?: SelectionEventSourceType): void;
+    /** Returns:
+     * - `true` if node is selected.
+     * - `false` if the node isn't selected.
+     * - `undefined` if it's partially selected (group where not all children are selected).
+     */
+    isSelected(): boolean | undefined;
+    /**
+     * Returns:
+     * - `true` if node is either pinned to the `top` or `bottom`.
+     * - `false` if the node isn't pinned.
+     */
+    isRowPinned(): boolean;
+    /** Returns:
+     * - `true` if the node can be expanded, i.e it is a group or master row.
+     * - `false` if the node cannot be expanded.
+     */
+    isExpandable(): boolean;
+    /**
+     * Set the expanded state of this rowNode.
+     * @param expanded - `true` to expand, `false` to collapse.
+     * @param sourceEvent - Optional event that will be passed to the `rowGroupOpened` event.
+     * @param forceSync - By default rows are expanded asynchronously for best performance. Set to `true` if you need to interact with the expanded row immediately after this function.
+     */
+    setExpanded(expanded: boolean, sourceEvent?: MouseEvent | KeyboardEvent, forceSync?: boolean): void;
+    /**
+     * @deprecated v32.2.0 Check `node.detail` then user provided callback `isFullWidthRow` instead.
+     *
+     * Returns:
+     * - `true` if the node is a full width cell.
+     * - `false` if the node is not a full width cell.
+     */
+    isFullWidthCell(): boolean;
+    /**
+     * Returns:
+     * - `true` if the node is currently hovered.
+     * - `false` if the node is not hovered.
+     */
+    isHovered(): boolean;
+    /** Add an event listener. */
+    addEventListener<T extends RowNodeEventType>(eventType: T, userListener: AgRowNodeEventListener<T>): void;
+    /** Remove event listener. */
+    removeEventListener<T extends RowNodeEventType>(eventType: T, userListener: AgRowNodeEventListener<T>): void;
+    /**
+     * The first time `quickFilter` runs, the grid creates a one-off string representation of the row.
+     * This string is then used for the quick filter instead of hitting each column separately.
+     * When you edit, using grid editing, this string gets cleared down.
+     * However if you edit without using grid editing, you will need to clear this string down for the row to be updated with the new values.
+     * Otherwise new values will not work with the `quickFilter`.
+     */
+    resetQuickFilterAggregateText(): void;
+    /** Perform a depth-first search of this node and its children. */
+    depthFirstSearch(callback: (rowNode: IRowNode<TData>) => void): void;
+    /**
+     * Sets the row height.
+     * Call if you want to change the height initially assigned to the row.
+     * After calling, you must call `api.onRowHeightChanged()` so the grid knows it needs to work out the placement of the rows.
+     * @param rowHeight - new height of the row
+     * @param estimated - is this an estimated height. Default: `false`
+     */
+    setRowHeight(rowHeight: number | undefined | null, estimated?: boolean): void;
+    /**
+     * Replaces the data on the `rowNode`. When this method is called, the grid will refresh the entire rendered row if it is displayed.
+     */
+    setData(data: TData): void;
+    /**
+     * Updates the data on the `rowNode`. When this method is called, the grid will refresh the entire rendered row if it is displayed.
+     */
+    updateData(data: TData): void;
+    /**
+     * Replaces the value on the `rowNode` for the specified column. When complete,
+     * the grid will refresh the rendered cell on the required row only.
+     * **Note**: This method only fires `onCellEditRequest` when the Grid is in **Read Only** mode.
+     *
+     * @param colKey The column where the value should be updated
+     * @param newValue The new value
+     * @param eventSource The source of the event
+     * @returns `true` if the value was changed, otherwise `false`.
+     */
+    setDataValue(colKey: string | Column, newValue: any, eventSource?: string): boolean;
+    /**
+     * Returns the route of the row node. If the Row Node does not have a key (i.e it's a group) returns undefined
+     */
+    getRoute(): string[] | undefined;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import type { GridOptions } from '../entities/gridOptions';
+import type { RowNode } from '../entities/rowNode';
+import type { ChangedPath } from '../utils/changedPath';
+import type { ClientSideRowModelStage, IChangedRowNodes } from './iClientSideRowModel';
+import type { RowNodeTransaction } from './rowNodeTransaction';
+export interface StageExecuteParams<TData = any> {
+    rowNode: RowNode<TData>;
+    changedRowNodes?: IChangedRowNodes<TData>;
+    rowNodeTransactions?: RowNodeTransaction<TData>[] | null;
+    rowNodesOrderChanged?: boolean;
+    changedPath?: ChangedPath;
+    afterColumnsChanged?: boolean;
+}
+export interface IRowNodeStage<TResult = any, TData = any> {
+    step: ClientSideRowModelStage;
+    refreshProps: Set<keyof GridOptions>;
+    execute(params: StageExecuteParams<TData>): TResult;
+}

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

@@ -0,0 +1,8 @@
+import type { RowPinnedType } from './iRowNode';
+export interface RowPosition {
+    /** A positive number from 0 to n, where n is the last row the grid is rendering
+     * or -1 if you want to navigate to the grid header */
+    rowIndex: number;
+    /** Either 'top', 'bottom' or null/undefined (for not pinned) */
+    rowPinned: RowPinnedType;
+}

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

@@ -0,0 +1,67 @@
+import type { AgColumn } from '../entities/agColumn';
+import type { SelectAllMode } from '../entities/gridOptions';
+import type { RowNode } from '../entities/rowNode';
+import type { SelectionEventSourceType } from '../events';
+import type { RowCtrl, RowGui } from '../rendering/row/rowCtrl';
+import type { CheckboxSelectionComponent } from '../selection/checkboxSelectionComponent';
+import type { SelectAllFeature } from '../selection/selectAllFeature';
+import type { ChangedPath } from '../utils/changedPath';
+import type { IRowNode } from './iRowNode';
+import type { ServerSideRowGroupSelectionState, ServerSideRowSelectionState } from './selectionState';
+export interface ISelectionService {
+    getSelectionState(): string[] | ServerSideRowSelectionState | ServerSideRowGroupSelectionState | null;
+    setSelectionState(state: string[] | ServerSideRowSelectionState | ServerSideRowGroupSelectionState, source: SelectionEventSourceType): void;
+    getSelectedNodes(): RowNode<any>[];
+    getSelectedRows(): any[];
+    getSelectionCount(): number;
+    setNodesSelected(params: ISetNodesSelectedParams): number;
+    filterFromSelection?(predicate: (node: RowNode) => boolean): void;
+    /** Should only be called if groupSelects = 'descendants' or 'filteredDescendants' in CSRM */
+    updateGroupsFromChildrenSelections?(source: SelectionEventSourceType, changedPath?: ChangedPath): boolean;
+    syncInRowNode(rowNode: RowNode, oldNode?: RowNode): void;
+    reset(source: SelectionEventSourceType): void;
+    getBestCostNodeSelection(): RowNode[] | undefined;
+    isEmpty(): boolean;
+    /**
+     * @param selectAll See `MultiRowSelectionOptions.selectAll`
+     * @returns all nodes including unselectable nodes which are the target of this selection attempt
+     */
+    getSelectAllState(selectAll?: SelectAllMode): boolean | null;
+    hasNodesToSelect(selectAll?: SelectAllMode): boolean;
+    selectAllRowNodes(params: {
+        source: SelectionEventSourceType;
+        selectAll?: SelectAllMode;
+    }): void;
+    deselectAllRowNodes(params: {
+        source: SelectionEventSourceType;
+        selectAll?: SelectAllMode;
+    }): void;
+    createCheckboxSelectionComponent(): CheckboxSelectionComponent;
+    createSelectAllFeature(column: AgColumn): SelectAllFeature;
+    onRowCtrlSelected(rowCtrl: RowCtrl, hasFocusFunc: (gui: RowGui) => void, gui?: RowGui): void;
+    announceAriaRowSelection(rowNode: RowNode): void;
+    /** Called after grouping / treeData */
+    updateSelectableAfterGrouping(changedPath: ChangedPath | undefined): void;
+    updateRowSelectable(rowNode: RowNode, suppressSelectionUpdate?: boolean): boolean;
+    selectRowNode(rowNode: RowNode, newValue?: boolean, e?: Event, source?: SelectionEventSourceType): boolean;
+    createDaemonNode?(rowNode: RowNode): RowNode | undefined;
+    handleSelectionEvent(event: MouseEvent | KeyboardEvent, rowNode: RowNode, source: SelectionEventSourceType): number;
+    isCellCheckboxSelection(column: AgColumn, rowNode: IRowNode): boolean;
+}
+interface ICommonSelectionParams {
+    /** true or false, whatever you want to set selection to */
+    newValue: boolean;
+    /** whether to remove other selections after this selection is done */
+    clearSelection?: boolean;
+    /** true when action is NOT on this node, ie user clicked a group and this is the child of a group */
+    suppressFinishActions?: boolean;
+    /** event source, if from an event */
+    source: SelectionEventSourceType;
+    /** originating event */
+    event?: Event;
+}
+export interface ISetNodesSelectedParams extends ICommonSelectionParams {
+    /** nodes to change selection of */
+    nodes: readonly RowNode[];
+}
+export {};

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

@@ -0,0 +1,59 @@
+import type { AdvancedFilterModel } from './advancedFilterModel';
+import type { ColumnVO } from './iColumnVO';
+import type { AgGridCommon } from './iCommon';
+import type { FilterModel } from './iFilter';
+import type { IRowNode } from './iRowNode';
+import type { LoadSuccessParams } from './iServerSideRowModel';
+import type { SortModelItem } from './iSortModelItem';
+export interface IServerSideGetRowsRequest {
+    /** First row requested or undefined for all rows. */
+    startRow: number | undefined;
+    /** Index after the last row required row or undefined for all rows. */
+    endRow: number | undefined;
+    /** Columns that are currently row grouped.  */
+    rowGroupCols: ColumnVO[];
+    /** Columns that have aggregations on them.  */
+    valueCols: ColumnVO[];
+    /** Columns that have pivot on them.  */
+    pivotCols: ColumnVO[];
+    /** Defines if pivot mode is on or off.  */
+    pivotMode: boolean;
+    /** What groups the user is viewing.  */
+    groupKeys: string[];
+    /**
+     * If filtering, what the filter model is.
+     * If Advanced Filter is enabled, will be of type `AdvancedFilterModel | null`.
+     * If Advanced Filter is disabled, will be of type `FilterModel`.
+     */
+    filterModel: FilterModel | AdvancedFilterModel | null;
+    /** If sorting, what the sort model is.  */
+    sortModel: SortModelItem[];
+}
+export interface IServerSideGetRowsParams<TData = any, TContext = any> extends AgGridCommon<TData, TContext> {
+    /**
+     * Details for the request. A simple object that can be converted to JSON.
+     */
+    request: IServerSideGetRowsRequest;
+    /**
+     * The parent row node. The RootNode (level -1) if request is top level.
+     * This is NOT part fo the request as it cannot be serialised to JSON (a rowNode has methods).
+     */
+    parentNode: IRowNode<TData>;
+    /**
+     * Success callback, pass the rows back to the grid that were requested.
+     */
+    success(params: LoadSuccessParams<TData>): void;
+    /**
+     * Fail callback, tell the grid the call failed so it can adjust it's state.
+     */
+    fail(): void;
+}
+export interface IServerSideDatasource<TData = any> {
+    /**
+     * Grid calls `getRows` when it requires more rows as specified in the params.
+     * Params object contains callbacks for responding to the request.
+     */
+    getRows(params: IServerSideGetRowsParams<TData>): void;
+    /** Optional method, if your datasource has state it needs to clean up. */
+    destroy?(): void;
+}

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

@@ -0,0 +1,55 @@
+import type { ServerSideGroupLevelState } from './IServerSideStore';
+import type { IRowModel } from './iRowModel';
+import type { IRowNode } from './iRowNode';
+import type { IServerSideDatasource } from './iServerSideDatasource';
+import type { ServerSideTransaction, ServerSideTransactionResult } from './serverSideTransaction';
+export interface IServerSideRowModel<TData = any> extends IRowModel {
+    refreshStore(params?: RefreshServerSideParams): void;
+    onRowHeightChanged(): void;
+    onRowHeightChangedDebounced(): void;
+    getStoreState(): ServerSideGroupLevelState[];
+    retryLoads(): void;
+    expandAll(value: boolean): void;
+    setDatasource(datasource: IServerSideDatasource<TData>): void;
+    forEachNodeAfterFilterAndSort(callback: (node: IRowNode<TData>, index: number) => void, includeFooterNodes?: boolean): void;
+    resetRootStore(): void;
+    getBlockStates(): void;
+    setRowCount(rowCount: number, isLastRowIndexKnown?: boolean): void;
+    applyRowData(rowDataParams: LoadSuccessParams<TData>, startRow: number, route: string[]): void;
+}
+export interface IServerSideTransactionManager<TData = any> {
+    applyTransaction(transaction: ServerSideTransaction<TData>): ServerSideTransactionResult<TData> | undefined;
+    applyTransactionAsync(transaction: ServerSideTransaction<TData>, callback?: (res: ServerSideTransactionResult<TData>) => void): void;
+    flushAsyncTransactions(): void;
+}
+export interface RefreshServerSideParams {
+    /**
+     * List of group keys, pointing to the level to refresh.
+     * For example, to purge two levels down under 'Canada'and then '2002', pass in the string array ['Canada','2002'].
+     * If no route is passed, or an empty array, then the top level is refreshed.
+     */
+    route?: string[];
+    /**
+     * If true, then all rows at the level getting refreshed are immediately destroyed and 'loading' rows will appear.
+     * If false, then all rows at the level getting refreshed are kept until rows are loaded (no 'loading' rows appear).
+     */
+    purge?: boolean;
+}
+export interface LoadSuccessParams<TData = any> {
+    /**
+     * Data retrieved from the server as requested by the grid.
+     */
+    rowData: TData[];
+    /**
+     * The last row, if known, to help Infinite Scroll.
+     */
+    rowCount?: number;
+    /**
+     * Any extra information for the grid to associate with this load.
+     */
+    groupLevelInfo?: any;
+    /**
+     * The pivot fields in the response - if provided the grid will attempt to generate secondary columns.
+     */
+    pivotResultFields?: string[];
+}