@nexterajs/ui 0.0.1 → 0.0.2

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

@@ -1,5 +1,7 @@
+import { NxeNumberSeparators } from '@nexterajs/ui/intl';
 import * as _angular_core from '@angular/core';
 import { NgZone, ViewContainerRef, OnDestroy, EventEmitter, TemplateRef } from '@angular/core';
+import { NxeExpr } from '@nexterajs/ui/core';
 import { Overlay, OverlayRef } from '@angular/cdk/overlay';
 
 /** A DevExtreme-style column `format`: a number-mask string, a date format string, or `{ type }`. */
@@ -10,6 +12,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 +169,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`). */
@@ -227,20 +236,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): 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;
+    }>;
+    /** Legacy alias for `search.enabled` (one holdout). */
+    readonly allowSearch: _angular_core.InputSignal<boolean>;
+    /**
+     * 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;
+    }[]>;
+    /** 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,7 +325,11 @@ 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>;
     /** px width — number (`[width]="150"`) or numeric string (`width="200"`). */
     readonly width: _angular_core.InputSignal<string | number>;
     readonly minWidth: _angular_core.InputSignal<string | number>;
@@ -272,8 +347,8 @@ declare class NxeColumnComponent {
      */
     readonly lookup: _angular_core.InputSignal<{
         dataSource: readonly any[];
-        valueExpr?: string;
-        displayExpr?: string;
+        valueExpr?: NxeExpr;
+        displayExpr?: NxeExpr;
     }>;
     readonly allowSorting: _angular_core.InputSignal<boolean>;
     /** dx parity: whether the header can be dragged into the group panel (default true). */
@@ -318,10 +393,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>;
     /** 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 +533,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 +544,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,6 +582,18 @@ 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;
 }
 declare class NxeHeaderFilterModel<C = unknown> {
     private readonly source;
@@ -567,6 +635,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,8 +664,10 @@ 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;
@@ -605,7 +682,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>;
 }
@@ -704,21 +785,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>;
+    /** dx `pager.label`: the pager's accessible name. */
+    readonly label: _angular_core.InputSignal<string>;
     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). */
@@ -763,8 +855,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 +925,15 @@ interface NxeExportDataGridOptions {
  */
 declare function exportDataGrid(opts: NxeExportDataGridOptions): Promise<void>;
 
+/** 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;
+}
+
 /**
  * Pointer-based column-resize engine (dx `allowColumnResizing` parity).
  *
@@ -877,6 +978,11 @@ declare class NxeGridResizeController {
     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 +1027,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 +1046,10 @@ 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;
     /** Pointer drag engine: drag-to-group, chip drag-out (ungroup), chip/column reorder. */
     protected readonly drag: NxeGridDragController;
     /** Pointer resize engine (dx allowColumnResizing). */
@@ -998,6 +1109,9 @@ declare class NxeDataGridComponent implements OnDestroy {
      */
     readonly syncLookupFilterValues: _angular_core.InputSignal<boolean>;
     readonly columnMinWidth: _angular_core.InputSignal<number>;
+    /** dx `height` — a bare number means px, anything else passes through. */
+    readonly height: _angular_core.InputSignal<string | number>;
+    protected readonly heightStyle: _angular_core.Signal<string>;
     readonly noDataTextInput: _angular_core.InputSignal<string>;
     readonly noDataText: _angular_core.Signal<string>;
     readonly loadPanel: _angular_core.InputSignal<{
@@ -1024,7 +1138,11 @@ declare class NxeDataGridComponent implements OnDestroy {
         visible?: boolean;
     }>;
     readonly scrolling: _angular_core.InputSignal<any>;
-    readonly sorting: _angular_core.InputSignal<{
+    /**
+     * dx `sorting`. Unbound means dx's default mode 'single'. `false` and `null` are accepted as dx
+     * reads them - no mode, so headers keep their sort slot but a click never sorts.
+     */
+    readonly sorting: _angular_core.InputSignal<false | {
         mode?: "single" | "multiple" | "none";
     }>;
     readonly allowColumnResizing: _angular_core.InputSignal<boolean>;
@@ -1114,6 +1232,14 @@ declare class NxeDataGridComponent implements OnDestroy {
     protected readonly hfColumn: _angular_core.WritableSignal<NxeColumnComponent>;
     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>()`. */
