@lemon-fe/kits 0.1.136 → 1.0.0-0

package/es/components/DataGrid/modules/server-side-row-model/serverSideRowModel/serverSideRowModel.js

@@ -0,0 +1,572 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+var __decorate = this && this.__decorate || function (decorators, target, key, desc) {
+  var c = arguments.length,
+      r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc,
+      d;
+  if ((typeof Reflect === "undefined" ? "undefined" : _typeof(Reflect)) === 'object' && typeof Reflect.decorate === 'function') r = Reflect.decorate(decorators, target, key, desc);else for (var i = decorators.length - 1; i >= 0; i--) {
+    if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  }
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
+import { _, Autowired, Bean, BeanStub, Constants, Events, NumberSequence, PostConstruct, PreDestroy, RowNode } from '@ag-grid-community/core';
+
+var ServerSideRowModel = /*#__PURE__*/function (_BeanStub) {
+  _inherits(ServerSideRowModel, _BeanStub);
+
+  var _super = _createSuper(ServerSideRowModel);
+
+  function ServerSideRowModel() {
+    var _this;
+
+    _classCallCheck(this, ServerSideRowModel);
+
+    _this = _super.apply(this, arguments);
+    _this.onRowHeightChanged_debounced = _.debounce(_this.onRowHeightChanged.bind(_assertThisInitialized(_this)), 100);
+    _this.pauseStoreUpdateListening = false;
+    _this.started = false;
+    return _this;
+  } // we don't implement as lazy row heights is not supported in this row model
+
+
+  _createClass(ServerSideRowModel, [{
+    key: "ensureRowHeightsValid",
+    value: function ensureRowHeightsValid() {
+      return false;
+    }
+  }, {
+    key: "start",
+    value: function start() {
+      this.started = true;
+      var datasource = this.gridOptionsWrapper.getServerSideDatasource();
+
+      if (datasource) {
+        this.setDatasource(datasource);
+      }
+    }
+  }, {
+    key: "destroyDatasource",
+    value: function destroyDatasource() {
+      if (!this.datasource) {
+        return;
+      }
+
+      if (this.datasource.destroy) {
+        this.datasource.destroy();
+      }
+
+      this.rowRenderer.datasourceChanged();
+      this.datasource = undefined;
+    }
+  }, {
+    key: "addEventListeners",
+    value: function addEventListeners() {
+      this.addManagedListener(this.eventService, Events.EVENT_NEW_COLUMNS_LOADED, this.onColumnEverything.bind(this));
+      this.addManagedListener(this.eventService, Events.EVENT_STORE_UPDATED, this.onStoreUpdated.bind(this));
+      var resetListener = this.resetRootStore.bind(this);
+      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_VALUE_CHANGED, resetListener);
+      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_PIVOT_CHANGED, resetListener);
+      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_ROW_GROUP_CHANGED, resetListener);
+      this.addManagedListener(this.eventService, Events.EVENT_COLUMN_PIVOT_MODE_CHANGED, resetListener);
+      this.verifyProps();
+    }
+  }, {
+    key: "verifyProps",
+    value: function verifyProps() {
+      if (this.gridOptionsWrapper.getInitialGroupOrderComparator() != null) {
+        var message = "AG Grid: initialGroupOrderComparator cannot be used with Server Side Row Model. If using Full Store, then provide the rows to the grid in the desired sort order. If using Infinite Scroll, then sorting is done on the server side, nothing to do with the client.";
+
+        _.doOnce(function () {
+          return console.warn(message);
+        }, 'SSRM.InitialGroupOrderComparator');
+      }
+
+      if (this.gridOptionsWrapper.isRowSelection() && this.gridOptionsWrapper.getRowIdFunc() == null) {
+        var _message = "AG Grid: getRowId callback must be provided for Server Side Row Model selection to work correctly.";
+
+        _.doOnce(function () {
+          return console.warn(_message);
+        }, 'SSRM.SelectionNeedsRowNodeIdFunc');
+      }
+    }
+  }, {
+    key: "setDatasource",
+    value: function setDatasource(datasource) {
+      // sometimes React, due to async, can call gridApi.setDatasource() before we have started.
+      // this happens when React app does this:
+      //      useEffect(() => setDatasource(ds), []);
+      // thus if we set the datasource before the grid UI has finished initialising, we do not set it,
+      // and the ssrm.start() method will set the datasoure when the grid is ready.
+      if (!this.started) {
+        return;
+      }
+
+      this.destroyDatasource();
+      this.datasource = datasource;
+      this.resetRootStore();
+    }
+  }, {
+    key: "isLastRowIndexKnown",
+    value: function isLastRowIndexKnown() {
+      var cache = this.getRootStore();
+
+      if (!cache) {
+        return false;
+      }
+
+      return cache.isLastRowIndexKnown();
+    }
+  }, {
+    key: "onColumnEverything",
+    value: function onColumnEverything() {
+      // this is a hack for one customer only, so they can suppress the resetting of the columns.
+      // The problem the customer had was they were api.setColumnDefs() after the data source came
+      // back with data. So this stops the reload from the grid after the data comes back.
+      // Once we have "AG-1591 Allow delta changes to columns" fixed, then this hack can be taken out.
+      if (this.gridOptionsWrapper.isSuppressEnterpriseResetOnNewColumns()) {
+        return;
+      } // every other customer can continue as normal and have it working!!!
+      // if first time, alwasy reset
+
+
+      if (!this.storeParams) {
+        this.resetRootStore();
+        return;
+      } // check if anything pertaining to fetching data has changed, and if it has, reset, but if
+      // it has not, don't reset
+
+
+      var rowGroupColumnVos = this.columnsToValueObjects(this.columnModel.getRowGroupColumns());
+      var valueColumnVos = this.columnsToValueObjects(this.columnModel.getValueColumns());
+      var pivotColumnVos = this.columnsToValueObjects(this.columnModel.getPivotColumns());
+      var sortModelDifferent = !_.jsonEquals(this.storeParams.sortModel, this.sortController.getSortModel());
+      var rowGroupDifferent = !_.jsonEquals(this.storeParams.rowGroupCols, rowGroupColumnVos);
+      var pivotDifferent = !_.jsonEquals(this.storeParams.pivotCols, pivotColumnVos);
+      var valuesDifferent = !_.jsonEquals(this.storeParams.valueCols, valueColumnVos);
+      var resetRequired = sortModelDifferent || rowGroupDifferent || pivotDifferent || valuesDifferent;
+
+      if (resetRequired) {
+        this.resetRootStore();
+      }
+    }
+  }, {
+    key: "destroyRootStore",
+    value: function destroyRootStore() {
+      if (!this.rootNode || !this.rootNode.childStore) {
+        return;
+      }
+
+      this.rootNode.childStore = this.destroyBean(this.rootNode.childStore);
+      this.nodeManager.clear();
+    }
+  }, {
+    key: "refreshAfterSort",
+    value: function refreshAfterSort(newSortModel, params) {
+      if (this.storeParams) {
+        this.storeParams.sortModel = newSortModel;
+      }
+
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return;
+      }
+
+      rootStore.refreshAfterSort(params);
+      this.onStoreUpdated();
+    }
+  }, {
+    key: "resetRootStore",
+    value: function resetRootStore() {
+      this.destroyRootStore();
+      this.rootNode = new RowNode(this.beans);
+      this.rootNode.group = true;
+      this.rootNode.level = -1;
+
+      if (this.datasource) {
+        this.storeParams = this.createStoreParams();
+        this.rootNode.childStore = this.createBean(this.storeFactory.createStore(this.storeParams, this.rootNode));
+        this.updateRowIndexesAndBounds();
+      } // this event shows/hides 'no rows' overlay
+
+
+      var rowDataChangedEvent = {
+        type: Events.EVENT_ROW_DATA_UPDATED
+      };
+      this.eventService.dispatchEvent(rowDataChangedEvent); // this gets the row to render rows (or remove the previously rendered rows, as it's blank to start).
+      // important to NOT pass in an event with keepRenderedRows or animate, as we want the renderer
+      // to treat the rows as new rows, as it's all new data
+
+      this.dispatchModelUpdated(true);
+    }
+  }, {
+    key: "columnsToValueObjects",
+    value: function columnsToValueObjects(columns) {
+      var _this2 = this;
+
+      return columns.map(function (col) {
+        return {
+          id: col.getId(),
+          aggFunc: col.getAggFunc(),
+          displayName: _this2.columnModel.getDisplayNameForColumn(col, 'model'),
+          field: col.getColDef().field
+        };
+      });
+    }
+  }, {
+    key: "createStoreParams",
+    value: function createStoreParams() {
+      var rowGroupColumnVos = this.columnsToValueObjects(this.columnModel.getRowGroupColumns());
+      var valueColumnVos = this.columnsToValueObjects(this.columnModel.getValueColumns());
+      var pivotColumnVos = this.columnsToValueObjects(this.columnModel.getPivotColumns());
+      var dynamicRowHeight = this.gridOptionsWrapper.isDynamicRowHeight();
+      var params = {
+        // the columns the user has grouped and aggregated by
+        valueCols: valueColumnVos,
+        rowGroupCols: rowGroupColumnVos,
+        pivotCols: pivotColumnVos,
+        pivotMode: this.columnModel.isPivotMode(),
+        // sort and filter model
+        filterModel: this.filterManager.getFilterModel(),
+        sortModel: this.sortListener.extractSortModel(),
+        datasource: this.datasource,
+        lastAccessedSequence: new NumberSequence(),
+        // blockSize: blockSize == null ? 100 : blockSize,
+        dynamicRowHeight: dynamicRowHeight
+      };
+      return params;
+    }
+  }, {
+    key: "getParams",
+    value: function getParams() {
+      return this.storeParams;
+    }
+  }, {
+    key: "dispatchModelUpdated",
+    value: function dispatchModelUpdated() {
+      var reset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+      var modelUpdatedEvent = {
+        type: Events.EVENT_MODEL_UPDATED,
+        animate: !reset,
+        keepRenderedRows: !reset,
+        newPage: false,
+        newData: false
+      };
+      this.eventService.dispatchEvent(modelUpdatedEvent);
+    }
+  }, {
+    key: "onStoreUpdated",
+    value: function onStoreUpdated() {
+      // sometimes if doing a batch update, we do the batch first,
+      // then call onStoreUpdated manually. eg expandAll() method.
+      if (this.pauseStoreUpdateListening) {
+        return;
+      }
+
+      this.updateRowIndexesAndBounds();
+      this.dispatchModelUpdated();
+    }
+    /** This method is debounced. It is used for row auto-height. If we don't debounce,
+     * then the Row Models will end up recalculating each row position
+     * for each row height change and result in the Row Renderer laying out rows.
+     * This is particularly bad if using print layout, and showing eg 1,000 rows,
+     * each row will change it's height, causing Row Model to update 1,000 times.
+     */
+
+  }, {
+    key: "onRowHeightChangedDebounced",
+    value: function onRowHeightChangedDebounced() {
+      this.onRowHeightChanged_debounced();
+    }
+  }, {
+    key: "onRowHeightChanged",
+    value: function onRowHeightChanged() {
+      this.updateRowIndexesAndBounds();
+      this.dispatchModelUpdated();
+    }
+  }, {
+    key: "updateRowIndexesAndBounds",
+    value: function updateRowIndexesAndBounds() {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return;
+      }
+
+      rootStore.setDisplayIndexes(new NumberSequence(), {
+        value: 0
+      });
+    }
+  }, {
+    key: "retryLoads",
+    value: function retryLoads() {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return;
+      }
+
+      rootStore.retryLoads();
+      this.onStoreUpdated();
+    }
+  }, {
+    key: "getRow",
+    value: function getRow(index) {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return undefined;
+      }
+
+      return rootStore.getRowUsingDisplayIndex(index);
+    }
+  }, {
+    key: "expandAll",
+    value: function expandAll(value) {
+      // if we don't pause store updating, we are needlessly
+      // recalculating row-indexes etc, and also getting rendering
+      // engine to re-render (listens on ModelUpdated event)
+      this.pauseStoreUpdateListening = true;
+      this.forEachNode(function (node) {
+        if (node.group && !node.stub) {
+          node.setExpanded(value);
+        }
+      });
+      this.pauseStoreUpdateListening = false;
+      this.onStoreUpdated();
+    }
+  }, {
+    key: "refreshAfterFilter",
+    value: function refreshAfterFilter(newFilterModel, params) {
+      if (this.storeParams) {
+        this.storeParams.filterModel = newFilterModel;
+      }
+
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return;
+      }
+
+      rootStore.refreshAfterFilter(params);
+      this.onStoreUpdated();
+    }
+  }, {
+    key: "getRootStore",
+    value: function getRootStore() {
+      if (this.rootNode && this.rootNode.childStore) {
+        return this.rootNode.childStore;
+      }
+    }
+  }, {
+    key: "getRowCount",
+    value: function getRowCount() {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return 0;
+      }
+
+      return rootStore.getDisplayIndexEnd();
+    }
+  }, {
+    key: "getTopLevelRowCount",
+    value: function getTopLevelRowCount() {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return 1;
+      }
+
+      return rootStore.getRowCount();
+    }
+  }, {
+    key: "getTopLevelRowDisplayedIndex",
+    value: function getTopLevelRowDisplayedIndex(topLevelIndex) {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return topLevelIndex;
+      }
+
+      return rootStore.getTopLevelRowDisplayedIndex(topLevelIndex);
+    }
+  }, {
+    key: "getRowBounds",
+    value: function getRowBounds(index) {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        var rowHeight = this.gridOptionsWrapper.getRowHeightAsNumber();
+        return {
+          rowTop: 0,
+          rowHeight: rowHeight
+        };
+      }
+
+      return rootStore.getRowBounds(index);
+    }
+  }, {
+    key: "getRowIndexAtPixel",
+    value: function getRowIndexAtPixel(pixel) {
+      var rootStore = this.getRootStore();
+
+      if (pixel <= 0 || !rootStore) {
+        return 0;
+      }
+
+      return rootStore.getRowIndexAtPixel(pixel);
+    }
+  }, {
+    key: "isEmpty",
+    value: function isEmpty() {
+      return false;
+    }
+  }, {
+    key: "isRowsToRender",
+    value: function isRowsToRender() {
+      return this.getRootStore() != null && this.getRowCount() > 0;
+    }
+  }, {
+    key: "getType",
+    value: function getType() {
+      return Constants.ROW_MODEL_TYPE_SERVER_SIDE;
+    }
+  }, {
+    key: "forEachNode",
+    value: function forEachNode(callback) {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return;
+      }
+
+      rootStore.forEachNodeDeep(callback);
+    }
+  }, {
+    key: "forEachNodeAfterFilterAndSort",
+    value: function forEachNodeAfterFilterAndSort(callback) {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return;
+      }
+
+      rootStore.forEachNodeDeepAfterFilterAndSort(callback);
+    }
+  }, {
+    key: "executeOnStore",
+    value: function executeOnStore(route, callback) {
+      var rootStore = this.getRootStore();
+
+      if (!rootStore) {
+        return;
+      }
+
+      var storeToExecuteOn = rootStore.getChildStore(route);
+
+      if (storeToExecuteOn) {
+        callback(storeToExecuteOn);
+      }
+    }
+  }, {
+    key: "refreshStore",
+    value: function refreshStore() {
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var route = params.route ? params.route : [];
+      this.executeOnStore(route, function (store) {
+        return store.refreshStore(params.purge == true);
+      });
+    }
+  }, {
+    key: "getStoreState",
+    value: function getStoreState() {
+      var res = [];
+      var rootStore = this.getRootStore();
+
+      if (rootStore) {
+        rootStore.addStoreStates(res);
+      }
+
+      return res;
+    }
+  }, {
+    key: "getNodesInRangeForSelection",
+    value: function getNodesInRangeForSelection(firstInRange, lastInRange) {
+      if (_.exists(lastInRange) && firstInRange.parent !== lastInRange.parent) {
+        return [];
+      }
+
+      return firstInRange.parent.childStore.getRowNodesInRange(lastInRange, firstInRange);
+    }
+  }, {
+    key: "getRowNode",
+    value: function getRowNode(id) {
+      var result;
+      this.forEachNode(function (rowNode) {
+        if (rowNode.id === id) {
+          result = rowNode;
+        }
+
+        if (rowNode.detailNode && rowNode.detailNode.id === id) {
+          result = rowNode.detailNode;
+        }
+      });
+      return result;
+    }
+  }, {
+    key: "isRowPresent",
+    value: function isRowPresent(rowNode) {
+      var foundRowNode = this.getRowNode(rowNode.id);
+      return !!foundRowNode;
+    }
+  }]);
+
+  return ServerSideRowModel;
+}(BeanStub);
+
+__decorate([Autowired('columnModel')], ServerSideRowModel.prototype, 'columnModel', void 0);
+
+__decorate([Autowired('filterManager')], ServerSideRowModel.prototype, 'filterManager', void 0);
+
+__decorate([Autowired('sortController')], ServerSideRowModel.prototype, 'sortController', void 0);
+
+__decorate([Autowired('rowRenderer')], ServerSideRowModel.prototype, 'rowRenderer', void 0);
+
+__decorate([Autowired('ssrmSortService')], ServerSideRowModel.prototype, 'sortListener', void 0);
+
+__decorate([Autowired('ssrmNodeManager')], ServerSideRowModel.prototype, 'nodeManager', void 0);
+
+__decorate([Autowired('ssrmStoreFactory')], ServerSideRowModel.prototype, 'storeFactory', void 0);
+
+__decorate([Autowired('beans')], ServerSideRowModel.prototype, 'beans', void 0);
+
+__decorate([PreDestroy], ServerSideRowModel.prototype, 'destroyDatasource', null);
+
+__decorate([PostConstruct], ServerSideRowModel.prototype, 'addEventListeners', null);
+
+__decorate([PreDestroy], ServerSideRowModel.prototype, 'destroyRootStore', null);
+
+ServerSideRowModel = __decorate([Bean('rowModel')], ServerSideRowModel);
+export { ServerSideRowModel };

