@nexterajs/ui 0.0.2 → 0.1.0

package/types/nexterajs-ui-grid.d.ts

@@ -1,8 +1,9 @@
 import { NxeNumberSeparators } from '@nexterajs/ui/intl';
 import * as _angular_core from '@angular/core';
-import { NgZone, ViewContainerRef, OnDestroy, EventEmitter, TemplateRef } from '@angular/core';
-import { NxeExpr } from '@nexterajs/ui/core';
+import { NgZone, ViewContainerRef, Signal, OnDestroy, InputSignal, EventEmitter, TemplateRef } from '@angular/core';
+import { NxeExpr, NxeMessageService, NxeMessageKey } from '@nexterajs/ui/core';
 import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+import { Observable } from 'rxjs';
 
 /** A DevExtreme-style column `format`: a number-mask string, a date format string, or `{ type }`. */
 interface NxeColumnFormatObject {
@@ -184,6 +185,13 @@ interface NxeTreeListNode<T = any> {
 interface NxeGridInstance<T = any> {
     getSelectedRowsData(): T[];
     getSelectedRowKeys(): T[];
+    /** dx `clearSelection()`: deselects every row, including rows the current filter hides. */
+    clearSelection(): void;
+    /**
+     * dx `deselectAll()`: deselects the rows the current filter shows (the current page of a
+     * server-side grid). A tree list deselects every node.
+     */
+    deselectAll(): void;
     refresh(): void;
     /**
      * dx `clearFilter()`: no argument clears the filter row AND header filters (including
@@ -277,7 +285,7 @@ declare function nxeNumberValue(raw: unknown): number;
  * JS number meets any valid `format`, whatever the column declared. So a number in an untyped
  * or string column still takes its mask, and a number column honours object formats as well.
  */
-declare function nxeDefaultFormat(dataType: NxeColumnDataType | 'object' | undefined, format: NxeColumnFormat | undefined, raw: any, separators?: NxeNumberSeparators): string;
+declare function nxeDefaultFormat(dataType: NxeColumnDataType | 'object' | undefined, format: NxeColumnFormat | undefined, raw: any, separators?: NxeNumberSeparators, locale?: string): string;
 
 /**
  * `nxe-header-filter` — drop-in replacement for DevExtreme `dxo-header-filter` (grid child option).
@@ -291,9 +299,9 @@ declare class NxeHeaderFilterComponent {
     readonly visible: _angular_core.InputSignal<boolean>;
     readonly search: _angular_core.InputSignal<{
         enabled?: boolean;
-    }>;
+    } | undefined>;
     /** Legacy alias for `search.enabled` (one holdout). */
-    readonly allowSearch: _angular_core.InputSignal<boolean>;
+    readonly allowSearch: _angular_core.InputSignal<boolean | undefined>;
     /**
      * dx `headerFilter.dataSource` — a fixed `{ text, value }` list shown instead of the values
      * derived from the rows.
@@ -301,7 +309,7 @@ declare class NxeHeaderFilterComponent {
     readonly dataSource: _angular_core.InputSignal<readonly {
         text?: string;
         value?: any;
-    }[]>;
+    }[] | undefined>;
     /** Whether the in-popup search box shows.
      *
      * Defaults to **true**, matching the legacy DevExtreme deployment: a popup listing every
@@ -329,17 +337,17 @@ declare class NxeColumnComponent {
      * Unset = dx: inferred from the loaded data (m_columns_controller.js:914-975), so a numeric
      * column nobody typed still right-aligns and honours its `format`. Declaring it wins.
      */
-    readonly dataType: _angular_core.InputSignal<NxeColumnDataType>;
+    readonly dataType: _angular_core.InputSignal<NxeColumnDataType | undefined>;
     /** px width — number (`[width]="150"`) or numeric string (`width="200"`). */
-    readonly width: _angular_core.InputSignal<string | number>;
-    readonly minWidth: _angular_core.InputSignal<string | number>;
-    readonly alignment: _angular_core.InputSignal<"left" | "center" | "right">;
+    readonly width: _angular_core.InputSignal<string | number | undefined>;
+    readonly minWidth: _angular_core.InputSignal<string | number | undefined>;
+    readonly alignment: _angular_core.InputSignal<"left" | "center" | "right" | undefined>;
     /** Number-mask string (`#,##0.00`), date format string, or `{ type: 'dd MMM yyyy' }`. */
-    readonly format: _angular_core.InputSignal<NxeColumnFormat>;
+    readonly format: _angular_core.InputSignal<NxeColumnFormat | undefined>;
     /** `(info:{value}) => string` (e.g. `formatAccounting` for parenthesized negatives). */
-    readonly customizeText: _angular_core.InputSignal<NxeCustomizeText>;
+    readonly customizeText: _angular_core.InputSignal<NxeCustomizeText | undefined>;
     /** Name of a sibling `<ng-template nxeTemplate="...">` to render the cell. */
-    readonly cellTemplate: _angular_core.InputSignal<string>;
+    readonly cellTemplate: _angular_core.InputSignal<string | undefined>;
     /**
      * DevExtreme column `lookup` (orbit addition): raw values resolve to display text through
      * `dataSource` (`{ lookup: { dataSource, valueExpr: 'lovCode', displayExpr: 'lovName' } }`).
@@ -349,7 +357,7 @@ declare class NxeColumnComponent {
         dataSource: readonly any[];
         valueExpr?: NxeExpr;
         displayExpr?: NxeExpr;
-    }>;
+    } | undefined>;
     readonly allowSorting: _angular_core.InputSignal<boolean>;
     /** dx parity: whether the header can be dragged into the group panel (default true). */
     readonly allowGrouping: _angular_core.InputSignal<boolean>;
@@ -361,18 +369,18 @@ declare class NxeColumnComponent {
     readonly allowSearch: _angular_core.InputSignal<boolean>;
     readonly allowHeaderFiltering: _angular_core.InputSignal<boolean>;
     readonly visible: _angular_core.InputSignal<boolean>;
-    readonly sortOrder: _angular_core.InputSignal<"asc" | "desc">;
-    readonly sortIndex: _angular_core.InputSignal<number>;
-    readonly groupIndex: _angular_core.InputSignal<number>;
+    readonly sortOrder: _angular_core.InputSignal<"asc" | "desc" | undefined>;
+    readonly sortIndex: _angular_core.InputSignal<number | undefined>;
+    readonly groupIndex: _angular_core.InputSignal<number | undefined>;
     readonly fixed: _angular_core.InputSignal<boolean>;
-    readonly filterValues: _angular_core.InputSignal<any[]>;
+    readonly filterValues: _angular_core.InputSignal<any[] | undefined>;
     /** Column `type` (only `type="date"` seen — a display hint, NOT a command column). */
-    readonly type: _angular_core.InputSignal<string>;
+    readonly type: _angular_core.InputSignal<string | undefined>;
     /**
      * dx `cssClass` — extra classes on this column's header, filter and data cells. The escape
      * hatch for one-off cell styling that does not warrant a `cellTemplate`.
      */
-    readonly cssClass: _angular_core.InputSignal<string>;
+    readonly cssClass: _angular_core.InputSignal<string | undefined>;
     /**
      * dx `editCellTemplate` — the sibling `<ng-template nxeTemplate="NAME">` rendered while this
      * cell is being edited, in place of the built-in editor. Its context is a
@@ -380,12 +388,12 @@ declare class NxeColumnComponent {
      * `ctx.data.field = $event` writes straight through, which is how dx's own edit templates
      * were used.
      */
-    readonly editCellTemplate: _angular_core.InputSignal<string>;
+    readonly editCellTemplate: _angular_core.InputSignal<string | undefined>;
     /**
      * dx `groupCellTemplate` — replaces the `"Caption: value"` text in a group row's caption
      * cell when this column is the one grouped by.
      */
-    readonly groupCellTemplate: _angular_core.InputSignal<string>;
+    readonly groupCellTemplate: _angular_core.InputSignal<string | undefined>;
     /**
      * Child columns declared inside this one — dx's banded header. Empty for an ordinary column.
      *
@@ -397,7 +405,7 @@ declare class NxeColumnComponent {
      * A `<nxe-header-filter>` declared inside this column, dx's per-column `headerFilter`
      * config. Only its `dataSource` is read here; visibility and search stay grid-level.
      */
-    readonly headerFilterConfig: _angular_core.Signal<NxeHeaderFilterComponent>;
+    readonly headerFilterConfig: _angular_core.Signal<NxeHeaderFilterComponent | undefined>;
     /** dx `isBand`: a column that groups other columns under a shared header instead of a field. */
     readonly isBand: _angular_core.Signal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeColumnComponent, never>;
@@ -595,16 +603,26 @@ interface NxeHeaderFilterSource<C> {
         text: string;
     }[] | null;
 }
+/** The words the popup writes itself; each a function so a host can read a signal inside it. */
+interface NxeHeaderFilterLabels {
+    blanks(): string;
+    yes(): string;
+    no(): string;
+    /** Month name for a 1-based month number. */
+    month(month: number): string;
+}
 declare class NxeHeaderFilterModel<C = unknown> {
     private readonly source;
-    private static readonly MONTH_NAMES;
+    private readonly labels;
     /** The column whose popup is open (`null` = closed). */
-    readonly column: _angular_core.WritableSignal<C>;
+    readonly column: _angular_core.WritableSignal<C | null>;
     /** The checked key set being edited in the popup (committed by the host on OK). */
     readonly draft: _angular_core.WritableSignal<ReadonlySet<any>>;
     readonly search: _angular_core.WritableSignal<string>;
     readonly expanded: _angular_core.WritableSignal<ReadonlySet<string>>;
-    constructor(source: NxeHeaderFilterSource<C>);
+    constructor(source: NxeHeaderFilterSource<C>, labels?: NxeHeaderFilterLabels);
+    /** The popup's wording for a boolean bucket. */
+    private boolText;
     /** This column's header-filter key for a raw value. */
     key(column: C, raw: any): any;
     /** Distinct {key, text} for the open column — `(Blanks)` first, then Yes/No or values ascending. */
@@ -674,6 +692,8 @@ declare class NxeHeaderFilterModel<C = unknown> {
  * the panel itself never touches the host's filter state.
  */
 declare class NxeHeaderFilterPanelComponent {
+    /** The library's runtime-switchable messages. */
+    protected readonly messages: NxeMessageService;
     readonly model: _angular_core.InputSignal<NxeHeaderFilterModel<any>>;
     /** Live predicate (re-read every CD, like the grid template did) — a mid-open config
         change to `search.enabled` still shows/hides the box. */
@@ -746,15 +766,15 @@ declare abstract class NxeSummaryItemBase implements NxeSummaryItemLike {
     readonly column: _angular_core.InputSignal<string>;
     readonly summaryType: _angular_core.InputSignal<"sum" | "count" | "min" | "max" | "avg" | "custom">;
     /** Identifier passed to `calculateCustomSummary` for `summaryType='custom'` items. */
-    readonly name: _angular_core.InputSignal<string>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
     /** Positional template; `{0}` is replaced by the customized/formatted value. */
     readonly displayFormat: _angular_core.InputSignal<string>;
-    readonly customizeText: _angular_core.InputSignal<NxeCustomizeText>;
-    readonly valueFormat: _angular_core.InputSignal<NxeColumnFormat>;
+    readonly customizeText: _angular_core.InputSignal<NxeCustomizeText | undefined>;
+    readonly valueFormat: _angular_core.InputSignal<NxeColumnFormat | undefined>;
     readonly alignByColumn: _angular_core.InputSignal<boolean>;
     /** Render this group aggregate in a footer row under the group instead of the group row. */
     readonly showInGroupFooter: _angular_core.InputSignal<boolean>;
-    readonly showInColumn: _angular_core.InputSignal<string>;
+    readonly showInColumn: _angular_core.InputSignal<string | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeSummaryItemBase, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NxeSummaryItemBase, never, never, { "column": { "alias": "column"; "required": false; "isSignal": true; }; "summaryType": { "alias": "summaryType"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "displayFormat": { "alias": "displayFormat"; "required": false; "isSignal": true; }; "customizeText": { "alias": "customizeText"; "required": false; "isSignal": true; }; "valueFormat": { "alias": "valueFormat"; "required": false; "isSignal": true; }; "alignByColumn": { "alias": "alignByColumn"; "required": false; "isSignal": true; }; "showInGroupFooter": { "alias": "showInGroupFooter"; "required": false; "isSignal": true; }; "showInColumn": { "alias": "showInColumn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -775,7 +795,7 @@ declare class NxeSummaryComponent {
      * `{name, summaryProcess:'start'}`, then `'calculate'` once per row (`options.value` = the
      * row object), then `'finalize'`; the handler mutates `options.totalValue`.
      */
-    readonly calculateCustomSummary: _angular_core.InputSignal<(options: any) => void>;
+    readonly calculateCustomSummary: _angular_core.InputSignal<((options: any) => void) | undefined>;
     readonly totalItems: _angular_core.Signal<readonly NxeTotalItemComponent[]>;
     readonly groupItems: _angular_core.Signal<readonly NxeGroupItemComponent[]>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeSummaryComponent, never>;
@@ -806,9 +826,9 @@ declare class NxePagerComponent {
      */
     readonly displayMode: _angular_core.InputSignal<"adaptive" | "compact" | "full">;
     /** dx `pager.infoText`: `{0}` the page, `{1}` the page count, `{2}` the item count. */
-    readonly infoText: _angular_core.InputSignal<string>;
+    readonly infoText: _angular_core.InputSignal<string | undefined>;
     /** dx `pager.label`: the pager's accessible name. */
-    readonly label: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxePagerComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePagerComponent, "nxe-pager", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "allowedPageSizes": { "alias": "allowedPageSizes"; "required": false; "isSignal": true; }; "showPageSizeSelector": { "alias": "showPageSizeSelector"; "required": false; "isSignal": true; }; "showNavigationButtons": { "alias": "showNavigationButtons"; "required": false; "isSignal": true; }; "showInfo": { "alias": "showInfo"; "required": false; "isSignal": true; }; "displayMode": { "alias": "displayMode"; "required": false; "isSignal": true; }; "infoText": { "alias": "infoText"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -846,7 +866,7 @@ declare class NxeEditingComponent {
 declare class NxeFilterRowComponent {
     readonly visible: _angular_core.InputSignal<boolean>;
     /** DevExtreme parity (`auto`/`onClick`); the nxe filter row always applies on input. */
-    readonly applyFilter: _angular_core.InputSignal<string>;
+    readonly applyFilter: _angular_core.InputSignal<string | undefined>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeFilterRowComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeFilterRowComponent, "nxe-filter-row", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "applyFilter": { "alias": "applyFilter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -925,6 +945,171 @@ interface NxeExportDataGridOptions {
  */
 declare function exportDataGrid(opts: NxeExportDataGridOptions): Promise<void>;
 
+/** One sort level: DevExtreme's `{ selector, desc }`. */
+interface NxeSortDescriptor {
+    /** The column's `dataField`. */
+    selector: string;
+    desc: boolean;
+}
+/** Operators a filter-row or header-filter condition can carry (DevExtreme's filter operations). */
+type NxeFilterOperator = '=' | '<>' | '<' | '<=' | '>' | '>=' | 'contains' | 'notcontains' | 'startswith' | 'endswith';
+/**
+ * A DevExtreme-style filter expression, the shape the grid's filter row and header filter produce
+ * for a remote source:
+ *
+ * - a condition: `['name', 'contains', 'acme']`
+ * - a negation: `['!', expression]`
+ * - a group: `[expression, 'and', expression, 'or', expression]`, which may nest
+ *
+ * `between` is expanded the way DevExtreme expands it: `[[f, '>=', a], 'and', [f, '<=', b]]`.
+ * Values are JSON-safe: strings, numbers, booleans and `null`; dates are `'yyyy-MM-dd'` strings.
+ */
+type NxeFilterExpression = readonly unknown[];
+/** What the application (or the grid) states: the page, its size, the sort and the filter. */
+interface NxeRemoteQuery {
+    /** 0-based page index. */
+    pageIndex: number;
+    pageSize: number;
+    sort: readonly NxeSortDescriptor[];
+    filter: NxeFilterExpression | null;
+}
+/**
+ * What `load` receives: the query plus the same page as `skip`/`take`, so an adapter can take
+ * whichever the endpoint speaks (`pageNo = pageIndex + 1`, or `offset = skip`).
+ */
+interface NxeLoadOptions extends NxeRemoteQuery {
+    readonly skip: number;
+    readonly take: number;
+    /** Always `true`: the grid needs the total to draw its pager. DevExtreme `CustomStore` parity. */
+    readonly requireTotalCount: true;
+}
+interface NxeLoadResult<T = any> {
+    data: readonly T[];
+    /** Rows matching the filter across every page. */
+    totalCount: number;
+}
+interface NxeLoadContext {
+    /** Aborted when a newer request supersedes this one, or the source is cancelled or destroyed. */
+    readonly signal: AbortSignal;
+}
+/** The load function: a promise or an observable (an `HttpClient` call passes straight in). */
+type NxeRemoteLoadFn<T = any> = (options: NxeLoadOptions, context: NxeLoadContext) => Promise<NxeLoadResult<T> | readonly T[]> | Observable<NxeLoadResult<T> | readonly T[]>;
+interface NxeRemoteDataSourceConfig {
+    /** The row key field. The grid takes its `keyExpr` from here when none is bound. */
+    key?: string;
+    /** The query the first load runs with. Anything left out is page 0, 20 rows, no sort, no filter. */
+    initial?: Partial<NxeRemoteQuery>;
+    /** Milliseconds a grid waits after the last filter-row keystroke before asking. Default 300. */
+    filterDebounce?: number;
+}
+/** The default page size of a source (and of a remote grid with no `nxe-paging`). */
+declare const NXE_REMOTE_DEFAULT_PAGE_SIZE = 20;
+/** Structural equality of two queries; what keeps a re-stated, unchanged query from reloading. */
+declare function nxeSameQuery(a: NxeRemoteQuery, b: NxeRemoteQuery): boolean;
+/** Builds the load options for a query. */
+declare function nxeLoadOptions(query: NxeRemoteQuery): NxeLoadOptions;
+/**
+ * One condition of a flattened filter, in the form a REST adapter wants. `in` is an OR of `=` on one
+ * field (a header-filter selection), with all its values.
+ */
+interface NxeFlatFilterCondition {
+    field: string;
+    operator: NxeFilterOperator | 'in';
+    value: unknown;
+}
+/**
+ * Flattens the AND-chain a grid builds into simple conditions, for endpoints that take a flat
+ * parameter list (`status=sent,confirmed&supplierId=123`). An OR of `=` on one field becomes one
+ * `in` condition. `exact` is `false` when part of the expression could not be flattened (a `!`, or
+ * an OR across fields); those parts are left out of `conditions`, so an adapter that cannot take
+ * `exact: false` should send the expression as JSON instead.
+ */
+declare function nxeFlattenFilter(filter: NxeFilterExpression | null | undefined): {
+    conditions: NxeFlatFilterCondition[];
+    exact: boolean;
+};
+/** Combines expressions with AND; `null` and empty ones are dropped, a single one is returned as is. */
+declare function nxeFilterAnd(...parts: readonly (NxeFilterExpression | null | undefined)[]): NxeFilterExpression | null;
+/** Combines expressions with OR, as {@link nxeFilterAnd} does with AND. */
+declare function nxeFilterOr(...parts: readonly (NxeFilterExpression | null | undefined)[]): NxeFilterExpression | null;
+/**
+ * A server-backed list for `nxe-data-grid` and `nxe-paginator`. It holds one page at a time:
+ * the grid (or the app) states a query, the source asks the server for exactly that page, and the
+ * result lands in signals.
+ *
+ * ```ts
+ * readonly orders = new NxeRemoteDataSource<Order>(
+ *     (o, { signal }) => this.http.get<OrderList>('/api/orders', { params: toParams(o) }).pipe(map(toResult)),
+ *     { key: 'id' },
+ * );
+ * ```
+ *
+ * A request still in flight is aborted (its `AbortSignal` fires, or its observable is
+ * unsubscribed) when a newer one starts, and a late response that slips past is ignored, so the
+ * rows on screen always belong to the latest query.
+ *
+ * The source is lazy: nothing loads until {@link setOptions} or {@link reload} is called, which a
+ * grid bound to it does on its own.
+ */
+declare class NxeRemoteDataSource<T = any> {
+    private readonly loadFn;
+    /** The row key field, when the source was given one. */
+    readonly key: string | undefined;
+    /** Milliseconds a grid waits after the last filter-row keystroke before asking. */
+    readonly filterDebounce: number;
+    private readonly itemsState;
+    private readonly totalCountState;
+    private readonly loadingState;
+    private readonly errorState;
+    private readonly loadedState;
+    private readonly queryState;
+    private readonly optionsState;
+    /** The rows of the current page. Kept (not cleared) while the next page loads. */
+    readonly items: Signal<readonly T[]>;
+    /** Rows matching the filter across every page, as the last successful response said. */
+    readonly totalCount: Signal<number>;
+    /** A request is in flight. */
+    readonly loading: Signal<boolean>;
+    /** The last request's failure, or `null` after a success or while a retry runs. */
+    readonly error: Signal<unknown>;
+    /** A response has arrived at least once. */
+    readonly loaded: Signal<boolean>;
+    /** The query and the `skip`/`take` of the page the next (or current) request uses. */
+    readonly options: Signal<NxeLoadOptions>;
+    private started;
+    private seq;
+    private controller;
+    private unsubscribe;
+    constructor(loadFn: NxeRemoteLoadFn<T>, config?: NxeRemoteDataSourceConfig);
+    /**
+     * States a new query (any of its parts) and loads it. Nothing happens when it is the query
+     * already stated, so a caller can re-state its inputs freely. The first call starts the source.
+     */
+    setOptions(patch: Partial<NxeRemoteQuery>): void;
+    /** Loads the current query again (after an edit, or as a retry). */
+    reload(): void;
+    /** Aborts the request in flight and ignores its response. */
+    cancel(): void;
+    private abort;
+    private run;
+    /** The last value an observable emits; rejects when it errors or completes empty. */
+    private fromObservable;
+}
+/** A DevExtreme `CustomStore`-shaped source: what `remoteOperations` makes the grid load page by page. */
+interface NxeStoreLike<T = any> {
+    load: NxeRemoteLoadFn<T>;
+    key?: string;
+}
+/** True for an object with a `load` function that is not an array or a {@link NxeRemoteDataSource}. */
+declare function nxeIsStoreLike(value: unknown): value is NxeStoreLike;
+
+/**
+ * The pager's page list and info text, as DevExtreme 24.2.3's pagination builds them.
+ *
+ * Pure functions, so the grid holds the only state (the sliding window, carried between renders
+ * by a linkedSignal) and the rules can be specced without rendering a grid.
+ */
+
 /** One entry of the page list: a page button, or dx's `. . .` separator. */
 interface NxePagerItem {
     /** Stable track key: the page index, or `low` / `high` for the separators. */
@@ -934,6 +1119,54 @@ interface NxePagerItem {
     readonly separator: boolean;
 }
 
+/**
+ * A page navigator that stands on its own: page buttons with the grid pager's sliding window,
+ * previous/next, a page-size selector and the total. Use it beside any list, or bind it to the same
+ * state a remote grid pages with.
+ *
+ * ```html
+ * <nxe-paginator [(pageIndex)]="page" [(pageSize)]="size" [totalCount]="orders.totalCount()" />
+ * ```
+ *
+ * Text comes from `NxeMessageService`, so it follows the language. The nav is a labelled
+ * `navigation` landmark; the current page carries `aria-current="page"`. With focus on a page
+ * button, Left/Right move to the previous/next page and Home/End to the first/last.
+ */
+declare class NxePaginatorComponent {
+    private readonly messages;
+    private readonly separators;
+    private readonly host;
+    private readonly injector;
+    /** The 0-based current page. Two-way. */
+    readonly pageIndex: _angular_core.ModelSignal<number>;
+    /** Rows per page. Two-way; changing it returns to the first page. */
+    readonly pageSize: _angular_core.ModelSignal<number>;
+    /** Rows across every page. */
+    readonly totalCount: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The sizes the selector offers. The current size is always offered too. */
+    readonly pageSizes: _angular_core.InputSignal<readonly number[]>;
+    readonly showPageSizeSelector: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly showInfo: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Greys the controls out and ignores clicks, e.g. while a page loads. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The navigation landmark's accessible name; default is the `grid.pager.navigation` message. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    protected t(key: NxeMessageKey, ...args: readonly unknown[]): string;
+    protected readonly pageCount: _angular_core.Signal<number>;
+    /** The page shown: `pageIndex` held inside the page count. */
+    protected readonly currentPage: _angular_core.Signal<number>;
+    private readonly window;
+    protected readonly items: _angular_core.Signal<readonly NxePagerItem[]>;
+    protected readonly sizes: _angular_core.Signal<number[]>;
+    protected readonly info: _angular_core.Signal<string>;
+    protected readonly total: _angular_core.Signal<string>;
+    protected go(index: number): void;
+    protected onSizeChange(event: Event): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxePaginatorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePaginatorComponent, "nxe-paginator", never, { "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "totalCount": { "alias": "totalCount"; "required": false; "isSignal": true; }; "pageSizes": { "alias": "pageSizes"; "required": false; "isSignal": true; }; "showPageSizeSelector": { "alias": "showPageSizeSelector"; "required": false; "isSignal": true; }; "showInfo": { "alias": "showInfo"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "pageIndex": "pageIndexChange"; "pageSize": "pageSizeChange"; }, never, never, true, never>;
+}
+
 /**
  * Pointer-based column-resize engine (dx `allowColumnResizing` parity).
  *
@@ -947,6 +1180,8 @@ interface NxeGridResizeHooks {
     zone: NgZone;
     host: () => HTMLElement;
     mode: () => 'nextColumn' | 'widget';
+    /** Widget mode only: the trailing column takes what a narrowed table leaves of the rows view. */
+    fillsGrid: () => boolean;
     minWidth: () => number;
     /** Drag started — the grid pauses its auto-width engine. */
     onStart: () => void;
@@ -974,6 +1209,7 @@ declare class NxeGridResizeController {
     destroy(): void;
     private pointerMove;
     private pointerUp;
+    private restore;
     private cancel;
     private teardown;
 }
@@ -1050,6 +1286,9 @@ declare class NxeDataGridComponent implements OnDestroy {
     private readonly defaults;
     /** Locale separators for every number this grid renders — cells, summaries and group text. */
     private readonly separators;
+    private readonly messages;
+    /** One library message for the active language; reading it in a template re-renders on a switch. */
+    protected t(key: NxeMessageKey, ...args: readonly unknown[]): string;
     /** Pointer drag engine: drag-to-group, chip drag-out (ungroup), chip/column reorder. */
     protected readonly drag: NxeGridDragController;
     /** Pointer resize engine (dx allowColumnResizing). */
@@ -1071,35 +1310,70 @@ declare class NxeDataGridComponent implements OnDestroy {
     /** True when any declared column is a band, i.e. the header needs more than one row. */
     protected readonly hasBands: _angular_core.Signal<boolean>;
     private readonly templates;
-    protected readonly selection: _angular_core.Signal<NxeSelectionComponent>;
-    protected readonly headerFilter: _angular_core.Signal<NxeHeaderFilterComponent>;
-    protected readonly grouping: _angular_core.Signal<NxeGroupingComponent>;
-    protected readonly groupPanel: _angular_core.Signal<NxeGroupPanelComponent>;
-    protected readonly summaryCmp: _angular_core.Signal<NxeSummaryComponent>;
-    protected readonly pagingCmp: _angular_core.Signal<NxePagingComponent>;
-    protected readonly pagerCmp: _angular_core.Signal<NxePagerComponent>;
-    protected readonly editingCmp: _angular_core.Signal<NxeEditingComponent>;
-    protected readonly filterRowCmp: _angular_core.Signal<NxeFilterRowComponent>;
-    protected readonly masterDetail: _angular_core.Signal<NxeMasterDetailComponent>;
-    readonly dataSource: _angular_core.InputSignal<readonly any[]>;
-    readonly keyExpr: _angular_core.InputSignal<string>;
-    readonly hoverStateEnabledInput: _angular_core.InputSignal<boolean>;
-    readonly showColumnLinesInput: _angular_core.InputSignal<boolean>;
-    readonly showRowLinesInput: _angular_core.InputSignal<boolean>;
-    readonly showBordersInput: _angular_core.InputSignal<boolean>;
-    readonly wordWrapEnabledInput: _angular_core.InputSignal<boolean>;
-    readonly columnAutoWidthInput: _angular_core.InputSignal<boolean>;
-    readonly rowAlternationEnabledInput: _angular_core.InputSignal<boolean>;
+    protected readonly selection: _angular_core.Signal<NxeSelectionComponent | undefined>;
+    protected readonly headerFilter: _angular_core.Signal<NxeHeaderFilterComponent | undefined>;
+    protected readonly grouping: _angular_core.Signal<NxeGroupingComponent | undefined>;
+    protected readonly groupPanel: _angular_core.Signal<NxeGroupPanelComponent | undefined>;
+    protected readonly summaryCmp: _angular_core.Signal<NxeSummaryComponent | undefined>;
+    protected readonly pagingCmp: _angular_core.Signal<NxePagingComponent | undefined>;
+    protected readonly pagerCmp: _angular_core.Signal<NxePagerComponent | undefined>;
+    protected readonly editingCmp: _angular_core.Signal<NxeEditingComponent | undefined>;
+    protected readonly filterRowCmp: _angular_core.Signal<NxeFilterRowComponent | undefined>;
+    protected readonly masterDetail: _angular_core.Signal<NxeMasterDetailComponent | undefined>;
+    /**
+     * The rows: a plain array (paged, sorted and filtered here), a {@link NxeRemoteDataSource}
+     * (paged, sorted and filtered by the server; the grid holds one page), or, with
+     * `remoteOperations` on, a `CustomStore`-shaped `{ load, key? }`.
+     */
+    readonly dataSource: InputSignal<readonly any[] | NxeStoreLike<any> | NxeRemoteDataSource<any> | null | undefined>;
+    readonly keyExpr: InputSignal<string | undefined>;
+    readonly hoverStateEnabledInput: InputSignal<boolean | undefined>;
+    readonly showColumnLinesInput: InputSignal<boolean | undefined>;
+    readonly showRowLinesInput: InputSignal<boolean | undefined>;
+    readonly showBordersInput: InputSignal<boolean | undefined>;
+    readonly wordWrapEnabledInput: InputSignal<boolean | undefined>;
+    readonly columnAutoWidthInput: InputSignal<boolean | undefined>;
+    readonly rowAlternationEnabledInput: InputSignal<boolean | undefined>;
+    readonly resizeFillsGridInput: InputSignal<boolean | undefined>;
     /** dx resolves `nxe-tree-list` against the `treeList` slice, not `dataGrid`. */
     private readonly widgetDefaults;
     readonly hoverStateEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Widget-mode resizing that never leaves a blank strip: the trailing column takes whatever a
+     * narrowed layout leaves of the grid's width. Not dx - dx lets the table end short - so off
+     * unless bound or set app-wide through `NXE_DEFAULT_OPTIONS`.
+     */
+    readonly resizeFillsGrid: _angular_core.Signal<boolean>;
     readonly showColumnLines: _angular_core.Signal<boolean>;
     readonly showRowLines: _angular_core.Signal<boolean>;
     readonly showBorders: _angular_core.Signal<boolean>;
     readonly wordWrapEnabled: _angular_core.Signal<boolean>;
     readonly columnAutoWidth: _angular_core.Signal<boolean>;
     readonly rowAlternationEnabled: _angular_core.Signal<boolean>;
-    readonly remoteOperations: _angular_core.InputSignal<any>;
+    /**
+     * dx `remoteOperations`. With a `{ load }` store as the `dataSource`, any truthy value makes the
+     * grid page, sort and filter on the server (`{ paging, sorting, filtering }` is read as all or
+     * nothing). A {@link NxeRemoteDataSource} is remote whatever this says.
+     */
+    readonly remoteOperations: InputSignal<any>;
+    /** The 0-based page. Two-way. */
+    readonly pageIndexModel: _angular_core.ModelSignal<number | undefined>;
+    /** Rows per page. Two-way. */
+    readonly pageSizeModel: _angular_core.ModelSignal<number | undefined>;
+    /** The sort, `[{ selector, desc }]`. Two-way; a header click writes its single level here. */
+    readonly sortModel: _angular_core.ModelSignal<readonly NxeSortDescriptor[] | undefined>;
+    /**
+     * A filter the application owns (a filter bar, a status tab), in {@link NxeFilterExpression}
+     * form. A remote grid ANDs it with the filter row and header filter and sends the lot to the
+     * server. Changing it returns the grid to the first page.
+     */
+    readonly filter: InputSignal<NxeFilterExpression | null | undefined>;
+    /**
+     * The options of every request a remote grid hands its source: page, size, sort and the
+     * combined filter. One emission per distinct request, after filter-row typing settles. This is
+     * where an application mirrors the grid's state into the URL.
+     */
+    readonly optionsChange: _angular_core.OutputEmitterRef<NxeLoadOptions>;
     /**
      * dx `syncLookupFilterValues` — accepted, and deliberately inert. It asks dx to narrow a
      * lookup column's header-filter list to the values still reachable under the other filters.
@@ -1107,55 +1381,55 @@ declare class NxeDataGridComponent implements OnDestroy {
      * already what it does; `true` is the option we do not honour.
      * @nxeInert grid — parity/data-grid.yaml "syncLookupFilterValues".
      */
-    readonly syncLookupFilterValues: _angular_core.InputSignal<boolean>;
-    readonly columnMinWidth: _angular_core.InputSignal<number>;
+    readonly syncLookupFilterValues: InputSignal<boolean>;
+    readonly columnMinWidth: InputSignal<number | undefined>;
     /** dx `height` — a bare number means px, anything else passes through. */
-    readonly height: _angular_core.InputSignal<string | number>;
-    protected readonly heightStyle: _angular_core.Signal<string>;
-    readonly noDataTextInput: _angular_core.InputSignal<string>;
+    readonly height: InputSignal<string | number | undefined>;
+    protected readonly heightStyle: _angular_core.Signal<string | null>;
+    readonly noDataTextInput: InputSignal<string | undefined>;
     readonly noDataText: _angular_core.Signal<string>;
-    readonly loadPanel: _angular_core.InputSignal<{
+    readonly loadPanel: InputSignal<{
         enabled?: boolean;
-    }>;
-    readonly paging: _angular_core.InputSignal<{
+    } | undefined>;
+    readonly paging: InputSignal<{
         enabled?: boolean;
         pageSize?: number;
-    }>;
-    readonly filterRow: _angular_core.InputSignal<{
+    } | undefined>;
+    readonly filterRow: InputSignal<{
         visible?: boolean;
-    }>;
+    } | undefined>;
     /** Object-input forms of the config elements (dx accepts both; orbit uses both styles). */
-    readonly headerFilterOptions: _angular_core.InputSignal<{
+    readonly headerFilterOptions: InputSignal<{
         visible?: boolean;
         search?: {
             enabled?: boolean;
         };
-    }>;
-    readonly groupingOptions: _angular_core.InputSignal<{
+    } | undefined>;
+    readonly groupingOptions: InputSignal<{
         autoExpandAll?: boolean;
-    }>;
-    readonly groupPanelOptions: _angular_core.InputSignal<{
+    } | undefined>;
+    readonly groupPanelOptions: InputSignal<{
         visible?: boolean;
-    }>;
-    readonly scrolling: _angular_core.InputSignal<any>;
+    } | undefined>;
+    readonly scrolling: InputSignal<any>;
     /**
      * dx `sorting`. Unbound means dx's default mode 'single'. `false` and `null` are accepted as dx
      * reads them - no mode, so headers keep their sort slot but a click never sorts.
      */
-    readonly sorting: _angular_core.InputSignal<false | {
+    readonly sorting: InputSignal<false | {
         mode?: "single" | "multiple" | "none";
-    }>;
-    readonly allowColumnResizing: _angular_core.InputSignal<boolean>;
+    } | null | undefined>;
+    readonly allowColumnResizing: InputSignal<boolean>;
     /** dx columnResizingMode: 'nextColumn' (default) trades width; 'widget' grows the table. */
-    readonly columnResizingMode: _angular_core.InputSignal<"nextColumn" | "widget">;
+    readonly columnResizingMode: InputSignal<"nextColumn" | "widget">;
     /** dx allowColumnReordering (default false — matches every dx-era template in this app). */
-    readonly allowColumnReordering: _angular_core.InputSignal<boolean>;
-    readonly repaintChangesOnly: _angular_core.InputSignal<boolean>;
-    readonly showColumnHeaders: _angular_core.InputSignal<boolean>;
-    readonly parentIdExpr: _angular_core.InputSignal<string>;
-    readonly dataStructure: _angular_core.InputSignal<"plain" | "tree">;
-    readonly rootValue: _angular_core.InputSignal<unknown>;
-    readonly autoExpandAll: _angular_core.InputSignal<boolean>;
+    readonly allowColumnReordering: InputSignal<boolean>;
+    readonly repaintChangesOnly: InputSignal<boolean>;
+    readonly showColumnHeaders: InputSignal<boolean>;
+    readonly parentIdExpr: InputSignal<string | undefined>;
+    readonly dataStructure: InputSignal<"plain" | "tree">;
+    readonly rootValue: InputSignal<unknown>;
+    readonly autoExpandAll: InputSignal<boolean>;
     readonly expandedRowKeys: _angular_core.ModelSignal<any[]>;
     /** Tree-list multi-select keys (`[(selectedRowKeys)]`); recursive via dxo-selection. */
     readonly selectedRowKeys: _angular_core.ModelSignal<any[]>;
@@ -1164,7 +1438,7 @@ declare class NxeDataGridComponent implements OnDestroy {
      * dataFields merged hierarchically left→right — consecutive rows with equal values render one
      * cell with `rowspan`; a break in an earlier field breaks all later fields.
      */
-    readonly mergeColumns: _angular_core.InputSignal<readonly string[]>;
+    readonly mergeColumns: InputSignal<readonly string[]>;
     readonly onSelectionChanged: _angular_core.OutputEmitterRef<NxeGridSelectionChangedEvent<any>>;
     readonly onRowClick: _angular_core.OutputEmitterRef<{
         data: any;
@@ -1183,7 +1457,7 @@ declare class NxeDataGridComponent implements OnDestroy {
      */
     readonly onOptionChanged: _angular_core.OutputEmitterRef<NxeGridOptionChangedEvent>;
     /** Extra CSS classes for a data row (replaces dx `onRowPrepared` class tweaks). */
-    readonly rowClass: _angular_core.InputSignal<(row: any) => string>;
+    readonly rowClass: InputSignal<((row: any) => string) | undefined>;
     /**
      * dx `onCellPrepared` / `onRowPrepared`, fired once per rendered cell and row after the DOM
      * is written, with the real element for handlers that mutate it.
@@ -1229,7 +1503,7 @@ declare class NxeDataGridComponent implements OnDestroy {
      * its rows/columns through the source adapter and keeps the aliases the specs poke.
      */
     protected readonly hf: NxeHeaderFilterModel<NxeColumnComponent>;
-    protected readonly hfColumn: _angular_core.WritableSignal<NxeColumnComponent>;
+    protected readonly hfColumn: _angular_core.WritableSignal<NxeColumnComponent | null>;
     protected readonly hfDraft: _angular_core.WritableSignal<ReadonlySet<any>>;
     private hfOverlayRef?;
     /**
@@ -1262,17 +1536,53 @@ declare class NxeDataGridComponent implements OnDestroy {
      */
     private frozenColWidth;
     protected effectiveColWidth(col: NxeColumnComponent, idx: number): string | null;
+    /** What a frozen layout's columns add up to, the command columns included. */
+    private frozenTableWidth;
+    /**
+     * With `resizeFillsGrid`, the room a frozen widget-mode layout leaves on the right, which the
+     * trailing column takes. 0 when the columns fill or overflow the grid - that table scrolls.
+     */
+    private readonly frozenSlack;
     protected tableWidthStyle(): string;
     protected readonly selectionEnabled: _angular_core.Signal<boolean>;
     protected readonly selectionMode: _angular_core.Signal<"none" | "single" | "multiple">;
     protected readonly showCheckboxes: _angular_core.Signal<boolean>;
+    /**
+     * The detached checkbox column. A tree list has none: dx draws its row checkbox in the first
+     * cell, after the expander, and its select-all in the first column's header.
+     */
+    protected readonly selectColumnVisible: _angular_core.Signal<boolean>;
+    protected readonly treeSelectAll: _angular_core.Signal<boolean>;
+    private readonly recursiveTreeSelection;
+    /**
+     * Each node's recursive selection state as dx draws it: `all` when its key is selected or an
+     * ancestor's is, or when every child is; `some` when only some descendants are; absent for none.
+     * Keys hold the selection, so the hierarchy - not the key list - decides what a parent shows.
+     */
+    private readonly treeCheckState;
+    /** Parent of each tree node, for settling ancestors after a recursive toggle. */
+    private readonly treeParents;
     /** Selected rows in dataSource order (stale refs from old data naturally filtered out). */
     protected readonly selectedRowsData: _angular_core.Signal<any[]>;
     protected readonly allSelected: _angular_core.Signal<boolean>;
     protected readonly someSelected: _angular_core.Signal<boolean>;
+    /** The key field: the bound `keyExpr`, else the remote source's own `key`. */
+    private readonly keyField;
     private rowKey;
     private treeDescendantKeys;
     private toggleTreeSelection;
+    /**
+     * dx recursive selection. Clicking a node that is not fully checked (unchecked, or a parent
+     * showing indeterminate) selects its whole subtree; clicking a checked one clears it. Then its
+     * ancestors follow their children, checked once all of them are and cleared as soon as one is
+     * not, so deselecting one child leaves its parent indeterminate rather than still ticked.
+     *
+     * The key list is rewritten as every checked node, which dx's `getSelectedRowKeys('all')`
+     * also reports. The event's current keys are what changed on screen.
+     */
+    private toggleRecursiveTreeSelection;
+    /** A recursive tree list's parent with only some descendants selected (dx's indeterminate box). */
+    protected isTreeIndeterminate(row: any): boolean;
     private emitTreeSelectionChanged;
     /** `grouping.autoExpandAll` from the child element or object input; dx default is true. */
     private readonly groupAutoExpand;
@@ -1291,6 +1601,39 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected readonly hasTotalFooter: _angular_core.Signal<boolean>;
     /** Grand-total sums keyed by dataField → formatted text (alignByColumn placement). */
     protected readonly totalSums: _angular_core.Signal<Map<string, string>>;
+    /** A `{ load }` store handed to `dataSource` with `remoteOperations`, wrapped once per store. */
+    private readonly storeWrappers;
+    private wrapped;
+    private readonly remoteWarnings;
+    /** Rows picked on earlier pages, by key, so `selectedRowsData` still has them. */
+    private readonly remoteRowCache;
+    /** Set by filter-row typing; the next request waits `filterDebounce` before it is sent. */
+    private remoteTyping;
+    /** What the last request was for, to tell a changed filter, sort or size from a changed page. */
+    private remoteSignature;
+    private warnOnce;
+    /**
+     * The source the grid pages through, or `null` for a client-side array. An
+     * {@link NxeRemoteDataSource} is used as it is; a `{ load }` store becomes one when
+     * `remoteOperations` is on.
+     */
+    protected readonly remote: _angular_core.Signal<NxeRemoteDataSource<any> | null>;
+    /** The rows every client-side computed reads: the array, or the remote source's current page. */
+    private readonly sourceRows;
+    private readonly selectedKeySet;
+    /** The sort a request carries: the controlled `sort`, else the header sort. */
+    private readonly remoteSort;
+    /** The filter a request carries: filter row AND header filters AND the application's `filter`. */
+    private readonly remoteFilter;
+    /** The request the remote source should be showing, or `null` for a client-side grid. */
+    private readonly remoteRequest;
+    private dispatchRemote;
+    private remoteFilterRowExpression;
+    private filterRowCondition;
+    private remoteHeaderFilterExpression;
+    private toggleRemoteSelection;
+    private toggleRemoteSelectAll;
+    private emitRemoteSelectionChanged;
     protected readonly pagingEnabled: _angular_core.Signal<boolean>;
     protected readonly effectivePageSize: _angular_core.Signal<number>;
     protected readonly pageCount: _angular_core.Signal<number>;
@@ -1442,7 +1785,7 @@ declare class NxeDataGridComponent implements OnDestroy {
     private readonly expandedDetails;
     protected isDetailExpanded(row: any): boolean;
     protected toggleDetail(row: any, event: Event): void;
-    protected detailTemplate(): TemplateRef<unknown>;
+    protected detailTemplate(): TemplateRef<unknown> | null;
     protected detailContext(row: any, rowIndex: number): {
         $implicit: {
             data: any;
@@ -1472,7 +1815,7 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected readonly editingCell: _angular_core.WritableSignal<{
         row: any;
         field: string;
-    }>;
+    } | null>;
     /** Buffered values for the row in edit mode (`row` mode), keyed by dataField. */
     protected readonly rowEditBuffer: _angular_core.WritableSignal<Record<string, any>>;
     protected isEditingCell(row: any, col: NxeColumnComponent): boolean;
@@ -1551,6 +1894,10 @@ declare class NxeDataGridComponent implements OnDestroy {
      */
     protected readonly displayRows: _angular_core.Signal<any[]>;
     protected readonly loading: _angular_core.Signal<boolean>;
+    /** A remote request is in flight over rows already on screen: the overlay, not the empty-body spinner. */
+    protected readonly remoteBusy: _angular_core.Signal<boolean>;
+    protected readonly remoteFailed: _angular_core.Signal<boolean>;
+    protected retryRemote(): void;
     /**
      * dx `isEmpty()` = `!items().length` (m_data_controller.js:1044-1046), toggled as `dx-empty`
      * on the rows view in `_renderCore` (m_rows_view.js:710) whether loading or not.
@@ -1648,6 +1995,8 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected colType(col: NxeColumnComponent): NxeColType | undefined;
     /** The active sort: an explicit user click, else the first column declaring `sortOrder`. */
     private effectiveSort;
+    /** A user sort change: the grid's own state, and the controlled `sort` when it is in play. */
+    private setSort;
     /**
      * dx `getAlignmentByDataType` (m_columns_controller_utils.js) over the effective type:
      * number right, boolean centre, everything else left. A lookup aligns by its display text
@@ -1687,7 +2036,7 @@ declare class NxeDataGridComponent implements OnDestroy {
     /** Column `lookup` resolution (orbit addition): raw value → display text via the lookup list. */
     private lookupText;
     private defaultFormat;
-    protected templateFor(name: string | undefined): TemplateRef<unknown>;
+    protected templateFor(name: string | undefined): TemplateRef<unknown> | null;
     protected cellContext(row: any, rowIndex: number, columnIndex: number, col: NxeColumnComponent): {
         $implicit: NxeCellInfo;
     };
@@ -1806,12 +2155,18 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected onCheckboxClick(row: any, event: Event): void;
     private toggleRow;
     protected toggleSelectAll(event: Event): void;
+    /**
+     * `clearSelection()` (`scope` null: every selected row) and `deselectAll()` (`scope`: the rows
+     * on show). One `onSelectionChanged` with the dropped keys as deselected, none when nothing
+     * was selected.
+     */
+    private deselectRows;
     private emitSelectionChanged;
     private rowKeys;
     private static readonly STRING_OPS;
     private static readonly SCALAR_OPS;
     private static readonly OP_ICON_SLUGS;
-    protected readonly frMenuColumn: _angular_core.WritableSignal<NxeColumnComponent>;
+    protected readonly frMenuColumn: _angular_core.WritableSignal<NxeColumnComponent | null>;
     private frMenuOverlayRef?;
     private readonly frMenuPanel;
     /** Which editor a filter cell renders (mirrors dx: select for lookup/boolean, typed inputs). */
@@ -1866,8 +2221,8 @@ declare class NxeDataGridComponent implements OnDestroy {
     private compare;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeDataGridComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeDataGridComponent, "nxe-data-grid, nxe-tree-list", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "keyExpr": { "alias": "keyExpr"; "required": false; "isSignal": true; }; "hoverStateEnabledInput": { "alias": "hoverStateEnabled"; "required": false; "isSignal": true; }; "showColumnLinesInput": { "alias": "showColumnLines"; "required": false; "isSignal": true; }; "showRowLinesInput": { "alias": "showRowLines"; "required": false; "isSignal": true; }; "showBordersInput": { "alias": "showBorders"; "required": false; "isSignal": true; }; "wordWrapEnabledInput": { "alias": "wordWrapEnabled"; "required": false; "isSignal": true; }; "columnAutoWidthInput": { "alias": "columnAutoWidth"; "required": false; "isSignal": true; }; "rowAlternationEnabledInput": { "alias": "rowAlternationEnabled"; "required": false; "isSignal": true; }; "remoteOperations": { "alias": "remoteOperations"; "required": false; "isSignal": true; }; "syncLookupFilterValues": { "alias": "syncLookupFilterValues"; "required": false; "isSignal": true; }; "columnMinWidth": { "alias": "columnMinWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "noDataTextInput": { "alias": "noDataText"; "required": false; "isSignal": true; }; "loadPanel": { "alias": "loadPanel"; "required": false; "isSignal": true; }; "paging": { "alias": "paging"; "required": false; "isSignal": true; }; "filterRow": { "alias": "filterRow"; "required": false; "isSignal": true; }; "headerFilterOptions": { "alias": "headerFilter"; "required": false; "isSignal": true; }; "groupingOptions": { "alias": "grouping"; "required": false; "isSignal": true; }; "groupPanelOptions": { "alias": "groupPanel"; "required": false; "isSignal": true; }; "scrolling": { "alias": "scrolling"; "required": false; "isSignal": true; }; "sorting": { "alias": "sorting"; "required": false; "isSignal": true; }; "allowColumnResizing": { "alias": "allowColumnResizing"; "required": false; "isSignal": true; }; "columnResizingMode": { "alias": "columnResizingMode"; "required": false; "isSignal": true; }; "allowColumnReordering": { "alias": "allowColumnReordering"; "required": false; "isSignal": true; }; "repaintChangesOnly": { "alias": "repaintChangesOnly"; "required": false; "isSignal": true; }; "showColumnHeaders": { "alias": "showColumnHeaders"; "required": false; "isSignal": true; }; "parentIdExpr": { "alias": "parentIdExpr"; "required": false; "isSignal": true; }; "dataStructure": { "alias": "dataStructure"; "required": false; "isSignal": true; }; "rootValue": { "alias": "rootValue"; "required": false; "isSignal": true; }; "autoExpandAll": { "alias": "autoExpandAll"; "required": false; "isSignal": true; }; "expandedRowKeys": { "alias": "expandedRowKeys"; "required": false; "isSignal": true; }; "selectedRowKeys": { "alias": "selectedRowKeys"; "required": false; "isSignal": true; }; "mergeColumns": { "alias": "mergeColumns"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; }, { "expandedRowKeys": "expandedRowKeysChange"; "selectedRowKeys": "selectedRowKeysChange"; "onSelectionChanged": "onSelectionChanged"; "onRowClick": "onRowClick"; "onContentReady": "onContentReady"; "onOptionChanged": "onOptionChanged"; "onCellPrepared": "onCellPrepared"; "onRowPrepared": "onRowPrepared"; "onRowExpanding": "onRowExpanding"; "onRowExpanded": "onRowExpanded"; }, ["declaredColumns", "templates", "selection", "headerFilter", "grouping", "groupPanel", "summaryCmp", "pagingCmp", "pagerCmp", "editingCmp", "filterRowCmp", "masterDetail"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeDataGridComponent, "nxe-data-grid, nxe-tree-list", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "keyExpr": { "alias": "keyExpr"; "required": false; "isSignal": true; }; "hoverStateEnabledInput": { "alias": "hoverStateEnabled"; "required": false; "isSignal": true; }; "showColumnLinesInput": { "alias": "showColumnLines"; "required": false; "isSignal": true; }; "showRowLinesInput": { "alias": "showRowLines"; "required": false; "isSignal": true; }; "showBordersInput": { "alias": "showBorders"; "required": false; "isSignal": true; }; "wordWrapEnabledInput": { "alias": "wordWrapEnabled"; "required": false; "isSignal": true; }; "columnAutoWidthInput": { "alias": "columnAutoWidth"; "required": false; "isSignal": true; }; "rowAlternationEnabledInput": { "alias": "rowAlternationEnabled"; "required": false; "isSignal": true; }; "resizeFillsGridInput": { "alias": "resizeFillsGrid"; "required": false; "isSignal": true; }; "remoteOperations": { "alias": "remoteOperations"; "required": false; "isSignal": true; }; "pageIndexModel": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "pageSizeModel": { "alias": "pageSize"; "required": false; "isSignal": true; }; "sortModel": { "alias": "sort"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "syncLookupFilterValues": { "alias": "syncLookupFilterValues"; "required": false; "isSignal": true; }; "columnMinWidth": { "alias": "columnMinWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "noDataTextInput": { "alias": "noDataText"; "required": false; "isSignal": true; }; "loadPanel": { "alias": "loadPanel"; "required": false; "isSignal": true; }; "paging": { "alias": "paging"; "required": false; "isSignal": true; }; "filterRow": { "alias": "filterRow"; "required": false; "isSignal": true; }; "headerFilterOptions": { "alias": "headerFilter"; "required": false; "isSignal": true; }; "groupingOptions": { "alias": "grouping"; "required": false; "isSignal": true; }; "groupPanelOptions": { "alias": "groupPanel"; "required": false; "isSignal": true; }; "scrolling": { "alias": "scrolling"; "required": false; "isSignal": true; }; "sorting": { "alias": "sorting"; "required": false; "isSignal": true; }; "allowColumnResizing": { "alias": "allowColumnResizing"; "required": false; "isSignal": true; }; "columnResizingMode": { "alias": "columnResizingMode"; "required": false; "isSignal": true; }; "allowColumnReordering": { "alias": "allowColumnReordering"; "required": false; "isSignal": true; }; "repaintChangesOnly": { "alias": "repaintChangesOnly"; "required": false; "isSignal": true; }; "showColumnHeaders": { "alias": "showColumnHeaders"; "required": false; "isSignal": true; }; "parentIdExpr": { "alias": "parentIdExpr"; "required": false; "isSignal": true; }; "dataStructure": { "alias": "dataStructure"; "required": false; "isSignal": true; }; "rootValue": { "alias": "rootValue"; "required": false; "isSignal": true; }; "autoExpandAll": { "alias": "autoExpandAll"; "required": false; "isSignal": true; }; "expandedRowKeys": { "alias": "expandedRowKeys"; "required": false; "isSignal": true; }; "selectedRowKeys": { "alias": "selectedRowKeys"; "required": false; "isSignal": true; }; "mergeColumns": { "alias": "mergeColumns"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; }, { "pageIndexModel": "pageIndexChange"; "pageSizeModel": "pageSizeChange"; "sortModel": "sortChange"; "optionsChange": "optionsChange"; "expandedRowKeys": "expandedRowKeysChange"; "selectedRowKeys": "selectedRowKeysChange"; "onSelectionChanged": "onSelectionChanged"; "onRowClick": "onRowClick"; "onContentReady": "onContentReady"; "onOptionChanged": "onOptionChanged"; "onCellPrepared": "onCellPrepared"; "onRowPrepared": "onRowPrepared"; "onRowExpanding": "onRowExpanding"; "onRowExpanded": "onRowExpanded"; }, ["declaredColumns", "templates", "selection", "headerFilter", "grouping", "groupPanel", "summaryCmp", "pagingCmp", "pagerCmp", "editingCmp", "filterRowCmp", "masterDetail"], never, true, never>;
 }
 
-export { NXE_HF_BLANKS, NxeColumnComponent, NxeDataGridComponent, NxeDragGesture, NxeEditingComponent, NxeFilterRowComponent, NxeGestureClickSuppression, NxeGridDragController, NxeGroupItemComponent, NxeGroupPanelComponent, NxeGroupingComponent, NxeHeaderFilterComponent, NxeHeaderFilterModel, NxeHeaderFilterPanelComponent, NxeMasterDetailComponent, NxePagerComponent, NxePagingComponent, NxeScrollingComponent, NxeSelectionComponent, NxeSummaryComponent, NxeTotalItemComponent, exportDataGrid, exportNxeGridToExcel, nxeDatePattern, nxeDefaultFormat, nxeExcelNumFmt, nxeExcelNumberMask, nxeFormatNumberValue, nxeHfKey, nxeNumberMask, nxeNumberValue, nxeValueDataType, openNxeHeaderFilterOverlay };
-export type { NxeCellInfo, NxeCellPreparedEvent, NxeColumnDataType, NxeColumnFormat, NxeColumnFormatObject, NxeCustomizeText, NxeDragGestureDelegate, NxeEditCellInfo, NxeExcelExportOptions, NxeExportColumn, NxeExportDataGridOptions, NxeFilterOp, NxeGridChange, NxeGridDragHooks, NxeGridInstance, NxeGridOptionChangedEvent, NxeGridSelectionChangedEvent, NxeGroupCellInfo, NxeHeaderCell, NxeHeaderFilterOverlayOptions, NxeHeaderFilterSource, NxeHfDateNode, NxeRowInfo, NxeRowPreparedEvent, NxeRowType, NxeSummaryItemLike, NxeTreeListNode };
+export { NXE_HF_BLANKS, NXE_REMOTE_DEFAULT_PAGE_SIZE, NxeColumnComponent, NxeDataGridComponent, NxeDragGesture, NxeEditingComponent, NxeFilterRowComponent, NxeGestureClickSuppression, NxeGridDragController, NxeGroupItemComponent, NxeGroupPanelComponent, NxeGroupingComponent, NxeHeaderFilterComponent, NxeHeaderFilterModel, NxeHeaderFilterPanelComponent, NxeMasterDetailComponent, NxePagerComponent, NxePaginatorComponent, NxePagingComponent, NxeRemoteDataSource, NxeScrollingComponent, NxeSelectionComponent, NxeSummaryComponent, NxeTotalItemComponent, exportDataGrid, exportNxeGridToExcel, nxeDatePattern, nxeDefaultFormat, nxeExcelNumFmt, nxeExcelNumberMask, nxeFilterAnd, nxeFilterOr, nxeFlattenFilter, nxeFormatNumberValue, nxeHfKey, nxeIsStoreLike, nxeLoadOptions, nxeNumberMask, nxeNumberValue, nxeSameQuery, nxeValueDataType, openNxeHeaderFilterOverlay };
+export type { NxeCellInfo, NxeCellPreparedEvent, NxeColumnDataType, NxeColumnFormat, NxeColumnFormatObject, NxeCustomizeText, NxeDragGestureDelegate, NxeEditCellInfo, NxeExcelExportOptions, NxeExportColumn, NxeExportDataGridOptions, NxeFilterExpression, NxeFilterOp, NxeFilterOperator, NxeFlatFilterCondition, NxeGridChange, NxeGridDragHooks, NxeGridInstance, NxeGridOptionChangedEvent, NxeGridSelectionChangedEvent, NxeGroupCellInfo, NxeHeaderCell, NxeHeaderFilterLabels, NxeHeaderFilterOverlayOptions, NxeHeaderFilterSource, NxeHfDateNode, NxeLoadContext, NxeLoadOptions, NxeLoadResult, NxeRemoteDataSourceConfig, NxeRemoteLoadFn, NxeRemoteQuery, NxeRowInfo, NxeRowPreparedEvent, NxeRowType, NxeSortDescriptor, NxeStoreLike, NxeSummaryItemLike, NxeTreeListNode };