@@ -1168,11 +1294,31 @@ declare class NxeDataGridComponent implements OnDestroy {
     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 +1328,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 +1351,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 +1425,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>;
@@ -1315,6 +1479,26 @@ declare class NxeDataGridComponent implements OnDestroy {
     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,14 +1551,138 @@ declare class NxeDataGridComponent implements OnDestroy {
      */
     protected readonly displayRows: _angular_core.Signal<any[]>;
     protected readonly loading: _angular_core.Signal<boolean>;
+    /**
+     * 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;
+    /**
+     * 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;
@@ -1406,14 +1714,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;
@@ -1439,7 +1822,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 +1866,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; }; "remoteOperations": { "alias": "remoteOperations"; "required": false; "isSignal": true; }; "syncLookupFilterValues": { "alias": "syncLookupFilterValues"; "required": false; "isSignal": true; }; "columnMinWidth": { "alias": "columnMinWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "noDataTextInput": { "alias": "noDataText"; "required": false; "isSignal": true; }; "loadPanel": { "alias": "loadPanel"; "required": false; "isSignal": true; }; "paging": { "alias": "paging"; "required": false; "isSignal": true; }; "filterRow": { "alias": "filterRow"; "required": false; "isSignal": true; }; "headerFilterOptions": { "alias": "headerFilter"; "required": false; "isSignal": true; }; "groupingOptions": { "alias": "grouping"; "required": false; "isSignal": true; }; "groupPanelOptions": { "alias": "groupPanel"; "required": false; "isSignal": true; }; "scrolling": { "alias": "scrolling"; "required": false; "isSignal": true; }; "sorting": { "alias": "sorting"; "required": false; "isSignal": true; }; "allowColumnResizing": { "alias": "allowColumnResizing"; "required": false; "isSignal": true; }; "columnResizingMode": { "alias": "columnResizingMode"; "required": false; "isSignal": true; }; "allowColumnReordering": { "alias": "allowColumnReordering"; "required": false; "isSignal": true; }; "repaintChangesOnly": { "alias": "repaintChangesOnly"; "required": false; "isSignal": true; }; "showColumnHeaders": { "alias": "showColumnHeaders"; "required": false; "isSignal": true; }; "parentIdExpr": { "alias": "parentIdExpr"; "required": false; "isSignal": true; }; "dataStructure": { "alias": "dataStructure"; "required": false; "isSignal": true; }; "rootValue": { "alias": "rootValue"; "required": false; "isSignal": true; }; "autoExpandAll": { "alias": "autoExpandAll"; "required": false; "isSignal": true; }; "expandedRowKeys": { "alias": "expandedRowKeys"; "required": false; "isSignal": true; }; "selectedRowKeys": { "alias": "selectedRowKeys"; "required": false; "isSignal": true; }; "mergeColumns": { "alias": "mergeColumns"; "required": false; "isSignal": true; }; "rowClass": { "alias": "rowClass"; "required": false; "isSignal": true; }; }, { "expandedRowKeys": "expandedRowKeysChange"; "selectedRowKeys": "selectedRowKeysChange"; "onSelectionChanged": "onSelectionChanged"; "onRowClick": "onRowClick"; "onContentReady": "onContentReady"; "onOptionChanged": "onOptionChanged"; "onCellPrepared": "onCellPrepared"; "onRowPrepared": "onRowPrepared"; "onRowExpanding": "onRowExpanding"; "onRowExpanded": "onRowExpanded"; }, ["declaredColumns", "templates", "selection", "headerFilter", "grouping", "groupPanel", "summaryCmp", "pagingCmp", "pagerCmp", "editingCmp", "filterRowCmp", "masterDetail"], never, true, never>;
 }
 
-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, NxeColumnComponent, NxeDataGridComponent, NxeDragGesture, NxeEditingComponent, NxeFilterRowComponent, NxeGestureClickSuppression, NxeGridDragController, NxeGroupItemComponent, NxeGroupPanelComponent, NxeGroupingComponent, NxeHeaderFilterComponent, NxeHeaderFilterModel, NxeHeaderFilterPanelComponent, NxeMasterDetailComponent, NxePagerComponent, NxePagingComponent, NxeScrollingComponent, NxeSelectionComponent, NxeSummaryComponent, NxeTotalItemComponent, exportDataGrid, exportNxeGridToExcel, nxeDatePattern, nxeDefaultFormat, nxeExcelNumFmt, nxeExcelNumberMask, nxeFormatNumberValue, nxeHfKey, nxeNumberMask, nxeNumberValue, nxeValueDataType, openNxeHeaderFilterOverlay };
+export type { NxeCellInfo, NxeCellPreparedEvent, NxeColumnDataType, NxeColumnFormat, NxeColumnFormatObject, NxeCustomizeText, NxeDragGestureDelegate, NxeEditCellInfo, NxeExcelExportOptions, NxeExportColumn, NxeExportDataGridOptions, NxeFilterOp, NxeGridChange, NxeGridDragHooks, NxeGridInstance, NxeGridOptionChangedEvent, NxeGridSelectionChangedEvent, NxeGroupCellInfo, NxeHeaderCell, NxeHeaderFilterOverlayOptions, NxeHeaderFilterSource, NxeHfDateNode, NxeRowInfo, NxeRowPreparedEvent, NxeRowType, NxeSummaryItemLike, NxeTreeListNode };