package/es/components/DataGrid/modules/server-side-row-model/serverSideRowModel/stores/fullStore.d.ts

@@ -0,0 +1,108 @@
+import {
+  IServerSideStore,
+  LoadSuccessParams,
+  NumberSequence,
+  RowBounds,
+  RowNode,
+  RowNodeBlock,
+  ServerSideGroupLevelParams,
+  ServerSideGroupLevelState,
+  ServerSideTransaction,
+  ServerSideTransactionResult,
+  StoreRefreshAfterParams,
+} from '@ag-grid-community/core';
+import { SSRMParams } from '../serverSideRowModel';
+export declare class FullStore extends RowNodeBlock implements IServerSideStore {
+  private storeUtils;
+  private blockUtils;
+  private columnModel;
+  private rowNodeBlockLoader;
+  private rowNodeSorter;
+  private sortController;
+  private nodeManager;
+  private filterManager;
+  private transactionManager;
+  private readonly level;
+  private readonly groupLevel;
+  private readonly leafGroup;
+  private readonly ssrmParams;
+  private readonly parentRowNode;
+  private nodeIdSequence;
+  private usingTreeData;
+  private allRowNodes;
+  private nodesAfterFilter;
+  private nodesAfterSort;
+  private allNodesMap;
+  private groupField;
+  private rowGroupColumn;
+  private nodeIdPrefix;
+  private displayIndexStart;
+  private displayIndexEnd;
+  private topPx;
+  private heightPx;
+  private info;
+  constructor(
+    ssrmParams: SSRMParams,
+    storeParams: ServerSideGroupLevelParams,
+    parentRowNode: RowNode,
+  );
+  private postConstruct;
+  private destroyRowNodes;
+  private initialiseRowNodes;
+  getBlockStateJson(): {
+    id: string;
+    state: any;
+  };
+  protected loadFromDatasource(): void;
+  getStartRow(): number;
+  getEndRow(): number;
+  private createDataNode;
+  private prefixId;
+  protected processServerFail(): void;
+  protected processServerResult(params: LoadSuccessParams): void;
+  private createOrRecycleNodes;
+  private flushAsyncTransactions;
+  private filterAndSortNodes;
+  private sortRowNodes;
+  private filterRowNodes;
+  clearDisplayIndexes(): void;
+  getDisplayIndexEnd(): number | undefined;
+  isDisplayIndexInStore(displayIndex: number): boolean;
+  setDisplayIndexes(
+    displayIndexSeq: NumberSequence,
+    nextRowTop: {
+      value: number;
+    },
+  ): void;
+  forEachNodeDeep(
+    callback: (rowNode: RowNode, index: number) => void,
+    sequence?: NumberSequence,
+  ): void;
+  forEachNodeDeepAfterFilterAndSort(
+    callback: (rowNode: RowNode, index: number) => void,
+    sequence?: NumberSequence,
+  ): void;
+  getRowUsingDisplayIndex(displayRowIndex: number): RowNode | undefined;
+  getRowBounds(index: number): RowBounds | null;
+  isPixelInRange(pixel: number): boolean;
+  getRowIndexAtPixel(pixel: number): number | null;
+  getChildStore(keys: string[]): IServerSideStore | null;
+  private forEachChildStoreShallow;
+  refreshAfterFilter(params: StoreRefreshAfterParams): void;
+  refreshAfterSort(params: StoreRefreshAfterParams): void;
+  applyTransaction(transaction: ServerSideTransaction): ServerSideTransactionResult;
+  private updateSelection;
+  private executeAdd;
+  private executeRemove;
+  private executeUpdate;
+  private lookupRowNode;
+  addStoreStates(result: ServerSideGroupLevelState[]): void;
+  refreshStore(purge: boolean): void;
+  retryLoads(): void;
+  private scheduleLoad;
+  private fireStoreUpdatedEvent;
+  getRowCount(): number;
+  getTopLevelRowDisplayedIndex(topLevelIndex: number): number;
+  isLastRowIndexKnown(): boolean;
+  getRowNodesInRange(firstInRange: RowNode, lastInRange: RowNode): RowNode[];
+}