@genesislcap/grid-pro 15.30.0 → 15.30.1

package/dist/esm/grid-pro.js

@@ -414,7 +414,10 @@ export class GridPro extends LifecycleMixin(FoundationElement) {
     handleDataChanged(event) {
         var _a, _b, _c;
         const { changes } = event.detail;
-        if (!this.gridApi)
+        // Every datasource emits this for consumers, but row transactions are a client-side row
+        // model API: the server-side datasource drives the grid through apply-server-side-transaction,
+        // and applyTransaction on that model is a no-op that logs an AG Grid warning per event.
+        if (!this.gridApi || this.isServerSide)
             return;
         if (((_a = changes.add) === null || _a === void 0 ? void 0 : _a.length) > 0) {
             if (this.asyncAdd) {

package/dist/grid-pro.api.json

@@ -5757,7 +5757,7 @@
                 },
                 {
                   "kind": "Content",
-                  "text": "{\n        add?: any[];\n        remove?: any[];\n        update?: any[];\n        insertIndex?: number;\n    }"
+                  "text": "{\n        add?: any[];\n        remove?: any[];\n        update?: any[];\n        addIndex?: number;\n        insertIndex?: number;\n    }"
                 },
                 {
                   "kind": "Content",
@@ -18679,6 +18679,37 @@
               "isProtected": false,
               "isAbstract": false
             },
+            {
+              "kind": "Property",
+              "canonicalReference": "@genesislcap/grid-pro!GridProBaseDatasource#serializer:member",
+              "docComment": "",
+              "excerptTokens": [
+                {
+                  "kind": "Content",
+                  "text": "serializer: "
+                },
+                {
+                  "kind": "Reference",
+                  "text": "JSONSerializer",
+                  "canonicalReference": "@genesislcap/foundation-utils!JSONSerializer:interface"
+                },
+                {
+                  "kind": "Content",
+                  "text": ";"
+                }
+              ],
+              "isReadonly": false,
+              "isOptional": false,
+              "releaseTag": "Public",
+              "name": "serializer",
+              "propertyTypeTokenRange": {
+                "startIndex": 1,
+                "endIndex": 2
+              },
+              "isStatic": false,
+              "isProtected": false,
+              "isAbstract": false
+            },
             {
               "kind": "Method",
               "canonicalReference": "@genesislcap/grid-pro!GridProBaseDatasource#setDisconnected:member(1)",
@@ -24634,7 +24665,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/grid-pro!GridProInfiniteDatasource:class",
-          "docComment": "/**\n * A Genesis Datasource element for AG Grid's Infinite Row Model.\n *\n * @remarks\n *\n * The Infinite Row Model is part of AG Grid Community (free) and provides: - Lazy loading of data as user scrolls - Server-side sorting and filtering - Simple infinite scroll without grouping/aggregation - Live updates for DATASERVER resources: the DATA_LOGON stream the grid pages over pushes every change, so no flag or second subscription is needed\n *\n * REQUEST_SERVER resources are read on demand only - a change on the server shows up when the grid re-reads (scroll, filter/sort change, or an explicit refresh), not live. The exception is a write made through this session: a commit ACK for an event listed in `pollTriggerEvents` re-reads the loaded blocks, so entity-management CRUD is reflected immediately.\n *\n * Like the other datasources, consumer options passed as `deferredGridOptions` (including via entity-management's `gridOptions` with `datasource-type=\"infinite\"`) are merged over this element's defaults in `init()`.\n *\n * Use this instead of Server-Side Row Model when you don't need Enterprise features like row grouping, aggregation, or pivoting.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the infinite grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`\n *\n * @fires\n *\n * refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * datasource-data-cleared - Fired when infinite row data is cleared. detail: `DataClearedEventDetail`\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @see\n *\n * https://www.ag-grid.com/javascript-data-grid/infinite-scrolling/\n *\n * @beta\n */\n",
+          "docComment": "/**\n * A Genesis Datasource element for AG Grid's Infinite Row Model.\n *\n * @remarks\n *\n * The Infinite Row Model is part of AG Grid Community (free) and provides: - Lazy loading of data as user scrolls - Server-side sorting and filtering - Simple infinite scroll without grouping/aggregation - Live updates for DATASERVER resources: the DATA_LOGON stream the grid pages over pushes every change, so no flag or second subscription is needed\n *\n * REQUEST_SERVER resources are read on demand only - a change on the server shows up when the grid re-reads (scroll, filter/sort change, or an explicit refresh), not live. The exception is a write made through this session: a commit ACK for an event listed in `pollTriggerEvents` re-reads the loaded blocks, so entity-management CRUD is reflected immediately.\n *\n * Like the other datasources, consumer options passed as `deferredGridOptions` (including via entity-management's `gridOptions` with `datasource-type=\"infinite\"`) are merged over this element's defaults in `init()`.\n *\n * Use this instead of Server-Side Row Model when you don't need Enterprise features like row grouping, aggregation, or pivoting.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the infinite grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * datasource-data-changed - Fired when rows are delivered to the grid, a DATASERVER push changes them, or a re-read no longer returns them; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`\n *\n * @fires\n *\n * set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`\n *\n * @fires\n *\n * refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`\n *\n * @fires\n *\n * datasource-loading-finished - Fired when the first block comes back with rows\n *\n * @fires\n *\n * datasource-no-data-available - Fired when the first block comes back empty\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @see\n *\n * https://www.ag-grid.com/javascript-data-grid/infinite-scrolling/\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -25476,7 +25507,7 @@
         {
           "kind": "Class",
           "canonicalReference": "@genesislcap/grid-pro!GridProServerSideDatasource:class",
-          "docComment": "/**\n * A Genesis Datasource element, for server-side | SSRM-compatible data fetching and used exclusively by the GridPro element.\n *\n * @remarks\n *\n * Only supports Server-Side Row Model. Requires `@ag-grid-enterprise/server-side-row-model` setup and valid AG Grid Enterprise license.\n *\n * **Supported resources**: DATASERVER resources, and REQUEST_SERVER (req/rep) resources that declare `criteriaOnlyRequest`. A req/rep resource without it reports a `resource-type` error and no datasource is attached to the grid.\n *\n * **Custom Sort Indicators**: This datasource automatically applies custom sort indicators that are always visible (instead of only on hover). Sortable columns will show a subtle sort icon even when not sorted, and active sort indicators will be more prominent. The custom styling uses AG Grid's native icon font for consistency with the grid theme.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes\n *\n * @fires\n *\n * datasource-no-data-available - Fired when loading finishes with an empty row set\n *\n * @fires\n *\n * datasource-data-changed - Fired when row data changes from applied stream transactions. detail: `DataChangedEventDetail`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`\n *\n * @fires\n *\n * set-server-side-datasource - Fired to attach or clear the server-side row model datasource\n *\n * @fires\n *\n * datasource-loading-started - Fired when a server-side load cycle starts\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (e.g. server-side styling). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove a CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off server-side grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the server-side grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @fires\n *\n * datasource-data-cleared - Fired when server-side row data is cleared. detail: `DataClearedEventDetail`\n *\n * @fires\n *\n * apply-server-side-transaction - Fired to apply a server-side row transaction\n *\n * @fires\n *\n * datasource-ready - Fired when the host grid is ready to start loading data\n *\n * @beta\n */\n",
+          "docComment": "/**\n * A Genesis Datasource element, for server-side | SSRM-compatible data fetching and used exclusively by the GridPro element.\n *\n * @remarks\n *\n * Only supports Server-Side Row Model. Requires `@ag-grid-enterprise/server-side-row-model` setup and valid AG Grid Enterprise license.\n *\n * **Supported resources**: DATASERVER resources, and REQUEST_SERVER (req/rep) resources that declare `criteriaOnlyRequest`. A req/rep resource without it reports a `resource-type` error and no datasource is attached to the grid.\n *\n * **Custom Sort Indicators**: This datasource automatically applies custom sort indicators that are always visible (instead of only on hover). Sortable columns will show a subtle sort icon even when not sorted, and active sort indicators will be more prominent. The custom styling uses AG Grid's native icon font for consistency with the grid theme.\n *\n * @fires\n *\n * base-datasource-error - Fired when a datasource error is reported. detail: `BaseDatasourceErrorEventDetail`\n *\n * @fires\n *\n * datasource-error - Fired when a datasource error occurs (for grid integration). detail: `DatasourceErrorEventDetail`\n *\n * @fires\n *\n * base-datasource-connected - Fired when error state is cleared after connection succeeds\n *\n * @fires\n *\n * datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes\n *\n * @fires\n *\n * datasource-no-data-available - Fired when loading finishes with an empty row set\n *\n * @fires\n *\n * datasource-data-changed - Fired when rows are delivered to the grid, a live stream pushes a change, a poll detects one, or a re-read no longer returns a row; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`\n *\n * @fires\n *\n * cache-filter-config - Fired to persist filter configuration for the grid\n *\n * @fires\n *\n * refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`\n *\n * @fires\n *\n * set-server-side-datasource - Fired to attach or clear the server-side row model datasource\n *\n * @fires\n *\n * datasource-loading-started - Fired when a server-side load cycle starts\n *\n * @fires\n *\n * add-grid-css-class - Fired to add a CSS class on the grid host (e.g. server-side styling). detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * remove-grid-css-class - Fired to remove a CSS class from the grid host. detail: `GridCssClassEventDetail`\n *\n * @fires\n *\n * datasource-initialize - Fired to hand off server-side grid options. detail: `InitializeEventDetail`\n *\n * @fires\n *\n * datasource-init - Fired when the server-side grid model should initialize data\n *\n * @fires\n *\n * datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`\n *\n * @fires\n *\n * datasource-filters-restored - Fired when persisted filters are reapplied\n *\n * @fires\n *\n * datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`\n *\n * @fires\n *\n * apply-server-side-transaction - Fired to apply a server-side row transaction\n *\n * @fires\n *\n * datasource-ready - Fired when the host grid is ready to start loading data\n *\n * @beta\n */\n",
           "excerptTokens": [
             {
               "kind": "Content",
@@ -26003,37 +26034,6 @@
               "isOptional": false,
               "isAbstract": false,
               "name": "restart"
-            },
-            {
-              "kind": "Property",
-              "canonicalReference": "@genesislcap/grid-pro!GridProServerSideDatasource#serializer:member",
-              "docComment": "",
-              "excerptTokens": [
-                {
-                  "kind": "Content",
-                  "text": "serializer: "
-                },
-                {
-                  "kind": "Reference",
-                  "text": "JSONSerializer",
-                  "canonicalReference": "@genesislcap/foundation-utils!JSONSerializer:interface"
-                },
-                {
-                  "kind": "Content",
-                  "text": ";"
-                }
-              ],
-              "isReadonly": false,
-              "isOptional": false,
-              "releaseTag": "Beta",
-              "name": "serializer",
-              "propertyTypeTokenRange": {
-                "startIndex": 1,
-                "endIndex": 2
-              },
-              "isStatic": false,
-              "isProtected": false,
-              "isAbstract": false
             }
           ],
           "extendsTokenRange": {
@@ -35704,7 +35704,7 @@
             },
             {
               "kind": "Content",
-              "text": "<void>;\n    errorHandlerFunc?: (message: string, type: string) => void;\n    onNoDataAvailableFunc?: () => void;\n    onDataAvailableFunc?: () => void;\n    resourceName: string;\n    resourceParams?: "
+              "text": "<void>;\n    errorHandlerFunc?: (message: string, type: string) => void;\n    onNoDataAvailableFunc?: () => void;\n    onDataAvailableFunc?: () => void;\n    onRowsDeliveredFunc?: (rows: any[]) => void;\n    onRowsWithdrawnFunc?: (rowIds: string[]) => void;\n    resourceName: string;\n    resourceParams?: "
             },
             {
               "kind": "Reference",

package/dist/grid-pro.d.ts

@@ -1430,8 +1430,12 @@ export declare const csvExportParams: CsvExportParams;
 export declare interface DataChangedEventDetail {
     changes: {
         add?: any[];
+        /** Row-id-only objects (`{ [rowId]: id }`) for the rows that left the grid. */
         remove?: any[];
         update?: any[];
+        /** Where `add` rows were inserted, as AG Grid's `RowDataTransaction.addIndex`. */
+        addIndex?: number;
+        /** @deprecated Never populated; the emitted field is `addIndex`. */
         insertIndex?: number;
     };
 }
@@ -2562,7 +2566,12 @@ export declare class GenesisGridDatasourceElement extends GenesisGridDatasourceE
     protected criteriaFromFilters: Map<string, string>;
     protected update: BehaviorSubject<Map<string, string>>;
     protected datasourceOptions(): DatasourceOptions;
-    private buildCriteria;
+    /**
+     * The criteria the resource should be read with: the `criteria` attribute plus anything added
+     * through `setFilter()`.
+     * @internal
+     */
+    protected buildCriteria(): string;
     setFilter(fieldName: string, newFilter: string): void;
     removeFilter(fieldName: string): void;
     get isRequestServer(): boolean;
@@ -2623,12 +2632,7 @@ declare const GenesisGridDatasourceElement_base: new () => {
     addEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
     addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
     removeEventListener<K extends keyof HTMLElementEventMap>(type: K, listener: (this: HTMLElement, ev: HTMLElementEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
-    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options
-    /**
-    * Optional parameter that allows you to select a subset of fields from the query if the client is not interested in receiving all of them.
-    * @remarks DATASERVER only.
-    */
-    ?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
     readonly attributes: NamedNodeMap;
     get classList(): DOMTokenList;
     set classList(value: string): any;
@@ -2693,7 +2697,15 @@ declare const GenesisGridDatasourceElement_base: new () => {
     removeAttribute(qualifiedName: string): void;
     removeAttributeNS(namespace: string | null, localName: string): void;
     removeAttributeNode(attr: Attr): Attr;
-    requestFullscreen(options?: FullscreenOptions): Promise<void>;
+    requestFullscreen(options
+    /**
+    * Returns whether the `row-id` attribute is the default one, depending on the resource type.
+    * @internal
+    */
+    ? /**
+    * Returns whether the `row-id` attribute is the default one, depending on the resource type.
+    * @internal
+    */: FullscreenOptions): Promise<void>;
     requestPointerLock(options?: PointerLockOptions): Promise<void>;
     scroll(options?: ScrollToOptions): void;
     scroll(x: number, y: number): void;
@@ -2967,6 +2979,15 @@ declare class GenesisInfiniteDatasource implements IDatasource {
     private rowId;
     private baseCriteria;
     private isRequestServer;
+    /**
+     * The `order-by` attribute, used when the grid itself is unsorted.
+     * @remarks DATASERVER takes the name of an index on the query; REQUEST_SERVER takes a column
+     * with the direction inline.
+     * @internal
+     */
+    private defaultOrderBy?;
+    /** The `reverse` attribute, applied alongside `defaultOrderBy` on DATASERVER. @internal */
+    private defaultReverse;
     private createSnapshotFunc;
     private createDataserverStreamFunc;
     private getMoreRowsFunc;
@@ -2974,17 +2995,69 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * Called when an unsolicited batch changes which rows exist or their order (an INSERT or a
      * DELETE). The cache cannot be patched in place for those - a created row arrives at the end
      * rather than in sort position, and a delete below the delivered watermark is skipped to keep
-     * slice offsets stable - so the rows have to be re-read.
+     * slice offsets stable - so the rows have to be re-read. Receives the pushed change so the
+     * host can report it before the re-read.
      * @internal
      */
     private onRowsInvalidatedFunc?;
     /**
      * Called when an unsolicited batch only modified rows already held. The cache is patched in
-     * place, so the grid just needs to re-render its blocks.
+     * place, so the grid just needs to re-render its blocks. Receives the pushed change so the
+     * host can report it.
      * @internal
      */
     private onRowsUpdatedFunc?;
+    /**
+     * Called with the rows just handed to AG Grid for a block, on either transport. This is the
+     * only point at which rows leave the datasource, so it is where the host learns which rows
+     * the grid holds (a re-read after a refresh delivers the same rows again).
+     * @internal
+     */
+    private onRowsDeliveredFunc?;
+    /**
+     * Called with the ids of rows a re-read of a block no longer returned: they left the grid
+     * (deleted on the server, or moved into a block that reports them again).
+     * @internal
+     */
+    private onRowsWithdrawnFunc?;
+    /**
+     * Called when a filter or sort change drops every row the grid held, on either transport, so
+     * the host forgets them too. AG Grid purges its own cache on those changes.
+     * @internal
+     */
+    private onRowCacheResetFunc?;
+    /**
+     * Called when the first block comes back with no rows, and when it comes back with rows, so
+     * the host can raise the same no-data / loading-finished events the server-side model does.
+     * @internal
+     */
+    private onNoDataAvailableFunc?;
+    /** @internal */
+    private onDataAvailableFunc?;
     private errorHandlerFunc;
+    /** Which rows each delivered block carried, for withdrawal and eviction reporting. @internal */
+    private ledger;
+    /**
+     * Bumped whenever the rows this datasource was reading for are dropped (a teardown, or a
+     * filter/sort change). A REQUEST_SERVER reply that resolves for an earlier generation was read
+     * for a cache the grid no longer has.
+     * @remarks Deliberately a generation rather than a "destroyed" flag: AG Grid calls `destroy()`
+     * on the datasource bean it then keeps using (`InfiniteRowModel.start()` re-applies the
+     * `datasource` grid option, and `setDatasource` destroys the previous one first), so a sticky
+     * flag would disable the instance the grid is still driving.
+     * @internal
+     */
+    private loadGeneration;
+    /**
+     * Set once the host has dropped this instance for a replacement (a criteria change, a resource
+     * change, teardown). AG Grid keeps calling the bean it was given until the new one is attached,
+     * and its purge re-requests blocks immediately, so without this the replaced instance keeps
+     * reading with its captured criteria and reporting those rows to the host as delivered.
+     * @remarks Distinct from `destroy()`, which AG Grid itself calls on a bean it then keeps using;
+     * only the host calls `detach()`, and only when it will never use this instance again.
+     * @internal
+     */
+    private detached;
     /**
      * Max time a DATASERVER block may stay pending before the safety valve resolves it with the
      * rows accumulated so far.
@@ -3007,11 +3080,20 @@ declare class GenesisInfiniteDatasource implements IDatasource {
     private dataserverStreamSubscription;
     private sourceRef;
     /**
-     * Identifies the CRITERIA_MATCH/ORDER_BY the current subscription was opened with; a change
-     * means the subscription has to be re-opened, as those are DATA_LOGON parameters.
+     * Identifies the CRITERIA_MATCH/ORDER_BY the current rows were read with. A change means AG
+     * Grid has dropped every block (it purges on filter/sort changes): on DATASERVER the
+     * subscription has to be re-opened, as those are DATA_LOGON parameters, and on both transports
+     * the host is told its held rows are gone.
      * @internal
      */
     private subscriptionKey;
+    /**
+     * Identifies the CRITERIA_MATCH/ORDER_BY the rows the host currently holds were read with.
+     * Unlike `subscriptionKey` this survives a subscription teardown, so a filter or sort change
+     * is still recognised as one when a live push tore the subscription down first.
+     * @internal
+     */
+    private rowCacheKey;
     /**
      * Session-cumulative row cache, keyed by row id. A Map preserves insertion order, so the
      * cache can be sliced by block range; Genesis splits batches across messages and later
@@ -3046,8 +3128,11 @@ declare class GenesisInfiniteDatasource implements IDatasource {
         createSnapshotFunc: (params?: any) => Promise<RequestServerResult | FilteredDataServerResult>;
         createDataserverStreamFunc?: (params?: any) => SocketObservable<FilteredDataServerResult>;
         getMoreRowsFunc?: (sourceRef: string) => Promise<unknown>;
-        onRowsInvalidatedFunc?: () => void;
-        onRowsUpdatedFunc?: () => void;
+        onRowsInvalidatedFunc?: (change: FilteredDataServerResult) => void;
+        onRowsUpdatedFunc?: (change: FilteredDataServerResult) => void;
+        onRowsDeliveredFunc?: (rows: any[]) => void;
+        onRowsWithdrawnFunc?: (rowIds: string[]) => void;
+        onRowCacheResetFunc?: () => void;
         errorHandlerFunc: (message: string, type: string) => void;
         resourceName: string;
         resourceParams: any;
@@ -3057,6 +3142,10 @@ declare class GenesisInfiniteDatasource implements IDatasource {
         rowId: string;
         baseCriteria?: string;
         isRequestServer: boolean;
+        defaultOrderBy?: string;
+        defaultReverse?: boolean;
+        onNoDataAvailableFunc?: () => void;
+        onDataAvailableFunc?: () => void;
     });
     /**
      * Builds request parameters for REQUEST_SERVER resources.
@@ -3090,6 +3179,23 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * outstanding at once, and each settles as soon as the cache covers its range.
      * @internal
      */
+    /**
+     * Notes the CRITERIA_MATCH/ORDER_BY a block is being read with. A change means AG Grid has
+     * purged its cache and restarted from block 0: on DATASERVER the subscription is re-opened
+     * (those are DATA_LOGON parameters), and on both transports the host is told the rows it held
+     * are gone, so the rows read under the new filter or sort are reported as new.
+     * @internal
+     */
+    /**
+     * The sort a block is read with: the grid's own sort model when the user has sorted, and the
+     * `order-by` / `reverse` attributes otherwise.
+     * @remarks Without the fallback those attributes reached the comms datasource but were then
+     * dropped, because the logon builder removes ORDER_BY and REVERSE whenever the grid is
+     * unsorted. Sorting from the grid still wins, as it is the more specific instruction.
+     * @internal
+     */
+    private resolveSortConfig;
+    private noteRequestKey;
     private getDataserverRows;
     /**
      * Keeps pulling batches while blocks are still waiting.
@@ -3138,6 +3244,19 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * @internal
      */
     private settleBlock;
+    /**
+     * Raises the no-data / data-available hooks for the first block, as the server-side resource
+     * does. Later blocks say nothing: the question is whether the resource has any rows at all,
+     * and the answer cannot change once the first block has been served.
+     * @internal
+     */
+    private notifyDataAvailability;
+    /**
+     * Reports rows handed to the grid for a block, then the rows a re-read of that block no longer
+     * carries and the rows whose block the grid evicted.
+     * @internal
+     */
+    private deliverRows;
     /**
      * Warns when the view filled up before the data ran out.
      * @remarks The server stops sending at MAX_VIEW rows and reports MORE_ROWS false, which is
@@ -3163,7 +3282,23 @@ declare class GenesisInfiniteDatasource implements IDatasource {
      * @internal
      */
     private teardownDataserverSubscription;
+    /**
+     * Drops the subscription and the cached rows.
+     * @remarks AG Grid calls this on the bean it then keeps using (`InfiniteRowModel.start()`
+     * re-applies the `datasource` grid option, and `setDatasource` destroys the previous one
+     * first), and it can land while a block request is in flight. So it must leave the datasource
+     * able to serve that reply and the next `getRows`: it drops the subscription, not the instance.
+     */
     destroy?(): void;
+    /**
+     * Drops this instance for good: the host is replacing it, so it must stop serving the grid and
+     * stop reporting rows, even though AG Grid still holds it as its `datasource` until the
+     * replacement is attached.
+     * @remarks Deliberately separate from `destroy()`, which AG Grid calls on a bean it then keeps
+     * using (`InfiniteRowModel.start()` re-applies the `datasource` grid option, and `setDatasource`
+     * destroys the previous one first).
+     */
+    detach(): void;
 }
 
 /**
@@ -4243,19 +4378,71 @@ declare const GridPro_base: (new (...args: any[]) => {
 }) & typeof FoundationElement;
 
 export declare class GridProBaseDatasource extends GenesisGridDatasourceElement {
+    serializer: JSONSerializer;
     protected dataSubWasLoggedOff: boolean;
     keepColDefsOnClearRowData: boolean;
     rowData: Map<string, any>;
     protected transactionData: TransactionData;
+    /** So rows without a row id are warned about once per element, not once per block. @internal */
+    private missingRowIdWarned;
     protected connectionSub: Subscription | undefined;
     protected subscribeToConnection(): void;
     protected unsubscribeFromConnection(): void;
     protected generateColumnDefsFromMetadata(fieldsMetadata: FieldMetadata[], getFilterParamsByFieldType: (field: FieldMetadata) => ColDef['filterParams'] | any, getFilterByFieldType: (type: FieldTypeEnum) => string): ColDef[];
     protected handleStreamInserts(insertedRows: any[], addIndex?: number): void;
+    /**
+     * Resolves the id of the held row a stream row refers to.
+     * @remarks Under a custom `row-id` a DATASERVER push may carry only the default id
+     * (`ROW_REF`), so the held row with that default id supplies the custom one. Returns
+     * `undefined` when neither id is present - callers skip the row rather than matching
+     * `undefined === undefined` against the first held row.
+     * @internal
+     */
+    protected resolveRowId(row: any): string | undefined;
     protected handleStreamDeletes(deletedRows: any[]): void;
     protected handleStreamUpdates(updatedRows: any[]): void;
     protected applyAllTransactions(): void;
     private applyMappedTransaction;
+    /**
+     * Reports rows a block-based row model (server-side, infinite) has just handed to the grid.
+     * Rows not held before are reported as `add`; rows already held (a block re-read after a
+     * refresh, or a req/rep re-read after a commit or poll) are reported as `update` only when
+     * their content changed, so a plain re-read is silent.
+     * @remarks `rowData` holds the rows delivered since the last cache reset: the resource reports
+     * rows a re-read no longer returned (`reportWithdrawnRows`), and `clearRowData` empties it when
+     * the grid drops its cache. Block eviction is not mirrored - see `DeliveredBlockLedger` - so
+     * this is a superset of what the grid holds.
+     * @internal
+     */
+    protected reportDeliveredRows(rows: any[]): void;
+    /**
+     * Reports rows a block re-read no longer returned: they left the grid (deleted on the server,
+     * or moved into a block that reports them again). Rows already reported removed - a DATASERVER
+     * push, say - are skipped.
+     * @internal
+     */
+    protected reportWithdrawnRows(rowIds: string[]): void;
+    /**
+     * Starts a fresh transaction and returns it, so a caller can keep working on the object it
+     * built even if a consumer's `datasource-data-changed` handler resets the element meanwhile.
+     * @internal
+     */
+    protected resetTransaction(): TransactionData & {
+        add: any[];
+        remove: any[];
+        update: any[];
+    };
+    /**
+     * Whether two versions of a row differ in content. Identity and a key-order-insensitive
+     * field comparison come first, so a re-read of unchanged rows costs no serialization; nested
+     * values fall back to the serializer.
+     * @internal
+     */
+    protected hasRowContentChanged(known: any, row: any): boolean;
+    /** Emits `datasource-data-changed` for `transaction` when it is non-empty. @internal */
+    protected emitTransaction(transaction: TransactionData | undefined): void;
+    /** @internal */
+    private warnMissingRowIdOnce;
     /**
      * Builds the index map used for server-side sorting from the resource's metadata.
      * @remarks Real DATASERVER indexes keep their names; when the resource also (or only) reports
@@ -4511,6 +4698,12 @@ export declare class GridProBeta extends GridProBeta_base {
      * @internal
      */
     private handleDataChanged;
+    /**
+     * Whether the live grid runs AG Grid's client-side row model (the default when the datasource
+     * set no `rowModelType`).
+     * @internal
+     */
+    private get isClientSideRowModel();
     private flashAddedCells;
     /**
      * Handles schema updates from datasource
@@ -6431,12 +6624,15 @@ export declare const gridProGenesisDatasourceEventNames: {
  * @fires datasource-initialize - Fired to hand off infinite row model grid options. detail: `InitializeEventDetail`
  * @fires datasource-init - Fired when the infinite grid model should initialize data
  * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
+ * @fires datasource-data-changed - Fired when rows are delivered to the grid, a DATASERVER push changes them, or a re-read no longer returns them; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @fires set-infinite-datasource - Fired to attach or clear the infinite row model datasource. detail: `SetInfiniteDatasourceEventDetail`
  * @fires refresh-infinite-cache - Fired to request an infinite row model refresh; `purge` drops the block cache and re-reads. detail: `RefreshInfiniteCacheEventDetail`
  * @fires add-grid-css-class - Fired to add a CSS class on the grid host (hover sort indicators). detail: `GridCssClassEventDetail`
  * @fires remove-grid-css-class - Fired to remove that CSS class from the grid host. detail: `GridCssClassEventDetail`
  * @fires cache-filter-config - Fired to persist filter configuration for the grid
- * @fires datasource-data-cleared - Fired when infinite row data is cleared. detail: `DataClearedEventDetail`
+ * @fires datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`
+ * @fires datasource-loading-finished - Fired when the first block comes back with rows
+ * @fires datasource-no-data-available - Fired when the first block comes back empty
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
  */
 export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource_base {
@@ -6452,6 +6648,19 @@ export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource
     criteriaChanged(oldCriteria: string, newCriteria: string): void;
     connectedCallback(): void;
     disconnectedCallback(): void;
+    /** Unsubscribes the `setFilter()` listener. @internal */
+    private filterSub;
+    /**
+     * Reloads when `setFilter()` or `removeFilter()` changes the criteria.
+     * @remarks The criteria a block is read with is captured when the resource is built, so a
+     * filter added later reaches nothing until the rows are re-read. The `criteria` attribute
+     * already reloads through `criteriaChanged`; this gives the programmatic API the same
+     * behaviour instead of silently doing nothing.
+     * @internal
+     */
+    private subscribeToFilterChanges;
+    /** @internal */
+    private unsubscribeFromFilterChanges;
     deepClone(): Node;
     /**
      * Resets the grid data while keeping columnDefs and reloads data.
@@ -6462,10 +6671,58 @@ export declare class GridProInfiniteDatasource extends GridProInfiniteDatasource
     init(): Promise<void>;
     /** @internal */
     private clearReadyListener;
+    /**
+     * Whether the infinite row model can drive this resource.
+     * @remarks It pages a req/rep by sending CRITERIA_MATCH, ORDER_BY and OFFSET in DETAILS, which
+     * a request reply only accepts when it is declared `criteriaOnlyRequest`
+     * (`CRITERIA_ONLY_REQUEST` in its metadata). Without it the server expects its inputs in
+     * `REQUEST` instead and rejects every block, which on this row model surfaces as a grid that
+     * simply never fills. Report it once, up front, as the server-side model does.
+     * @returns `true` when the infinite model can be used, `false` after reporting a
+     * `resource-type` error.
+     * @internal
+     */
+    private isInfiniteSupportedForResource;
     /** @internal */
     private onDatasourceReady;
+    /**
+     * A pushed INSERT/DELETE changes which rows exist or their order, so the change is reported
+     * and then the rows are re-read (purge).
+     * @internal
+     */
+    private handleLiveRowsInvalidated;
+    /**
+     * A pushed MODIFY is already patched into the paging cache, so the change is reported and the
+     * grid only needs to re-render its blocks.
+     * @internal
+     */
+    private handleLiveRowsUpdated;
+    /**
+     * Turns a DATASERVER push into the same transaction the client-side datasource reports:
+     * partial MODIFY rows are merged into the held row, and a remove carries just the row id.
+     * @remarks Unlike the client-side model, a pushed row need not be held here - it may sit
+     * beyond the loaded blocks, in which case the grid will never show it.
+     *
+     * So a pushed INSERT is deliberately not reported: nothing here says where the new row sorts,
+     * and reporting an `add` for a row that lands at position 40,000 of an unscrolled grid would
+     * contradict the event's contract and leave the row held forever, since no block re-read ever
+     * delivers (or withdraws) it. Every INSERT is followed by a purge and re-read, which reports
+     * the row as `add` if and when it actually reaches the grid.
+     *
+     * A MODIFY for a row that is not held is skipped for the same reason; a DELETE is reported by
+     * the id it carries, and one that cannot be resolved to an id is skipped with a warning rather
+     * than matched against the wrong row.
+     * @internal
+     */
+    private reportLiveChange;
     destroy(): Promise<void>;
     restart(): Promise<void>;
+    /**
+     * Forgets every held row and tells consumers, as the client-side datasource does: the grid is
+     * dropping its rows (a reload, a filter or sort change, or teardown). `withColumnDefs` also
+     * clears the column definitions.
+     * @internal
+     */
     private clearRowData;
     /**
      * Honours `pollTriggerEvents` without polling: a commit ACK for one of the listed events
@@ -6902,7 +7159,7 @@ export declare enum GridProRendererTypes {
  * @fires base-datasource-connected - Fired when error state is cleared after connection succeeds
  * @fires datasource-loading-finished - Fired when pending stream transactions are flushed with no row changes
  * @fires datasource-no-data-available - Fired when loading finishes with an empty row set
- * @fires datasource-data-changed - Fired when row data changes from applied stream transactions. detail: `DataChangedEventDetail`
+ * @fires datasource-data-changed - Fired when rows are delivered to the grid, a live stream pushes a change, a poll detects one, or a re-read no longer returns a row; `add` are rows the grid did not hold before, `update` are held rows whose content changed, `remove` carries the row id. detail: `DataChangedEventDetail`
  * @fires cache-filter-config - Fired to persist filter configuration for the grid
  * @fires refresh-server-side - Fired to request a server-side refresh. detail: `RefreshServerSideEventDetail`
  * @fires set-server-side-datasource - Fired to attach or clear the server-side row model datasource
@@ -6913,12 +7170,11 @@ export declare enum GridProRendererTypes {
  * @fires datasource-init - Fired when the server-side grid model should initialize data
  * @fires datasource-schema-updated - Fired when column metadata or defs are updated. detail: `SchemaUpdatedEventDetail`
  * @fires datasource-filters-restored - Fired when persisted filters are reapplied
- * @fires datasource-data-cleared - Fired when server-side row data is cleared. detail: `DataClearedEventDetail`
+ * @fires datasource-data-cleared - Fired when the grid drops every row it held (reload, filter or sort change, destroy); `includeSchema` says whether the columns went too. detail: `DataClearedEventDetail`
  * @fires apply-server-side-transaction - Fired to apply a server-side row transaction
  * @fires datasource-ready - Fired when the host grid is ready to start loading data
  */
 export declare class GridProServerSideDatasource extends GridProServerSideDatasource_base {
-    serializer: JSONSerializer;
     pollingDatasource: Datasource;
     /**
      * Enable live updates for the grid.
@@ -6955,6 +7211,12 @@ export declare class GridProServerSideDatasource extends GridProServerSideDataso
     private onDatasourceReady;
     destroy(): Promise<void>;
     restart(): Promise<void>;
+    /**
+     * Forgets every held row and tells consumers, as the client-side datasource does: the grid is
+     * dropping its rows (a reload, a filter or sort change, or teardown). `withColumnDefs` also
+     * clears the column definitions.
+     * @internal
+     */
     private clearRowData;
     /**
      * Checks whether the resolved resource can be served through the Server-Side Row Model.
@@ -8877,6 +9139,16 @@ export declare type ServerSideDatasourceOptions = {
     onNoDataAvailableFunc?: () => void;
     /** Called when a server-side load finishes with one or more rows. */
     onDataAvailableFunc?: () => void;
+    /**
+     * Called with the rows just handed to AG Grid for a block. This is the only point at which
+     * rows leave the datasource, so it is where the host learns which rows the grid holds.
+     */
+    onRowsDeliveredFunc?: (rows: any[]) => void;
+    /**
+     * Called with the ids of rows a re-read of a block no longer returned - they left the grid
+     * (deleted on the server, or moved to a block that reports them again).
+     */
+    onRowsWithdrawnFunc?: (rowIds: string[]) => void;
     resourceName: string;
     resourceParams?: DataserverParams | RequestParams;
     resourceIndexes?: Map<string, string[]>;