@nexterajs/ui 0.0.1 → 0.1.0

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

@@ -1,6 +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 { 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 {
@@ -10,6 +13,12 @@ interface NxeColumnFormatObject {
     formatter?: (value: any) => string;
 }
 type NxeColumnFormat = string | NxeColumnFormatObject;
+/**
+ * A column's declared `dataType`. Leaving it unset is not the same as `'string'`: as in dx
+ * (m_columns_controller.js `updateColumnDataTypes`), an unset type is inferred from the loaded
+ * values, which is what right-aligns and formats a numeric column nobody typed.
+ */
+type NxeColumnDataType = 'string' | 'number' | 'date' | 'boolean';
 /** Column `customizeText` callback — `(info) => string` (used by `formatAccounting`). */
 type NxeCustomizeText = (info: {
     value: any;
@@ -161,7 +170,8 @@ interface NxeGridSelectionChangedEvent<T = any> {
 interface NxeExportColumn {
     caption: string;
     dataField: string;
-    dataType: 'string' | 'number' | 'date' | 'boolean';
+    /** The declared type, else the inferred one; `undefined` while nothing could be inferred. */
+    dataType: NxeColumnDataType | undefined;
     format: NxeColumnFormat | undefined;
 }
 /** dx TreeList node shape — the slice `exportTreeToExcel` walks (`data` + `children`). */
@@ -175,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
@@ -227,20 +244,82 @@ declare function nxeNumberMask(format: NxeColumnFormat | undefined): string | un
  * `{ formatter }`). No format / an unresolvable one → `String(value)` (the grid's untyped
  * rendering).
  */
-declare function nxeFormatNumberValue(value: number, format: NxeColumnFormat | undefined): string;
+declare function nxeFormatNumberValue(value: number, format: NxeColumnFormat | undefined, separators?: NxeNumberSeparators): string;
 /**
- * Derive the Excel `numFmt` mask for a `format`: string masks pass through, fixedPoint/currency
+ * Derive the Excel `numFmt` mask for a `format`: string masks go through
+ * {@link nxeExcelNumberMask} (the same conversion the grid export uses), fixedPoint/currency
  * come from {@link nxeNumberMask}, percent appends a bare `%` (Excel multiplies by 100 itself),
  * and any other `{ type }` is a date pattern used as-is. `{ formatter }`-only objects →
  * `undefined` (callers fall back to exporting the formatted text).
  */
 declare function nxeExcelNumFmt(format: NxeColumnFormat | undefined): string | undefined;
+/**
+ * Excel `numFmt` for a dx LDML string mask.
+ *
+ * The two languages disagree on one character. In Excel an unquoted comma after the last digit
+ * placeholder SCALES the value by 1/1000, while dx's LDML engine ignores it (see the golden
+ * transcript in `@nexterajs/ui/intl`). The consumer percent mask `#,##0.00,'%'` therefore
+ * exported 100 as "0.10%". Dropped here, per `;` section: every unquoted comma after the
+ * section's decimal point, and a comma that follows a digit placeholder with no placeholder
+ * after it before the section's decimal point or end (`#,##0,'%'`, `#,##0,.00`) — none of them
+ * ever meant anything to dx. Grouping commas between integer placeholders stay, and
+ * single-quoted literals become Excel's double-quoted ones.
+ */
+declare function nxeExcelNumberMask(mask: string): string;
+/**
+ * dx `getValueDataType` (m_columns_controller_utils.js:230-236): the type a value contributes
+ * to column type inference. `null`, arrays and functions contribute nothing.
+ */
+declare function nxeValueDataType(v: unknown): NxeColumnDataType | 'object' | undefined;
+/**
+ * dx's number-column deserializer (m_columns_controller_utils.js:263 `updateSerializers`):
+ * `parseFloat`, so "20.5" is 20.5 and "1,234" is 1 exactly as dx shows it. `NaN` when the
+ * value is not numeric at all, which callers render raw.
+ */
+declare function nxeNumberValue(raw: unknown): number;
 /**
  * The data grid's default cell rendering (pure extraction of nxe-data-grid's `defaultFormat`):
- * `dataType`/`format` → display text. Number cells honour string masks only — exactly the
- * grid's pre-extraction behaviour.
+ * `dataType`/`format` → display text.
+ *
+ * dx's format_helper (format_helper.js:23-43) formats by the VALUE, not by the column type: any
+ * 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: 'string' | 'number' | 'date' | 'boolean' | undefined, format: NxeColumnFormat | undefined, raw: any): 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).
+ *
+ * Adds a funnel icon to each filterable column header; clicking it opens a popup of the column's
+ * distinct values (checkbox list + optional search) to filter the grid. The app uses essentially
+ * one shape: `[search]="{ enabled: true }" [visible]="true"` (60 files). Legacy `[allowSearch]`
+ * (1×) folds into `search.enabled`.
+ */
+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 | undefined>;
+    /**
+     * dx `headerFilter.dataSource` — a fixed `{ text, value }` list shown instead of the values
+     * derived from the rows.
+     */
+    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
+     * distinct value in a column is close to unusable without one. 60 of the app's templates
+     * already opt in explicitly, so this only changes the handful that never said either way —
+     * and an explicit `[search]="{ enabled: false }"` still turns it off. */
+    searchEnabled(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeHeaderFilterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeHeaderFilterComponent, "nxe-header-filter", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "allowSearch": { "alias": "allowSearch"; "required": false; "isSignal": true; }; "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
 
 /**
  * `nxe-column` — drop-in replacement for DevExtreme `dxi-column`.
@@ -254,17 +333,21 @@ declare class NxeColumnComponent {
     readonly caption: _angular_core.InputSignal<string>;
     /** Bound row field (supports dotted paths and bound/ternary expressions). */
     readonly dataField: _angular_core.InputSignal<string>;
-    readonly dataType: _angular_core.InputSignal<"string" | "number" | "boolean" | "date">;
+    /**
+     * 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 | 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' } }`).
@@ -272,9 +355,9 @@ declare class NxeColumnComponent {
      */
     readonly lookup: _angular_core.InputSignal<{
         dataSource: readonly any[];
-        valueExpr?: string;
-        displayExpr?: string;
-    }>;
+        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>;
@@ -286,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
@@ -305,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.
      *
@@ -318,10 +401,15 @@ declare class NxeColumnComponent {
      * its children, and flattening them here would collapse the very nesting the band expresses.
      */
     readonly childColumns: _angular_core.Signal<readonly 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 | 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>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeColumnComponent, "nxe-column", never, { "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "dataField": { "alias": "dataField"; "required": false; "isSignal": true; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "customizeText": { "alias": "customizeText"; "required": false; "isSignal": true; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; "lookup": { "alias": "lookup"; "required": false; "isSignal": true; }; "allowSorting": { "alias": "allowSorting"; "required": false; "isSignal": true; }; "allowGrouping": { "alias": "allowGrouping"; "required": false; "isSignal": true; }; "allowResizing": { "alias": "allowResizing"; "required": false; "isSignal": true; }; "allowFiltering": { "alias": "allowFiltering"; "required": false; "isSignal": true; }; "allowEditing": { "alias": "allowEditing"; "required": false; "isSignal": true; }; "allowExporting": { "alias": "allowExporting"; "required": false; "isSignal": true; }; "allowSearch": { "alias": "allowSearch"; "required": false; "isSignal": true; }; "allowHeaderFiltering": { "alias": "allowHeaderFiltering"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "sortOrder": { "alias": "sortOrder"; "required": false; "isSignal": true; }; "sortIndex": { "alias": "sortIndex"; "required": false; "isSignal": true; }; "groupIndex": { "alias": "groupIndex"; "required": false; "isSignal": true; }; "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; "filterValues": { "alias": "filterValues"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "cssClass": { "alias": "cssClass"; "required": false; "isSignal": true; }; "editCellTemplate": { "alias": "editCellTemplate"; "required": false; "isSignal": true; }; "groupCellTemplate": { "alias": "groupCellTemplate"; "required": false; "isSignal": true; }; }, {}, ["childColumns"], never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeColumnComponent, "nxe-column", never, { "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "dataField": { "alias": "dataField"; "required": false; "isSignal": true; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "customizeText": { "alias": "customizeText"; "required": false; "isSignal": true; }; "cellTemplate": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; "lookup": { "alias": "lookup"; "required": false; "isSignal": true; }; "allowSorting": { "alias": "allowSorting"; "required": false; "isSignal": true; }; "allowGrouping": { "alias": "allowGrouping"; "required": false; "isSignal": true; }; "allowResizing": { "alias": "allowResizing"; "required": false; "isSignal": true; }; "allowFiltering": { "alias": "allowFiltering"; "required": false; "isSignal": true; }; "allowEditing": { "alias": "allowEditing"; "required": false; "isSignal": true; }; "allowExporting": { "alias": "allowExporting"; "required": false; "isSignal": true; }; "allowSearch": { "alias": "allowSearch"; "required": false; "isSignal": true; }; "allowHeaderFiltering": { "alias": "allowHeaderFiltering"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "sortOrder": { "alias": "sortOrder"; "required": false; "isSignal": true; }; "sortIndex": { "alias": "sortIndex"; "required": false; "isSignal": true; }; "groupIndex": { "alias": "groupIndex"; "required": false; "isSignal": true; }; "fixed": { "alias": "fixed"; "required": false; "isSignal": true; }; "filterValues": { "alias": "filterValues"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "cssClass": { "alias": "cssClass"; "required": false; "isSignal": true; }; "editCellTemplate": { "alias": "editCellTemplate"; "required": false; "isSignal": true; }; "groupCellTemplate": { "alias": "groupCellTemplate"; "required": false; "isSignal": true; }; }, {}, ["childColumns", "headerFilterConfig"], never, true, never>;
 }
 
 /**
@@ -453,32 +541,6 @@ declare class NxeSelectionComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeSelectionComponent, "nxe-selection", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "selectAllMode": { "alias": "selectAllMode"; "required": false; "isSignal": true; }; "showCheckBoxesMode": { "alias": "showCheckBoxesMode"; "required": false; "isSignal": true; }; "recursive": { "alias": "recursive"; "required": false; "isSignal": true; }; "selectByClick": { "alias": "selectByClick"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-/**
- * `nxe-header-filter` — drop-in replacement for DevExtreme `dxo-header-filter` (grid child option).
- *
- * Adds a funnel icon to each filterable column header; clicking it opens a popup of the column's
- * distinct values (checkbox list + optional search) to filter the grid. The app uses essentially
- * one shape: `[search]="{ enabled: true }" [visible]="true"` (60 files). Legacy `[allowSearch]`
- * (1×) folds into `search.enabled`.
- */
-declare class NxeHeaderFilterComponent {
-    readonly visible: _angular_core.InputSignal<boolean>;
-    readonly search: _angular_core.InputSignal<{
-        enabled?: boolean;
-    }>;
-    /** Legacy alias for `search.enabled` (one holdout). */
-    readonly allowSearch: _angular_core.InputSignal<boolean>;
-    /** Whether the in-popup search box shows.
-     *
-     * Defaults to **true**, matching the legacy DevExtreme deployment: a popup listing every
-     * distinct value in a column is close to unusable without one. 60 of the app's templates
-     * already opt in explicitly, so this only changes the handful that never said either way —
-     * and an explicit `[search]="{ enabled: false }"` still turns it off. */
-    searchEnabled(): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeHeaderFilterComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeHeaderFilterComponent, "nxe-header-filter", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "search": { "alias": "search"; "required": false; "isSignal": true; }; "allowSearch": { "alias": "allowSearch"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
 /**
  * Header-filter state model — the draft/apply/search machinery extracted from
  * `nxe-data-grid` (pivot parity Phase 3a) so the pivot's field panel can reuse it on pages
@@ -490,6 +552,8 @@ declare class NxeHeaderFilterComponent {
  * {@link NxeHeaderFilterSource} adapter, so it owns only the frozen semantics:
  * `(Blanks)` first, Yes/No boolean buckets, the date Year > Month > Day tree, dx search
  * scoping of (Select All), check-on-open, and "everything checked = no filter" on apply.
+ * (Select All)'s indeterminate state ({@link NxeHeaderFilterModel.someChecked}) is derived
+ * from the same draft and search scope, and changes none of these rules.
  */
 /**
  * Header-filter key for blank-ish values (`null`/`undefined`/`''`) — dx lists them as one
@@ -526,17 +590,39 @@ interface NxeHeaderFilterSource<C> {
     boolLabel(column: C, raw: any): 'Yes' | 'No' | null;
     /** Raw-value comparator (numbers numeric, dates by instant, else locale strings). */
     compare(a: any, b: any): number;
+    /**
+     * dx `headerFilter.dataSource` on a column: a fixed `{ text, value }` list replacing the
+     * values derived from the rows. Returning `null` (the default) keeps the derived list.
+     *
+     * A fixed list is used verbatim — declared order, no `(Blanks)` sentinel, and values that
+     * never occur in the data still listed. That is dx's behaviour and the point of supplying
+     * one: a boolean column whose rows are all `true` should still offer "No".
+     */
+    fixedItems?(column: C): {
+        key: any;
+        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. */
@@ -567,6 +653,13 @@ declare class NxeHeaderFilterModel<C = unknown> {
     readonly visibleKeys: _angular_core.Signal<any[]>;
     /** (Select All) state/toggle operate on the VISIBLE keys (dx: search scopes Select All). */
     readonly allChecked: _angular_core.Signal<boolean>;
+    /**
+     * (Select All)'s third state: some visible keys checked, but not all. dx shows it as the
+     * indeterminate square (the select-all dxCheckBox's `value: undefined`). It is never true
+     * together with {@link allChecked}, so check-on-open, which checks everything when no filter
+     * is applied, always opens on a fully checked box and never on a half-checked one.
+     */
+    readonly someChecked: _angular_core.Signal<boolean>;
     /** Whether every key of the whole column is checked — decides "no filter" on apply. */
     readonly fullChecked: _angular_core.Signal<boolean>;
     /**
@@ -589,14 +682,18 @@ declare class NxeHeaderFilterModel<C = unknown> {
  * The header-filter popup panel — the `.nxe-hf-*` chunk extracted from `nxe-data-grid`'s
  * template (pivot parity Phase 3a) so the pivot can open the same popup on pages with no
  * data grid. Same DOM, same FROZEN classes (`.nxe-hf-item`/`.nxe-hf-search`/… — DEFAULTS.md):
- * the host element carries `dx-header-filter-menu nxe-hf-panel`, exactly where the old
- * template's root `<div>` sat inside the overlay pane.
+ * the host element carries `nxe-header-filter-menu nxe-hf-panel`, exactly where the old
+ * template's root `<div>` sat inside the overlay pane. The dx-parity pass only added to that DOM:
+ * the `input.nxe-hf-search` now sits in a `.nxe-hf-searchbox` with its magnifier and clear
+ * button, and rows also carry `.nxe-hf-list-item` / `.nxe-hf-tree-item`.
  *
  * Renders whatever {@link NxeHeaderFilterModel} it is given — checkbox list or the date
  * Year > Month > Day tree — and emits `applied`/`cancelled` for the host to commit/close;
  * 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. */
@@ -605,7 +702,11 @@ declare class NxeHeaderFilterPanelComponent {
     readonly applied: _angular_core.OutputEmitterRef<void>;
     /** Cancel — the host closes without committing. */
     readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    private readonly searchInput;
     protected showSearch(): boolean;
+    /** The search box's clear button (dx search mode forces `showClearButton`): empties the
+        search and keeps the caret in the box, as dx's clear does. */
+    protected clearSearch(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeHeaderFilterPanelComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeHeaderFilterPanelComponent, "nxe-header-filter-panel", never, { "model": { "alias": "model"; "required": true; "isSignal": true; }; "searchEnabled": { "alias": "searchEnabled"; "required": false; "isSignal": true; }; }, { "applied": "applied"; "cancelled": "cancelled"; }, never, never, true, never>;
 }
@@ -665,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>;
 }
@@ -694,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>;
@@ -704,21 +805,32 @@ declare class NxeSummaryComponent {
 /** `dxo-paging` — internal client paging. Presence enables paging; `[pageSize]`/`[pageIndex]` used. */
 declare class NxePagingComponent {
     readonly pageSize: _angular_core.InputSignal<number>;
-    readonly pageIndex: _angular_core.InputSignal<number>;
+    /** Two-way: dx supports `[(pageIndex)]`, and a consumer drives the pager from outside with it. */
+    readonly pageIndex: _angular_core.ModelSignal<number>;
     readonly enabled: _angular_core.InputSignal<boolean>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxePagingComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePagingComponent, "nxe-paging", never, { "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePagingComponent, "nxe-paging", never, { "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; }, { "pageIndex": "pageIndexChange"; }, never, never, true, never>;
 }
 /** `dxo-pager` — the pager UI config. */
 declare class NxePagerComponent {
+    /** `'auto'` shows the pager only when there is more than one page (dx `isVisible`). */
     readonly visible: _angular_core.InputSignal<boolean | "auto">;
+    /** `'auto'` offers half, the same and double the page size (dx `getPageSizes`). */
     readonly allowedPageSizes: _angular_core.InputSignal<number[] | "auto">;
     readonly showPageSizeSelector: _angular_core.InputSignal<boolean>;
     readonly showNavigationButtons: _angular_core.InputSignal<boolean>;
     readonly showInfo: _angular_core.InputSignal<boolean>;
+    /**
+     * `'full'` and `'adaptive'` list the page sizes as buttons; `'compact'` uses a drop-down and
+     * always shows the navigation buttons, as dx's small mode does.
+     */
     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 | undefined>;
+    /** dx `pager.label`: the pager's accessible name. */
+    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; }; }, {}, never, never, true, 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>;
 }
 
 /** A tracked inline change (matches the app's local `Change<T>` shape). */
@@ -754,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>;
 }
@@ -763,8 +875,8 @@ declare class NxeFilterRowComponent {
  * `nxe-master-detail` — drop-in for DevExtreme `dxo-master-detail` (orbit addition).
  *
  * A no-render config element read by the parent `nxe-data-grid`. When `enabled`, the grid
- * prepends a `dx-command-expand` column; expanding a row renders a
- * `<tr class="dx-master-detail-row">` hosting the named sibling
+ * prepends a `nxe-command-expand` column; expanding a row renders a
+ * `<tr class="nxe-master-detail-row">` hosting the named sibling
  * `<ng-template nxeTemplate="...">` with `{ data, rowIndex, key }` — instantiated ONLY while
  * expanded, preserving the app's lazy nested-grid loading (`onRowExpanding` fires first).
  */
@@ -833,6 +945,228 @@ 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. */
+    readonly key: string;
+    /** 0-based page index; -1 for a separator. */
+    readonly page: number;
+    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).
  *
@@ -846,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;
@@ -873,10 +1209,16 @@ declare class NxeGridResizeController {
     destroy(): void;
     private pointerMove;
     private pointerUp;
+    private restore;
     private cancel;
     private teardown;
 }
 
+/**
+ * A column's effective type: declared, or inferred from its values. dx's inference can also land
+ * on 'object' (m_columns_controller_utils.js getValueDataType), which aligns and formats as text.
+ */
+type NxeColType = NxeColumnDataType | 'object';
 /** dx filter-row operations (`selectedFilterOperation`). */
 type NxeFilterOp = 'contains' | 'notcontains' | 'startswith' | 'endswith' | '=' | '<>' | '<' | '<=' | '>' | '>=' | 'between';
 /** Flattened render rows when grouping or tree hierarchy is active. */
@@ -921,10 +1263,12 @@ interface NxeHeaderCell {
 /**
  * `nxe-data-grid` — drop-in replacement for DevExtreme `dx-data-grid` (read-only core, slice 9a).
  *
- * Renders a single `<table>` emitting the dx DOM-class contract (`dx-widget dx-datagrid`,
- * `dx-row`/`dx-header-row`/`dx-data-row`/`dx-datagrid-headers`/`dx-datagrid-rowsview`, `td`s) so
- * the globally-loaded `dx.light.css` + repo `_grid.scss` overrides style it pixel-for-pixel
- * (4px cell padding, #f8fafc header, #525252 header text, row/hover/alt colours). Columns are
+ * Renders a single `<table>` under the library's own class namespace (`nxe-widget nxe-datagrid`,
+ * `nxe-row`/`nxe-header-row`/`nxe-data-row`/`nxe-datagrid-headers`/`nxe-datagrid-rowsview`, `td`s).
+ * The structure still mirrors dx's, name for name, so the visual contract carries over
+ * (4px cell padding, #f8fafc header, #525252 header text, row/hover/alt colours) — but the
+ * `dx-` prefix is gone; `provideNxeDxCompat()` re-emits it for stylesheets not yet migrated.
+ * Columns are
  * collected from `nxe-column` content children; named `cellTemplate`s resolve to sibling
  * `<ng-template nxeTemplate="name">` blocks rendered with `{ data, rowIndex, columnIndex, ... }`
  * (the live row object, so in-cell `nxe-*` editors can write through `key.data.<field>`).
@@ -938,7 +1282,13 @@ declare class NxeDataGridComponent implements OnDestroy {
     private readonly overlay;
     private readonly viewContainerRef;
     private readonly ngZone;
+    private readonly destroyRef;
     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). */
@@ -960,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.
@@ -996,48 +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 noDataTextInput: _angular_core.InputSignal<string>;
+    readonly syncLookupFilterValues: InputSignal<boolean>;
+    readonly columnMinWidth: InputSignal<number | undefined>;
+    /** dx `height` — a bare number means px, anything else passes through. */
+    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>;
-    readonly sorting: _angular_core.InputSignal<{
+    } | 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: 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[]>;
@@ -1046,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;
@@ -1065,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.
@@ -1111,9 +1503,17 @@ 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?;
+    /**
+     * The current page.
+     *
+     * A `linkedSignal` over `nxe-paging`'s own `pageIndex` so the binding is genuinely two-way:
+     * a host that sets `[(pageIndex)]` moves the grid, and `goToPage` writes back. Declaring the
+     * input without this would satisfy an audit while doing nothing — the option would resolve
+     * and be ignored, which is worse than not accepting it.
+     */
     protected readonly pageIndex: _angular_core.WritableSignal<number>;
     private readonly userPageSize;
     /** DevExtreme `.instance` facade — `#gridAll.instance.<method>()`. */
@@ -1136,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;
@@ -1165,14 +1601,67 @@ 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>;
+    /**
+     * The page shown: `pageIndex` held inside the page count. A filter can leave the bound index
+     * past the last page; dx moves it back (m_data_source_adapter.js:454), and the rows, the
+     * pager's selected button, its info text and prev/next all read this one value.
+     */
+    protected readonly currentPage: _angular_core.Signal<number>;
     /** The filtered/sorted rows visible on the current page (all rows when paging is off). */
-    private readonly pagedRows;
+    protected readonly pagedRows: _angular_core.Signal<any[]>;
+    /**
+     * dx `PagerView.isVisible` (m_pager.js): `true` always, `'auto'` only while there is more than
+     * one page to move between, and never under virtual or infinite scrolling.
+     */
     protected readonly pagerVisible: _angular_core.Signal<boolean>;
     protected readonly pageSizes: _angular_core.Signal<number[]>;
-    protected readonly pageNumbers: _angular_core.Signal<number[]>;
+    /** dx's small mode: a page-size drop-down, and the navigation buttons whatever the option says. */
+    protected readonly pagerCompact: _angular_core.Signal<boolean>;
+    /** dx `getRenderPrevButton` (pages/page_index_selector.js): `!isLargeDisplayMode || showNavigationButtons`. */
+    protected readonly pagerNavVisible: _angular_core.Signal<boolean>;
+    /**
+     * The page buttons and `. . .` separators. A linkedSignal because dx's list keeps a sliding
+     * window between renders (pages/large.js): the previous window decides whether the next one
+     * moves.
+     */
+    private readonly pagerWindow;
+    protected readonly pageItems: _angular_core.Signal<readonly NxePagerItem[]>;
     /** True when the host element is `<nxe-tree-list>` (vs `<nxe-data-grid>`). */
     protected readonly treeMode: boolean;
     private readonly expandOverride;
@@ -1182,6 +1671,15 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected toggleTreeNode(key: any, event: Event): void;
     /** Flattened group + data render rows (tree hierarchy, then grouping, then flat). */
     protected readonly renderRows: _angular_core.Signal<GridRenderRow[]>;
+    /**
+     * The dataField a group summary renders under: dx `_calculateSummaryCells` (m_summary.js:443)
+     * takes `showInColumn` when it names a column, else the item's own `column`.
+     *
+     * Keying footers on `column()` alone put an item that names only `showInColumn` (broker's
+     * `name="totalSumInsured" showInColumn="totalSumInsured" summaryType="custom"`) under its
+     * empty `column` - i.e. in whichever column happens to have no dataField.
+     */
+    private summaryTarget;
     /** Computes + formats a summary item over a set of rows. */
     private summaryText;
     /**
@@ -1196,6 +1694,7 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected nextPage(): void;
     protected changePageSize(size: number): void;
     protected onPageSizeSelect(event: Event): void;
+    /** dx's info text, `Page {0} of {1} ({2} items)` unless `infoText` says otherwise (pagination/info.js). */
     protected readonly pageInfo: _angular_core.Signal<string>;
     private static readonly fieldArrayEqual;
     /**
@@ -1269,8 +1768,16 @@ declare class NxeDataGridComponent implements OnDestroy {
     /** True when this header renders a resize handle on its right edge. */
     protected resizeHandleVisible(col: NxeColumnComponent, ci: number): boolean;
     protected startColumnResize(col: NxeColumnComponent, ci: number, event: PointerEvent): void;
+    /** A visible column's position, for cells rendered outside the main `@for` index. */
+    protected visibleIndexOf(col: NxeColumnComponent): number;
     /** Command columns preceding the data columns — the offset dx's 1-based aria-colindex counts from. */
     protected leadCellCount(): number;
+    /** The master-detail expander's aria-colindex: straight after the group indents. */
+    protected readonly expandColIndex: _angular_core.Signal<number>;
+    /** The selection column's aria-colindex: after the indents and the expander. */
+    protected readonly selectColIndex: _angular_core.Signal<number>;
+    /** The row-edit command column's aria-colindex: after the last data column. */
+    protected readonly editColIndex: _angular_core.Signal<number>;
     /** Resize commit: freeze all rendered widths (dx post-resize behavior) + emit width events. */
     private commitColumnResize;
     protected readonly filterRowVisible: _angular_core.Signal<boolean>;
@@ -1278,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;
@@ -1308,13 +1815,33 @@ 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;
     protected isRowEditing(row: any): boolean;
     protected editableCell(col: NxeColumnComponent): boolean;
     protected onCellClick(row: any, col: NxeColumnComponent, event: Event): void;
+    /**
+     * dx `readOnly: !options.setValue` (m_editing.js:210): a grid checkbox is editable only where
+     * dx gives the cell a setValue - cell mode on an editable column (m_editing.js:1832-1847). Row
+     * mode's resting rows stay read-only; the row being edited renders the editor instead.
+     */
+    protected booleanReadOnly(col: NxeColumnComponent): boolean;
+    /**
+     * A boolean cell that is its own editor: cell mode, editable, and no editCellTemplate asking
+     * to take over. The resting checkbox toggles in place, as dx's always-shown dxCheckBox does.
+     */
+    protected booleanInPlace(col: NxeColumnComponent): boolean;
+    /** A resting boolean checkbox was clicked: toggle it when it is editable, else let it be. */
+    protected onBooleanCellClick(row: any, col: NxeColumnComponent, event: Event): void;
+    /**
+     * The checkbox editor's state: the buffered value in the row being edited, else the row's.
+     * Read as the native editor it replaces read it - any value but '' and 'false' is checked.
+     */
+    protected editorChecked(row: any, col: NxeColumnComponent): boolean;
+    /** A click or Space on the checkbox editor. Space must not scroll the page or reach the grid. */
+    protected toggleEditorCheck(row: any, col: NxeColumnComponent, mode: 'cell' | 'row', event: Event): void;
     /** dx cell-mode semantics: commit to the row on blur/Enter (client-side array write-through). */
     protected commitCellEdit(row: any, col: NxeColumnComponent, rawInput: any): void;
     /** Write a cell value through the grid's own path, leaving edit state alone (dx `setValue`). */
@@ -1367,19 +1894,149 @@ 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.
+     *
+     * Keyed on `renderRows` - what the `<tbody>` iterates, dx's `items()` - not `displayRows`. The
+     * two agree for flat and grouped grids (`pagedRows` clamps the page), but a tree list builds
+     * `renderRows` from the unfiltered source while `displayRows` applies the filters, so a tree
+     * whose filter matches nothing still renders rows and must not also show an empty body.
+     */
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    /**
+     * What the last reading of this grid's own layout found.
+     *
+     * - `bounded` is dx's `hasHeight`: the rows view is sized by the grid, not by its rows.
+     * - `room` is dx's `elementHeightWithoutScrollbar - contentHeight` (m_rows_view.js:840-842): the
+     *   rows view's inner height less the table as it stands with the free-space row empty and the
+     *   last row keeping its line. Neither the row's height nor the last-row-border state changes
+     *   it, so what it decides cannot change the next reading.
+     * - `fill` is dx's `resultHeight` (:844-848): the height that leaves the table 1px short of
+     *   the rows view (`_getHeightCorrection`, 1 in Chrome).
+     * - `rowHeight` is dx's `_rowHeight`, the average rendered row. It sizes the gap that a short
+     *   last page leaves.
+     */
+    private readonly freeSpaceMeasure;
+    /**
+     * dx's three cases, in its order:
+     * - no rows: the row shows at 0px, so the last row keeps no border to lose (:857-860);
+     * - a bounded grid whose rows leave room: the row fills it, less the 1px dx subtracts in
+     *   Chrome (`_getHeightCorrection`), and column lines run to the bottom (:837-855);
+     * - an unbounded grid on a short page of several: the row holds the missing rows' height, so
+     *   the grid keeps its height from page to page (:823-835).
+     *
+     * `visible` drives the last row's border in a bordered grid (`_updateLastRowBorder`, :931-937).
+     */
+    private readonly freeSpace;
+    protected readonly freeSpaceHeight: _angular_core.Signal<number>;
+    protected readonly freeSpaceVisible: _angular_core.Signal<boolean>;
+    /**
+     * One reading of the rows view, from the ResizeObserver that watches it and its table.
+     *
+     * dx hides the free-space row and then measures (m_rows_view.js:837-848). This reading cannot
+     * hide it - that would shrink the document and could clamp its scroll position - so it takes
+     * the row's part of the table back out arithmetically, from quantities that do not move with
+     * what the reading decides:
+     *
+     * - The row's box comes out whole: the height it was given, or with none, its halves of the
+     *   collapsed borders above and below it (0.5px under a last row with a 1px frame).
+     * - With no free space shown, a bordered grid's last row gives its line to the box
+     *   (`nxe-last-row-border`, `border-bottom-width:0`), which makes the table a line shorter.
+     *   That line is put back, at the grid's line width, so the answer is the same either way.
+     *
+     * Read naively off the table, either one feeds back: the half-line reads as room, which shows
+     * the row, which gives the line back, which removes the room - a flip every frame - and a
+     * filled row in a rows view that hugs its table reads as its own room, 1px less each time.
+     *
+     * The second case gets its own rule. A rows view that hugs its table while the row adds height
+     * of its own is sized by that row, so it has no room, whatever `height` says: the row lets go
+     * at once. (A bounded grid resized to exactly its table height less the 1px lands here too, and
+     * fills again on the next reading.)
+     *
+     * Whether the grid is bounded (dx `hasHeight`): an explicit `height` other than 'auto' always
+     * is (m_grid_view.js:597-604, `isHeightSpecified`), even a percentage that resolves to auto,
+     * and then has no room while its rows view hugs. Otherwise a rows view that does not hug is
+     * bounded by CSS, and one that hugs while the row holds free space is not, so a grid that
+     * loses its height lets go of the space. When they coincide with no free space held (an exact
+     * fit), the previous answer stands.
+     */
+    private measureFreeSpace;
+    /**
+     * dx `updateColumnDataTypes` (m_columns_controller.js:914-977): a column with no declared
+     * `dataType` takes the type of its values, and mixed values make it 'string'.
+     *
+     * A lookup column is typed by its DISPLAY values - dx's `lookup.dataType`, which is what dx
+     * aligns, formats and edits a lookup by (:901) - and a value with no lookup match contributes
+     * nothing: dx's `lookup.calculateCellValue` returns `valueMap[value]`, undefined for a missing
+     * key, so `getValueDataType` skips it (:946). A not-yet-loaded list must not type the column.
+     *
+     * Once inferred, a type sticks. dx infers only while `dataType` is unset (:935) and stops once
+     * every column is typed (:289), so a later load of mixed values cannot flip a column; the
+     * previous value of this linkedSignal carries that. The refresh tick is in the source because
+     * rows mutated in place (inline editing, `refresh()`) can type a column that was all blanks.
+     *
+     * dx samples the loaded page (or the first group's leaves); this scans the client array,
+     * which only differs when the types are mixed beyond that sample.
+     */
+    private readonly inferredTypes;
+    /** A lookup's value → raw display value, first match winning as in `lookupText`; null without one. */
+    private lookupDisplayMap;
+    /**
+     * The column's effective type - its declared `dataType`, else the inferred one - which is what
+     * dx's `column.dataType` holds after inference. Every type-driven decision reads this, never
+     * `col.dataType()` directly, or an undeclared column would behave as text in one place and
+     * as a number in the next.
+     */
+    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
+     * (dx `lookup.dataType`, :901), which is text - so left, even over numeric codes.
+     */
+    /**
+     * Columns whose cellTemplate draws a check box (nxe-check-box, mat-checkbox, a native
+     * checkbox input or anything with role=checkbox). align() centres them like a boolean column,
+     * header and cells, unless the column asks for center or right. dx centres only by dataType,
+     * so a template check box over non-boolean data (or no dataField) would sit at the left there;
+     * a check box reads as a boolean whatever feeds it, so here it is centred too.
+     *
+     * Sticky, as an inferred type is: a column that drew a check box keeps its alignment when a
+     * filter or an empty page leaves no row to look at. A column that goes away drops out.
+     */
+    private readonly templateCheckboxColumns;
+    private detectTemplateCheckboxColumns;
+    /** Boolean data (declared or inferred) or a cellTemplate seen drawing a check box. */
+    private isCheckboxColumn;
     protected align(col: NxeColumnComponent): string;
+    /**
+     * The filter cell's text-align: dx sets the filter editor's input to the column alignment
+     * unless it is centre (m_filter_row.js:390-395).
+     */
+    protected filterCellAlign(col: NxeColumnComponent): string | null;
     protected colWidth(col: NxeColumnComponent): string | null;
     protected getRaw(row: any, dataField: string): any;
+    /**
+     * dx `showEditorAlways` (m_columns_controller.js:912): a boolean-typed column - declared or
+     * inferred - renders a checkbox, unless it is a lookup or has its own cellTemplate. Decided
+     * per column, not per value: a column whose values are mixed infers 'string' and shows text,
+     * as in dx.
+     */
+    protected isBooleanCell(col: NxeColumnComponent): boolean;
     /** Resolve the displayed cell text: lookup > customizeText > dataType/format > raw string. */
-    /** dx parity: boolean values render as read-only checkboxes (dx dataType inference did this). */
-    protected isBooleanCell(col: NxeColumnComponent, row: any): boolean;
     protected cellText(col: NxeColumnComponent, row: any): string;
     /** 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;
     };
@@ -1406,14 +2063,89 @@ declare class NxeDataGridComponent implements OnDestroy {
      * failure the `effect()` ban exists to prevent.
      */
     private emitPreparedEvents;
+    /**
+     * The single cell holding the grid's tab stop.
+     *
+     * A grid is one stop in the tab order, not one per cell — a 200-row table would otherwise be
+     * 1,400 tab presses to get past. Row `-1` is the header, so ArrowUp from the first data row
+     * reaches the column headers rather than stopping dead.
+     */
+    protected readonly focusedCell: _angular_core.WritableSignal<{
+        row: number;
+        col: number;
+    }>;
+    /**
+     * The rows the keyboard and `aria-rowindex` address: the data rows actually RENDERED.
+     *
+     * Emphatically not `pagedRows()`. That is the page's data BEFORE grouping and tree collapse
+     * take rows out of the DOM, while `renderRows` renumbers densely over what it emits - so with
+     * one group collapsed `pagedRows()` counts three rows where two have a cell to focus. Every
+     * consumer of the count is then wrong in a different way: `aria-rowcount` claims a row a
+     * reader cannot reach, Ctrl+End targets an index with no DOM behind it and movement silently
+     * does nothing, and Enter and Space read `pagedRows()[row]` - which is a DIFFERENT row than
+     * the one under the cursor, so Space selects something the user is not looking at.
+     */
+    protected readonly navigableRows: _angular_core.Signal<any[]>;
+    protected isCellTabStop(row: number, col: number): boolean;
+    protected focusCell(row: number, col: number): void;
+    /** dx marks the sorted column for assistive tech as well as with the arrow glyph. */
+    protected ariaSort(col: NxeColumnComponent): 'ascending' | 'descending' | null;
+    /**
+     * The DOM cell at a logical position, addressed by `aria-colindex` rather than by offset.
+     *
+     * Offsets break twice over. A band cell carries `role="columnheader"` too, so counting
+     * header cells finds bands as well as leaves; and `mergeColumns` deletes the covered `<td>`s,
+     * so a data row can be short. `aria-colindex` is emitted on every cell and already includes
+     * the lead command columns, so it names the position exactly rather than by counting.
+     *
+     * Both lookups stay inside this grid's own table: a master-detail grid renders a whole second
+     * grid into a `<td>`, and its rows would otherwise answer to the outer grid's arrow keys.
+     */
+    private cellAt;
+    /** Move the tab stop and put real DOM focus on the cell that now holds it. */
+    private moveFocus;
+    /**
+     * Arrow-key movement over cells.
+     *
+     * Deliberately not bound to the rowsview: a projected editor inside a cell needs its own
+     * arrow keys, so anything originating inside an editor is left alone.
+     */
+    protected onGridKeydown(event: KeyboardEvent): void;
     /** True when this header can start a drag gesture (to the group panel and/or a reorder). */
     protected headerDraggable(col: NxeColumnComponent): boolean;
     protected onHeaderPointerDown(col: NxeColumnComponent, ci: number, event: PointerEvent): void;
     protected onChipPointerDown(col: NxeColumnComponent, level: number, event: PointerEvent): void;
-    /** Chip click (dx): toggle the grouped column's sort — unless this click ends a drag. */
+    /**
+     * Chip click (dx): toggle the grouped column's sort — unless this click ends a drag. dx sends
+     * it through the same changeSortOrder as a header click (m_sorting.js:134), so the same gate.
+     */
     protected onChipClick(col: NxeColumnComponent): void;
     protected onHeaderClick(col: NxeColumnComponent): void;
     protected sortDir(col: NxeColumnComponent): 'asc' | 'desc' | null;
+    /**
+     * `sorting.mode` as dx's sorting code reads the option: unbound is dx's default 'single', an
+     * object gives its `mode` (default 'single'), and anything else - `[sorting]="false"` or
+     * `null` - has no mode at all.
+     */
+    private sortingMode;
+    /**
+     * dx changeSortOrder (m_columns_controller.js:758-766) acts only in mode 'single' or
+     * 'multiple', and only on a column that allows sorting. `[sorting]="false"` still renders the
+     * sort slot, but a header or chip click never sorts.
+     */
+    private clickSorts;
+    /**
+     * dx `isSortingAllowed` (m_sorting_mixin.js:37): a sortable column, unless the mode is
+     * literally 'none'. A column with no dataField is never sortable (m_columns_controller.js:
+     * 1383-1388). Gates the `nxe-datagrid-action` class, and the sort slot of an unsorted column.
+     */
+    protected sortAllowed(col: NxeColumnComponent): boolean;
+    /**
+     * Whether the header renders dx's sort span: always for the sorted column, and as an empty
+     * `nxe-sort-none` placeholder for any other sortable one (m_sorting_mixin.js:38-46). The
+     * placeholder is display:none in the fixed table and 14px wide in the best-fit pass.
+     */
+    protected sortSlot(col: NxeColumnComponent): boolean;
     protected onRowEnter(index: number): void;
     protected onRowLeave(): void;
     protected isHovered(index: number): boolean;
@@ -1423,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). */
@@ -1439,7 +2177,12 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected frOp(col: NxeColumnComponent): NxeFilterOp;
     protected frText(col: NxeColumnComponent): string;
     protected frText2(col: NxeColumnComponent): string;
-    protected frOpIconClass(col: NxeColumnComponent): string;
+    /**
+     * The chooser glyph: dx's magnifier ('default') until an operation is picked from the menu,
+     * then that operation's own. Only the slug varies - the template emits `nxe-icon-filter-operation-*`
+     * and nothing prefixed `dx-`, which the compat mirror would strip for want of an nxe twin.
+     */
+    protected frOpIconSlug(col: NxeColumnComponent): string;
     protected opIconSlug(op: NxeFilterOp): string;
     protected setFilterRowText(col: NxeColumnComponent, text: string, second?: boolean): void;
     protected openFilterOpMenu(col: NxeColumnComponent, event: Event): void;
@@ -1478,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; }; "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, nxeFormatNumberValue, nxeHfKey, nxeNumberMask, openNxeHeaderFilterOverlay };
-export type { NxeCellInfo, NxeCellPreparedEvent, 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 };