@nexterajs/ui 0.0.1

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

@@ -0,0 +1,1485 @@
+import * as _angular_core from '@angular/core';
+import { NgZone, ViewContainerRef, OnDestroy, EventEmitter, TemplateRef } from '@angular/core';
+import { Overlay, OverlayRef } from '@angular/cdk/overlay';
+
+/** A DevExtreme-style column `format`: a number-mask string, a date format string, or `{ type }`. */
+interface NxeColumnFormatObject {
+    type?: string;
+    precision?: number;
+    /** dx parity: a custom `formatter` wins over `type` (resolved in nxe-format.util). */
+    formatter?: (value: any) => string;
+}
+type NxeColumnFormat = string | NxeColumnFormatObject;
+/** Column `customizeText` callback — `(info) => string` (used by `formatAccounting`). */
+type NxeCustomizeText = (info: {
+    value: any;
+    valueText: string;
+}) => string;
+/**
+ * The `$implicit` context object handed to a cell template, mirroring DevExtreme's cell info.
+ * Templates read `cell.data.<field>` (live row object), `cell.rowIndex`, and `cell.columnIndex`.
+ * `value`/`displayValue`/`text`/`key`/`column` are provided for parity (presently unread in cells).
+ */
+interface NxeCellInfo<T = any> {
+    data: T;
+    rowIndex: number;
+    columnIndex: number;
+    value: any;
+    displayValue: any;
+    text: string;
+    key: T;
+    column: {
+        dataField?: string;
+        caption?: string;
+    } | null;
+}
+/**
+ * The `$implicit` context of an `editCellTemplate`, mirroring DevExtreme's edit-cell info.
+ *
+ * `data` is the LIVE row object. That is the load-bearing part: the dominant template shape
+ * assigns straight to it (`ctx.data.amount = $event`) rather than calling `setValue`, exactly as
+ * it did under dx, and the grid reads display text back off the same object.
+ *
+ * `setValue` is provided for dx parity and routes through the grid's own write path — committing
+ * in `cell` mode, buffering in `row` mode — so a template that uses it participates in Save and
+ * Cancel. A template that writes `data` directly bypasses the buffer, and therefore Cancel; dx
+ * behaves the same way, because it hands out the raw row and does not police it.
+ */
+interface NxeEditCellInfo<T = any> {
+    data: T;
+    key: any;
+    value: any;
+    displayValue: any;
+    text: string;
+    rowIndex: number;
+    columnIndex: number;
+    column: {
+        dataField?: string;
+        caption?: string;
+        dataType?: string;
+        format?: NxeColumnFormat;
+    } | null;
+    /** dx parity: commits in `cell` mode, buffers in `row` mode. */
+    setValue: (newValue: any) => void;
+    component: NxeGridInstance<T>;
+}
+/** dx `rowType` — which kind of row a prepared cell belongs to. */
+type NxeRowType = 'header' | 'filter' | 'data' | 'group' | 'groupFooter' | 'totalFooter';
+/** The row half of a prepared event, shared by `onCellPrepared` and `onRowPrepared`. */
+interface NxeRowInfo<T = any> {
+    rowType: NxeRowType;
+    data: T | undefined;
+    key: any;
+    rowIndex: number;
+    /** Group nesting level for a group or group-footer row; absent elsewhere. */
+    groupIndex?: number;
+    /** dx handlers written against older builds read this name instead. */
+    groupLevel?: number;
+    isExpanded?: boolean;
+    isSelected?: boolean;
+}
+/**
+ * DevExtreme-shaped `onCellPrepared` payload, emitted once per rendered cell after the DOM is
+ * written — `cellElement` is the real `<td>`, and handlers are expected to mutate it.
+ *
+ * The declarative `mergeColumns` and `rowClass` inputs are the recommended way to do what most
+ * handlers do. This exists because applications carry handlers that cannot be rewritten.
+ */
+interface NxeCellPreparedEvent<T = any> {
+    data: T | undefined;
+    key: any;
+    value: any;
+    displayValue: any;
+    text: string;
+    /** Visible-column index, command columns excluded; -1 for a cell that spans columns. */
+    columnIndex: number;
+    /** 0-based data-row index; -1 for header, filter and total-footer rows. */
+    rowIndex: number;
+    column: {
+        dataField?: string;
+        caption?: string;
+        dataType?: string;
+        index: number;
+    } | null;
+    row: NxeRowInfo<T> | null;
+    rowType: NxeRowType;
+    cellElement: HTMLTableCellElement;
+    component: NxeGridInstance<T>;
+    element: HTMLElement;
+}
+/** DevExtreme-shaped `onRowPrepared` payload. `rowClass` covers the common case declaratively. */
+interface NxeRowPreparedEvent<T = any> extends NxeRowInfo<T> {
+    rowElement: HTMLTableRowElement;
+    columnCount: number;
+    component: NxeGridInstance<T>;
+    element: HTMLElement;
+}
+/**
+ * The `$implicit` context of a `groupCellTemplate`, replacing the `"Caption: value"` text in a
+ * group row's caption cell. `value` is the raw group key; `text` is what the grid would have
+ * rendered.
+ */
+interface NxeGroupCellInfo<T = any> {
+    data: T[];
+    key: any;
+    value: any;
+    displayValue: any;
+    text: string;
+    groupIndex: number;
+    columnIndex: number;
+    column: {
+        dataField?: string;
+        caption?: string;
+    } | null;
+    component: NxeGridInstance<T>;
+}
+/**
+ * DevExtreme-shaped `onOptionChanged` payload. Emitted for internal paging
+ * (`paging.pageIndex`) and for runtime grouping changes (`columns[<i>].groupIndex`, where `<i>`
+ * is the column's content-children declaration index) — one event per user gesture, carrying
+ * `previousValue`/`value` exactly as generic-list's persistence handler expects.
+ */
+interface NxeGridOptionChangedEvent {
+    name: string;
+    fullName: string;
+    value: any;
+    previousValue?: any;
+}
+/** DevExtreme-shaped `onSelectionChanged` payload (handlers read `selectedRowsData[0]?.<field>`). */
+interface NxeGridSelectionChangedEvent<T = any> {
+    selectedRowsData: T[];
+    selectedRowKeys: T[];
+    currentSelectedRowKeys: T[];
+    currentDeselectedRowKeys: T[];
+    component: NxeGridInstance<T>;
+    element: HTMLElement | null;
+}
+/**
+ * The `.instance` facade surface — only the methods the codebase actually calls
+ * (`getSelectedRowsData` ×12 in templates, `refresh` ×13, `columnOption(field,'visible',bool)` ×3).
+ */
+interface NxeExportColumn {
+    caption: string;
+    dataField: string;
+    dataType: 'string' | 'number' | 'date' | 'boolean';
+    format: NxeColumnFormat | undefined;
+}
+/** dx TreeList node shape — the slice `exportTreeToExcel` walks (`data` + `children`). */
+interface NxeTreeListNode<T = any> {
+    key?: any;
+    data?: T;
+    children: NxeTreeListNode<T>[];
+    level?: number;
+    hasChildren?: boolean;
+}
+interface NxeGridInstance<T = any> {
+    getSelectedRowsData(): T[];
+    getSelectedRowKeys(): T[];
+    refresh(): void;
+    /**
+     * dx `clearFilter()`: no argument clears the filter row AND header filters (including
+     * declarative `filterValues` seeds); `'row'`/`'header'` clear one kind. `'search'`,
+     * `'filterValue'`, `'dataSource'` are accepted no-ops (those filters don't exist here).
+     */
+    clearFilter(filterName?: 'row' | 'header' | 'search' | 'filterValue' | 'dataSource'): void;
+    /** Only the `(field, 'visible', boolean)` setter form is used (export show/hide toggle). */
+    columnOption(dataField: string, optionName: 'visible', value: boolean): void;
+    /** Export model: currently-visible columns (honours columnOption visibility toggles). */
+    getVisibleColumns(): NxeExportColumn[];
+    /** Export model: the filtered+sorted data rows (all pages). */
+    getVisibleRows(): T[];
+    /**
+     * dx `totalCount()`: data rows after filtering, across all pages. Read as
+     * `e.component.totalCount()` from a cell-prepared handler to size a merge run.
+     */
+    totalCount(): number;
+    /** dx TreeList parity: virtual root whose `children` are the top-level nodes (empty for flat grids). */
+    getRootNode(): NxeTreeListNode<T>;
+    /** DevExtreme parity no-op (layout is CSS-driven); triggers a refresh tick. */
+    updateDimensions(): void;
+    /** Collapses a master-detail row / tree-list node by key (orbit addition). */
+    collapseRow(key: any): void;
+    /** Expands a tree-list node by key, overriding a manual collapse (orbit addition). */
+    expandRow(key: any): void;
+    /**
+     * Ungroups every grouped column (real dx semantics), emitting one `columns[i].groupIndex`
+     * removal per level in descending order so generic-list's persistence replay converges.
+     */
+    clearGrouping(): void;
+    /** Expands all groups / tree nodes (orbit addition). */
+    expandAll(): void;
+    /** Commits the pending row edit, if any (dx parity; cell edits commit on blur). */
+    saveEditData(): void;
+    /** The grid's host element (dx parity: `e.component.element()`). */
+    element(): HTMLElement;
+}
+
+/** Resolve a `format` to a date display pattern — a `{ type }` object's `type` IS the pattern. */
+declare function nxeDatePattern(format: NxeColumnFormat | undefined, fallback?: string): string;
+/**
+ * Resolve a `format` to the LDML number mask the library's number engine understands: string
+ * masks pass through; `{ type: 'fixedPoint' | 'currency', precision }` build a grouped mask
+ * (`currency` deliberately carries NO symbol — DEFAULTS.md). Anything else → `undefined`.
+ */
+declare function nxeNumberMask(format: NxeColumnFormat | undefined): string | undefined;
+/**
+ * Format a numeric value per a dx-style `format` (string mask, `{ type }` object, or
+ * `{ formatter }`). No format / an unresolvable one → `String(value)` (the grid's untyped
+ * rendering).
+ */
+declare function nxeFormatNumberValue(value: number, format: NxeColumnFormat | undefined): string;
+/**
+ * Derive the Excel `numFmt` mask for a `format`: string masks pass through, 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;
+/**
+ * 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.
+ */
+declare function nxeDefaultFormat(dataType: 'string' | 'number' | 'date' | 'boolean' | undefined, format: NxeColumnFormat | undefined, raw: any): string;
+
+/**
+ * `nxe-column` — drop-in replacement for DevExtreme `dxi-column`.
+ *
+ * A no-render config element collected by the parent `nxe-data-grid` via `contentChildren`.
+ * Carries the column's display/format/behaviour config as signals. Works inside `@for`/`@if`
+ * with full property binding (column sets are computed at render time; `dataField`/`caption`
+ * are sometimes expressions). There are no command-button columns or `calculate*` options here.
+ */
+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">;
+    /** 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">;
+    /** Number-mask string (`#,##0.00`), date format string, or `{ type: 'dd MMM yyyy' }`. */
+    readonly format: _angular_core.InputSignal<NxeColumnFormat>;
+    /** `(info:{value}) => string` (e.g. `formatAccounting` for parenthesized negatives). */
+    readonly customizeText: _angular_core.InputSignal<NxeCustomizeText>;
+    /** Name of a sibling `<ng-template nxeTemplate="...">` to render the cell. */
+    readonly cellTemplate: _angular_core.InputSignal<string>;
+    /**
+     * DevExtreme column `lookup` (orbit addition): raw values resolve to display text through
+     * `dataSource` (`{ lookup: { dataSource, valueExpr: 'lovCode', displayExpr: 'lovName' } }`).
+     * Inline cell editing renders a `<select>` over the same list.
+     */
+    readonly lookup: _angular_core.InputSignal<{
+        dataSource: readonly any[];
+        valueExpr?: string;
+        displayExpr?: string;
+    }>;
+    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>;
+    /** dx parity: whether this column shows a resize handle when the grid allows resizing. */
+    readonly allowResizing: _angular_core.InputSignal<boolean>;
+    readonly allowFiltering: _angular_core.InputSignal<boolean>;
+    readonly allowEditing: _angular_core.InputSignal<boolean>;
+    readonly allowExporting: _angular_core.InputSignal<boolean>;
+    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 fixed: _angular_core.InputSignal<boolean>;
+    readonly filterValues: _angular_core.InputSignal<any[]>;
+    /** Column `type` (only `type="date"` seen — a display hint, NOT a command column). */
+    readonly type: _angular_core.InputSignal<string>;
+    /**
+     * 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>;
+    /**
+     * 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
+     * {@link NxeEditCellInfo}, whose `data` is the live row: a template that assigns
+     * `ctx.data.field = $event` writes straight through, which is how dx's own edit templates
+     * were used.
+     */
+    readonly editCellTemplate: _angular_core.InputSignal<string>;
+    /**
+     * 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>;
+    /**
+     * Child columns declared inside this one — dx's banded header. Empty for an ordinary column.
+     *
+     * `descendants: false` is explicit rather than relied upon: a band's grandchildren belong to
+     * its children, and flattening them here would collapse the very nesting the band expresses.
+     */
+    readonly childColumns: _angular_core.Signal<readonly NxeColumnComponent[]>;
+    /** 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>;
+}
+
+/**
+ * One-shot suppression of the click a completed gesture is about to fire, shared by the drag and
+ * resize engines. Strictly gesture-scoped: clears once that trailing click has passed (even when
+ * it lands on an element without a consuming handler) and expires after 500ms, so a later genuine
+ * click is never eaten.
+ */
+declare class NxeGestureClickSuppression {
+    private pending;
+    private until;
+    arm(): void;
+    consume(): boolean;
+}
+/**
+ * Owner-side contract of {@link NxeDragGesture}. The gesture core owns the press → threshold →
+ * drag lifecycle (document listeners outside the zone, ghost mounting/positioning, Escape /
+ * pointercancel semantics, click suppression, ghost/source/body teardown); the delegate owns the
+ * payload, the drop-target hit-testing, and any indicators/highlights beyond the ghost itself.
+ */
+interface NxeDragGestureDelegate {
+    /** Build the ghost's element (classes + content). The gesture appends it to <body> and
+     *  keeps it `position: fixed` at pointer + offset. Called once, when the threshold passes. */
+    createGhost(): HTMLElement;
+    /** Class(es) that dim the pressed source element for the duration of the drag. */
+    sourceDragClasses: readonly string[];
+    /** The 5px threshold just passed — add initial highlights (e.g. the grid's header-row
+     *  drop highlight for chip drags). */
+    dragStarted?(): void;
+    /** Pointer tracking while a drag is active — update drop targets / indicators. */
+    dragMove(x: number, y: number): void;
+    /** Pointer released after a REAL drag. Runs inside the Angular zone; the ghost, source dim,
+     *  and `clearDropVisuals` teardown have already happened (imperative DOM must be gone
+     *  before any signal write re-runs an @for over the drop zone). */
+    drop(): void;
+    /** Remove indicators/highlights the delegate created. Must be idempotent — also runs on
+     *  cancel and destroy. */
+    clearDropVisuals(): void;
+    /** Gesture over (drop dispatched, sub-threshold release, cancel, destroy) — drop payload. */
+    reset?(): void;
+}
+/**
+ * The shared pointer-gesture core (extracted from the grid controller in P3-C2 so the pivot
+ * field panel reuses it rather than copy-pasting). Behavior is the audited 2026-07-27 gesture:
+ * press arms, 5px starts, Escape cancels (suppressing the held pointer's release click),
+ * pointercancel cancels silently, drop arms one-shot click suppression.
+ */
+declare class NxeDragGesture {
+    private readonly zone;
+    private readonly delegate;
+    private active;
+    private readonly suppression;
+    private readonly onMove;
+    private readonly onUp;
+    private readonly onCancel;
+    private readonly onKey;
+    constructor(zone: NgZone, delegate: NxeDragGestureDelegate);
+    /** Arm a gesture on pointerdown. Returns false (payload must NOT be set) when refused. */
+    begin(event: PointerEvent): boolean;
+    /**
+     * One-shot suppression of the click browsers fire right after a drag's pointerup — call at
+     * the top of header/chip/funnel click handlers so a drop never doubles as a click action.
+     */
+    consumeClick(): boolean;
+    destroy(): void;
+    private pointerMove;
+    private mountGhost;
+    private pointerUp;
+    private cancel;
+    private teardownVisuals;
+    private detachListeners;
+}
+interface NxeGridDragHooks {
+    zone: NgZone;
+    host: () => HTMLElement;
+    /** Header dropped on the group panel. */
+    onGroupDrop: (col: NxeColumnComponent) => void;
+    /** Chip dropped outside the panel. */
+    onChipRemove: (col: NxeColumnComponent) => void;
+    /** Chip dropped at another panel position. */
+    onChipMove: (fromLevel: number, toLevel: number) => void;
+    /** dx `allowColumnReordering` (default false) — enables the header-row drop zone. */
+    reorderEnabled: () => boolean;
+    /** Header dropped between two headers: move visible column `from` to insertion `slot`. */
+    onColumnMove: (fromVisibleIndex: number, insertionSlot: number) => void;
+    /** Data-column header cells (command cells excluded), for reorder hit-testing. */
+    headerDataCells: () => HTMLElement[];
+}
+/** The data grid's drag controller — payload + drop topology over the shared gesture core. */
+declare class NxeGridDragController {
+    private readonly hooks;
+    private drag;
+    private readonly gesture;
+    constructor(hooks: NxeGridDragHooks);
+    startHeaderDrag(col: NxeColumnComponent, visibleIndex: number, event: PointerEvent): void;
+    startChipDrag(col: NxeColumnComponent, level: number, event: PointerEvent): void;
+    /** See {@link NxeDragGesture.consumeClick}. */
+    consumeClick(): boolean;
+    destroy(): void;
+    private begin;
+    private updateDropTarget;
+    /** Header-row drop zone (only with `allowColumnReordering`): slot between data headers. */
+    private updateHeaderReorderTarget;
+    private removeColIndicator;
+    private completeDrop;
+    private placeSeparator;
+    private removeSeparator;
+    private panel;
+    private headerRow;
+}
+
+/**
+ * `nxe-selection` — drop-in replacement for DevExtreme `dxo-selection` (grid child option).
+ *
+ * A no-render config element collected by `nxe-data-grid` via `contentChild`. The app only uses
+ * `mode` ("single" ×17 / "multiple" ×14, plain string attrs), `selectAllMode="page"`,
+ * `showCheckBoxesMode` ("always" ×11 shows the checkbox column; "false"/"none" hide it →
+ * selection by row click). `recursive` is tree-list-only (ignored here).
+ */
+declare class NxeSelectionComponent {
+    readonly mode: _angular_core.InputSignal<"none" | "single" | "multiple">;
+    readonly selectAllMode: _angular_core.InputSignal<"page" | "allPages">;
+    /** "always" shows the checkbox column; anything else ("false"/"none"/"onClick") hides it. */
+    readonly showCheckBoxesMode: _angular_core.InputSignal<string>;
+    readonly recursive: _angular_core.InputSignal<boolean>;
+    /** dx parity: row-body clicks toggle selection even when checkboxes are shown. */
+    readonly selectByClick: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeSelectionComponent, never>;
+    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
+ * that have no data grid. Pure signals/computeds, no Angular DI, ZERO behavior change:
+ * every computed/method body is a verbatim move from `nxe-data-grid.component.ts`.
+ *
+ * The model is generic over the column type `C` (the grid passes `NxeColumnComponent`; the
+ * pivot will pass its field descriptor) and reads rows/values through a
+ * {@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.
+ */
+/**
+ * Header-filter key for blank-ish values (`null`/`undefined`/`''`) — dx lists them as one
+ * `(Blanks)` bucket, FIRST (bright audit). A symbol can never collide with data values.
+ */
+declare const NXE_HF_BLANKS: unique symbol;
+/** A node of the date-column header-filter tree (dx: Year > Month > Day, bright audit). */
+interface NxeHfDateNode {
+    label: string;
+    key: string;
+    children: NxeHfDateNode[];
+    /** The draft-set entries this node covers (day keys, or the blanks sentinel). */
+    leafKeys: any[];
+}
+/**
+ * Normalizes a raw cell value to its header-filter key: blank-ish → the `(Blanks)` sentinel,
+ * date columns → a `yyyy-MM-dd` day key (the tree's leaf unit), else the raw value.
+ */
+declare function nxeHfKey(raw: any, isDate: boolean): any;
+/** How the model reads rows and column values — the host (grid, pivot) supplies these. */
+interface NxeHeaderFilterSource<C> {
+    /** The rows the value list is built from. dx does NOT cascade header-filter lists for
+        client arrays (bright audit V6) — the grid passes its FULL dataSource here. */
+    rows(): readonly any[];
+    /** Raw cell value of a row for this column (dotted-path aware on the grid). */
+    rawValue(column: C, row: any): any;
+    /** Formatted display text for a row — used for non-blank, non-boolean-bucket items. */
+    displayText(column: C, row: any): string;
+    /** Date column → values bucket into the Year > Month > Day tree. */
+    isDate(column: C): boolean;
+    /** dx sorts lookup columns by display text, everything else by raw value. */
+    sortByDisplayText(column: C): boolean;
+    /** dx boolean buckets label Yes/No (Yes first); `null` = not a boolean bucket. */
+    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;
+}
+declare class NxeHeaderFilterModel<C = unknown> {
+    private readonly source;
+    private static readonly MONTH_NAMES;
+    /** The column whose popup is open (`null` = closed). */
+    readonly column: _angular_core.WritableSignal<C>;
+    /** 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>);
+    /** 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. */
+    readonly distinct: _angular_core.Signal<{
+        key: any;
+        text: string;
+    }[]>;
+    readonly distinctFiltered: _angular_core.Signal<{
+        key: any;
+        text: string;
+    }[]>;
+    readonly isDate: _angular_core.Signal<boolean>;
+    readonly dateTree: _angular_core.Signal<NxeHfDateNode[]>;
+    /**
+     * Search prunes the tree dx-style: a node stays if its label matches or a descendant does;
+     * a matched-label node with no matching descendants collapses to a leaf (keeps all its keys).
+     */
+    readonly dateTreeFiltered: _angular_core.Signal<NxeHfDateNode[]>;
+    toggleExpand(key: string): void;
+    /** While searching every surviving branch shows expanded (dx auto-expands matches). */
+    nodeExpanded(key: string): boolean;
+    nodeChecked(n: NxeHfDateNode): boolean;
+    nodeIndeterminate(n: NxeHfDateNode): boolean;
+    toggleNode(n: NxeHfDateNode): void;
+    /** Every selectable key of the open column (tree leaves for dates, list keys otherwise). */
+    readonly allKeys: _angular_core.Signal<any[]>;
+    /** The keys currently shown in the popup — with a search active, only the matches. */
+    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>;
+    /** Whether every key of the whole column is checked — decides "no filter" on apply. */
+    readonly fullChecked: _angular_core.Signal<boolean>;
+    /**
+     * Reset the popup state for `column` (check-on-open — FROZEN, see DEFAULTS.md):
+     * no applied filter → everything checked; else start from the applied set.
+     */
+    open(column: C, applied: ReadonlySet<any> | undefined): void;
+    close(): void;
+    toggleValue(value: any): void;
+    toggleAll(): void;
+    /**
+     * The set the host stores on OK: everything checked (or nothing to choose from) =
+     * explicit "no filter" (`null` so a declarative seed can't resurrect); else the
+     * allowed-key set (empty = empty grid).
+     */
+    applyResult(): ReadonlySet<any> | null;
+}
+
+/**
+ * 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.
+ *
+ * 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 {
+    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. */
+    readonly searchEnabled: _angular_core.InputSignal<() => boolean>;
+    /** OK — the host commits the draft and closes. */
+    readonly applied: _angular_core.OutputEmitterRef<void>;
+    /** Cancel — the host closes without committing. */
+    readonly cancelled: _angular_core.OutputEmitterRef<void>;
+    protected showSearch(): boolean;
+    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>;
+}
+
+/**
+ * CDK overlay wiring for the header-filter popup — extracted from `nxe-data-grid` (pivot
+ * parity Phase 3a) so any host (grid header funnel, pivot field panel) opens the identical
+ * popup: dropped below the origin start-aligned (end-aligned fallback), repositioning on
+ * scroll, closing on a transparent-backdrop click, pane carrying `nxePane('nxe-hf-pane')`
+ * (the `.nxe-widget` font contract for body-level panes).
+ */
+interface NxeHeaderFilterOverlayOptions {
+    overlay: Overlay;
+    /** Anchors the panel in the caller's injector AND change-detection tree — exactly what
+        the grid's old `TemplatePortal(panel, viewContainerRef)` attachment did. */
+    viewContainerRef: ViewContainerRef;
+    /** The clicked funnel/trigger element the panel connects to. */
+    origin: HTMLElement;
+    model: NxeHeaderFilterModel<any>;
+    /** Live predicate for the in-popup search box (re-read every CD). */
+    searchEnabled: () => boolean;
+    /** OK — commit the draft and close (the host disposes/detaches the returned ref). */
+    onApply: () => void;
+    /** Cancel button or backdrop click — close without committing. */
+    onClose: () => void;
+}
+/** Create + attach the header-filter popup; the caller keeps the ref to detach/dispose. */
+declare function openNxeHeaderFilterOverlay(options: NxeHeaderFilterOverlayOptions): OverlayRef;
+
+/** `dxo-grouping` — only `[autoExpandAll]="true"` is used (24 grids). */
+declare class NxeGroupingComponent {
+    readonly autoExpandAll: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeGroupingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeGroupingComponent, "nxe-grouping", never, { "autoExpandAll": { "alias": "autoExpandAll"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** `dxo-group-panel` — only `[visible]` is used (23 grids). */
+declare class NxeGroupPanelComponent {
+    readonly visible: _angular_core.InputSignal<boolean | "auto">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeGroupPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeGroupPanelComponent, "nxe-group-panel", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Structural shape the grid reads off a total/group summary item. */
+interface NxeSummaryItemLike {
+    column(): string;
+    summaryType(): 'sum' | 'count' | 'min' | 'max' | 'avg' | 'custom';
+    name(): string | undefined;
+    displayFormat(): string;
+    customizeText(): NxeCustomizeText | undefined;
+    valueFormat(): NxeColumnFormat | undefined;
+    alignByColumn(): boolean;
+    showInGroupFooter(): boolean;
+    showInColumn(): string | undefined;
+}
+/** Shared base for total/group summary items. The app only uses `summaryType="sum"`. */
+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>;
+    /** 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 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>;
+    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>;
+}
+/** `dxi-total-item` — a grand-total footer aggregate. */
+declare class NxeTotalItemComponent extends NxeSummaryItemBase {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeTotalItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeTotalItemComponent, "nxe-total-item", never, {}, {}, never, never, true, never>;
+}
+/** `dxi-group-item` — a per-group footer aggregate. */
+declare class NxeGroupItemComponent extends NxeSummaryItemBase {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeGroupItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeGroupItemComponent, "nxe-group-item", never, {}, {}, never, never, true, never>;
+}
+/** `dxo-summary` — container collecting `nxe-total-item` / `nxe-group-item` children. */
+declare class NxeSummaryComponent {
+    /**
+     * DevExtreme `calculateCustomSummary` (orbit addition): called with the dx protocol —
+     * `{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 totalItems: _angular_core.Signal<readonly NxeTotalItemComponent[]>;
+    readonly groupItems: _angular_core.Signal<readonly NxeGroupItemComponent[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeSummaryComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeSummaryComponent, "nxe-summary", never, { "calculateCustomSummary": { "alias": "calculateCustomSummary"; "required": false; "isSignal": true; }; }, {}, ["totalItems", "groupItems"], ["*"], true, never>;
+}
+
+/** `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>;
+    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>;
+}
+/** `dxo-pager` — the pager UI config. */
+declare class NxePagerComponent {
+    readonly visible: _angular_core.InputSignal<boolean | "auto">;
+    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>;
+    readonly displayMode: _angular_core.InputSignal<"adaptive" | "compact" | "full">;
+    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>;
+}
+
+/** A tracked inline change (matches the app's local `Change<T>` shape). */
+interface NxeGridChange<T = any> {
+    type: 'insert' | 'update' | 'remove';
+    key: any;
+    data: Partial<T>;
+}
+/**
+ * `dxo-editing` — inline editing config. In this app editing is almost always template-driven
+ * (cell templates host `nxe-*` editors two-way-bound to `key.data.<field>`), so `mode="cell"` +
+ * `allowUpdating` are effectively decorative there. `mode="row"` with `[(changes)]`/`[(editRowKey)]`
+ * (autonumber-detail) and native cell editors (job-upsert) drive the grid's native inline editing.
+ */
+declare class NxeEditingComponent {
+    readonly mode: _angular_core.InputSignal<"row" | "cell" | "batch">;
+    readonly allowUpdating: _angular_core.InputSignal<boolean>;
+    readonly allowAdding: _angular_core.InputSignal<boolean>;
+    readonly allowDeleting: _angular_core.InputSignal<boolean>;
+    /** Two-way tracked changes (autonumber-detail's `Change<T>[]`). */
+    readonly changes: _angular_core.ModelSignal<NxeGridChange<any>[]>;
+    /** Two-way key of the row currently in edit mode (row mode). */
+    readonly editRowKey: _angular_core.ModelSignal<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeEditingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeEditingComponent, "nxe-editing", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "allowUpdating": { "alias": "allowUpdating"; "required": false; "isSignal": true; }; "allowAdding": { "alias": "allowAdding"; "required": false; "isSignal": true; }; "allowDeleting": { "alias": "allowDeleting"; "required": false; "isSignal": true; }; "changes": { "alias": "changes"; "required": false; "isSignal": true; }; "editRowKey": { "alias": "editRowKey"; "required": false; "isSignal": true; }; }, { "changes": "changesChange"; "editRowKey": "editRowKeyChange"; }, never, never, true, never>;
+}
+
+/**
+ * `nxe-filter-row` — drop-in for DevExtreme `dxo-filter-row` (orbit addition; psak expressed
+ * the same config through the grid's `[filterRow]` object input, which remains supported).
+ * A no-render config element read by the parent `nxe-data-grid`.
+ */
+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>;
+    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>;
+}
+
+/**
+ * `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
+ * `<ng-template nxeTemplate="...">` with `{ data, rowIndex, key }` — instantiated ONLY while
+ * expanded, preserving the app's lazy nested-grid loading (`onRowExpanding` fires first).
+ */
+declare class NxeMasterDetailComponent {
+    readonly enabled: _angular_core.InputSignal<boolean>;
+    /** Name of the sibling `nxeTemplate` rendered as the detail section (default `detail`). */
+    readonly template: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeMasterDetailComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeMasterDetailComponent, "nxe-master-detail", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "template": { "alias": "template"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * `dxo-scrolling` — accepted for parity.
+ *
+ * Grid: the only usage is `rowRenderingMode="virtual"` (ledger-list), which renders only
+ * visible rows but loads all data; nxe-data-grid renders all rows (datasets are small
+ * enough), so it stays a no-op config there.
+ *
+ * Pivot (LIVE since W4 Lane 3): `NxePivotGridComponent` contentChild's this and
+ * `mode: 'virtual'` arms ROW WINDOWING — for `rowHeaderLayout: 'tree'` ONLY (the standard
+ * layout's rowspan-merged parent labels conflict with row slicing; DEFAULTS.md). Render-only:
+ * fixed 31px row pitch, spacer rows keep the scrollbar honest, and the model/export/chart
+ * always see every row. The DA page projects `mode="virtual"` but renders the standard
+ * layout → no-op there, dx-consistent with its pane-based virtual scrolling being a render
+ * optimization, never a data change.
+ */
+declare class NxeScrollingComponent {
+    readonly mode: _angular_core.InputSignal<"standard" | "virtual" | "infinite">;
+    readonly rowRenderingMode: _angular_core.InputSignal<"standard" | "virtual">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeScrollingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeScrollingComponent, "nxe-scrolling", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "rowRenderingMode": { "alias": "rowRenderingMode"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface NxeExcelExportOptions {
+    /** File name (`.xlsx` appended if missing). */
+    fileName: string;
+    sheetName?: string;
+    /** Default true — sets the sheet auto-filter over the header range. */
+    autoFilter?: boolean;
+    /** Default true — defaults every cell font to 'Calibri Light' (form-report passes false). */
+    applyFont?: boolean;
+}
+/**
+ * Replacement for DevExtreme's `exportDataGrid({component, worksheet, autoFilterEnabled})`.
+ * Walks an {@link NxeGridInstance}'s currently-visible columns + filtered/sorted rows into an
+ * exceljs sheet (header row + autofilter + per-column numFmt), defaults the font to 'Calibri
+ * Light' (preserving the app's `formatExcel`), and saves via `nxeSaveAs` — matching the prior
+ * `report.helper.exportExcel` pipeline.
+ */
+declare function exportNxeGridToExcel(grid: NxeGridInstance, opts: NxeExcelExportOptions): Promise<void>;
+/** Options for {@link exportDataGrid} — mirrors DevExtreme's worksheet-injection call form. */
+interface NxeExportDataGridOptions {
+    component: NxeGridInstance;
+    /**
+     * Caller-supplied worksheet — exceljs `Worksheet` or the in-house one; typed loosely
+     * because the two APIs are structural cousins, not the same declared type.
+     */
+    worksheet: any;
+    autoFilterEnabled?: boolean;
+}
+/**
+ * Drop-in for DevExtreme's `exportDataGrid({component, worksheet, autoFilterEnabled})`
+ * (orbit addition): writes the grid's visible columns + rows into the CALLER's worksheet —
+ * the caller keeps ownership of the workbook, post-formatting, and saving
+ * (`report.helper.exportExcel` pipeline).
+ */
+declare function exportDataGrid(opts: NxeExportDataGridOptions): Promise<void>;
+
+/**
+ * Pointer-based column-resize engine (dx `allowColumnResizing` parity).
+ *
+ * `widget` mode resizes only the dragged column — the table width follows; `nextColumn` (dx
+ * default) trades width with the next visible column at constant table width; both clamp at
+ * `columnMinWidth`. During the drag we write `<col>`/table widths directly (no change detection
+ * per pointermove); the grid commits the final widths into its override signal on release —
+ * freezing the layout exactly like dx does after the first manual resize.
+ */
+interface NxeGridResizeHooks {
+    zone: NgZone;
+    host: () => HTMLElement;
+    mode: () => 'nextColumn' | 'widget';
+    minWidth: () => number;
+    /** Drag started — the grid pauses its auto-width engine. */
+    onStart: () => void;
+    /** Escape/pointercancel — inline styles were restored, resume auto-width. */
+    onCancel: () => void;
+    /** Final widths per affected column; the grid freezes overrides and emits width events. */
+    onCommit: (changes: {
+        field: string;
+        from: number;
+        to: number;
+    }[]) => void;
+}
+declare class NxeGridResizeController {
+    private readonly hooks;
+    private active;
+    private readonly suppression;
+    private readonly onMove;
+    private readonly onUp;
+    private readonly onCancelEv;
+    private readonly onKey;
+    constructor(hooks: NxeGridResizeHooks);
+    /** `visibleIndex`/`lead` locate the header cell + `<col>`; `nextField` only in nextColumn mode. */
+    start(field: string, nextField: string | null, visibleIndex: number, lead: number, event: PointerEvent): void;
+    consumeClick(): boolean;
+    destroy(): void;
+    private pointerMove;
+    private pointerUp;
+    private cancel;
+    private teardown;
+}
+
+/** dx filter-row operations (`selectedFilterOperation`). */
+type NxeFilterOp = 'contains' | 'notcontains' | 'startswith' | 'endswith' | '=' | '<>' | '<' | '<=' | '>' | '>=' | 'between';
+/** Flattened render rows when grouping or tree hierarchy is active. */
+type GridRenderRow = {
+    kind: 'data';
+    row: any;
+    rowIndex: number;
+    level?: number;
+    hasChildren?: boolean;
+    expanded?: boolean;
+    nodeKey?: any;
+} | {
+    kind: 'group';
+    level: number;
+    column: NxeColumnComponent;
+    text: string;
+    /** Raw group key, before formatting — dx hands this to `groupCellTemplate` as `value`. */
+    value: any;
+    /** The rows in this group, dx's `data` for a group cell. */
+    rows: readonly any[];
+    groupKey: string;
+    collapsed: boolean;
+    /** `alignByColumn` group sums keyed by target dataField (`showInColumn ?? column`). */
+    alignedSums: Map<string, string>;
+    /** Non-aligned group items appended to the caption — dx `Caption: Key (a, b)`. */
+    captionSuffix: string;
+} | {
+    kind: 'groupFooter';
+    level: number;
+    /** Per-column formatted sums for items with `showInGroupFooter` (orbit addition). */
+    sums: Map<string, string>;
+};
+/** One `<td>` in the header, which may span columns (a band) or rows (a leaf above the bottom). */
+interface NxeHeaderCell {
+    column: NxeColumnComponent;
+    colspan: number;
+    rowspan: number;
+    isBand: boolean;
+    /** Index into the visible leaf columns; null for a band, which sorts and resizes nothing. */
+    leafIndex: number | null;
+}
+/**
+ * `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
+ * 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>`).
+ *
+ * The `.instance` facade exposes only what the app calls: `getSelectedRowsData()` (12 template
+ * sites), `refresh()` (13), `columnOption(field,'visible',bool)` (3). Selection UI, header-filter,
+ * grouping and summary land in slice 9b.
+ */
+declare class NxeDataGridComponent implements OnDestroy {
+    private readonly elementRef;
+    private readonly overlay;
+    private readonly viewContainerRef;
+    private readonly ngZone;
+    private readonly defaults;
+    /** Pointer drag engine: drag-to-group, chip drag-out (ungroup), chip/column reorder. */
+    protected readonly drag: NxeGridDragController;
+    /** Pointer resize engine (dx allowColumnResizing). */
+    protected readonly resize: NxeGridResizeController;
+    private resizeActive;
+    /**
+     * Columns exactly as declared: top-level leaves and bands, bands still holding their children.
+     * Only the header model reads this — everything else wants leaves.
+     */
+    private readonly declaredColumns;
+    /**
+     * The data columns: bands flattened away, depth-first, in declaration order.
+     *
+     * Keeping `columns()` meaning "the columns that carry data" is what stops banded headers
+     * being a rewrite. Sorting, grouping, filtering, summaries, resize, export and the whole
+     * `<tbody>` are about leaves and continue to work untouched; bands exist only in `<thead>`.
+     */
+    protected readonly columns: _angular_core.Signal<readonly NxeColumnComponent[]>;
+    /** 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>;
+    /** dx resolves `nxe-tree-list` against the `treeList` slice, not `dataGrid`. */
+    private readonly widgetDefaults;
+    readonly hoverStateEnabled: _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 `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.
+     * This grid never cascades those lists for client arrays (see `hfBaseRows`), so `false` is
+     * 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 noDataText: _angular_core.Signal<string>;
+    readonly loadPanel: _angular_core.InputSignal<{
+        enabled?: boolean;
+    }>;
+    readonly paging: _angular_core.InputSignal<{
+        enabled?: boolean;
+        pageSize?: number;
+    }>;
+    readonly filterRow: _angular_core.InputSignal<{
+        visible?: boolean;
+    }>;
+    /** Object-input forms of the config elements (dx accepts both; orbit uses both styles). */
+    readonly headerFilterOptions: _angular_core.InputSignal<{
+        visible?: boolean;
+        search?: {
+            enabled?: boolean;
+        };
+    }>;
+    readonly groupingOptions: _angular_core.InputSignal<{
+        autoExpandAll?: boolean;
+    }>;
+    readonly groupPanelOptions: _angular_core.InputSignal<{
+        visible?: boolean;
+    }>;
+    readonly scrolling: _angular_core.InputSignal<any>;
+    readonly sorting: _angular_core.InputSignal<{
+        mode?: "single" | "multiple" | "none";
+    }>;
+    readonly allowColumnResizing: _angular_core.InputSignal<boolean>;
+    /** dx columnResizingMode: 'nextColumn' (default) trades width; 'widget' grows the table. */
+    readonly columnResizingMode: _angular_core.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 expandedRowKeys: _angular_core.ModelSignal<any[]>;
+    /** Tree-list multi-select keys (`[(selectedRowKeys)]`); recursive via dxo-selection. */
+    readonly selectedRowKeys: _angular_core.ModelSignal<any[]>;
+    /**
+     * Declarative cell merge (orbit addition, replaces the legacy `onCellPrepared` DOM surgery):
+     * 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 onSelectionChanged: _angular_core.OutputEmitterRef<NxeGridSelectionChangedEvent<any>>;
+    readonly onRowClick: _angular_core.OutputEmitterRef<{
+        data: any;
+        rowIndex: number;
+        component: NxeGridInstance;
+    }>;
+    /** Fires after the rendered row set changes (dx parity; used for post-render DOM work). */
+    readonly onContentReady: _angular_core.OutputEmitterRef<{
+        component: NxeGridInstance;
+        element: HTMLElement;
+    }>;
+    /**
+     * dx parity: `{ fullName: 'paging.pageIndex', value }` for internal paging and
+     * `{ fullName: 'columns[<i>].groupIndex', previousValue, value }` for runtime grouping
+     * changes (one event per gesture — the contract generic-list's persistence handler expects).
+     */
+    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>;
+    /**
+     * dx `onCellPrepared` / `onRowPrepared`, fired once per rendered cell and row after the DOM
+     * is written, with the real element for handlers that mutate it.
+     *
+     * Classic EventEmitters, NOT `output()`, for the same reason the pivot uses them: `.observed`
+     * gates a per-cell walk, so a grid that binds neither pays nothing. That gate is the whole
+     * cost model here — without it every grid would walk every cell on every render.
+     *
+     * `mergeColumns` and `rowClass` are the supported way to do what most handlers do; these
+     * exist because applications carry handlers that cannot be rewritten.
+     */
+    readonly onCellPrepared: EventEmitter<NxeCellPreparedEvent<any>>;
+    readonly onRowPrepared: EventEmitter<NxeRowPreparedEvent<any>>;
+    protected rowClassFor(row: any): string;
+    /** Master-detail expand lifecycle (fires before the detail template instantiates). */
+    readonly onRowExpanding: _angular_core.OutputEmitterRef<{
+        key: any;
+        component: NxeGridInstance;
+    }>;
+    readonly onRowExpanded: _angular_core.OutputEmitterRef<{
+        key: any;
+        component: NxeGridInstance;
+    }>;
+    /** Set imperatively by `app-data-pagination-wrapper` (a group-count summary). Stored for 9b. */
+    summary: any;
+    private readonly hoveredIndex;
+    private readonly sort;
+    private readonly sortInit;
+    private readonly visibilityOverride;
+    /** Filter-row state per dataField (operation + typed text) — controlled editors read it back. */
+    private readonly filterRowState;
+    /**
+     * Header-filter runtime overrides: field → allowed-key set, or `null` for "user explicitly
+     * cleared" (a declarative `filterValues` seed must NOT resurrect after Select All → OK).
+     * Absent field = untouched → the column's `filterValues` input seeds the filter (dx parity).
+     */
+    private readonly hfOverride;
+    private readonly selectedSet;
+    private readonly refreshTick;
+    /**
+     * Header-filter popup working state — the draft/search/tree machinery lives in
+     * {@link NxeHeaderFilterModel} (extracted for pivot reuse, Phase 3a); the grid supplies
+     * 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 hfDraft: _angular_core.WritableSignal<ReadonlySet<any>>;
+    private hfOverlayRef?;
+    protected readonly pageIndex: _angular_core.WritableSignal<number>;
+    private readonly userPageSize;
+    /** DevExtreme `.instance` facade — `#gridAll.instance.<method>()`. */
+    private readonly facade;
+    get instance(): NxeGridInstance;
+    /** Guards against a handler that schedules another render re-entering the walk. */
+    private preparedDepth;
+    constructor();
+    private readonly autoWidths;
+    private readonly containerW;
+    private resizeObserver;
+    private autoWidthPending;
+    private lastAutoWidthKey;
+    private scheduleAutoWidthMeasure;
+    private measureAutoWidths;
+    /**
+     * A column with no frozen/declared width appearing AFTER a manual resize froze the layout
+     * (ungrouped chip, re-shown via columnOption): give it dx's default column width instead of
+     * letting the pinned table width squeeze it to ~0.
+     */
+    private frozenColWidth;
+    protected effectiveColWidth(col: NxeColumnComponent, idx: number): string | null;
+    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>;
+    /** 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>;
+    private rowKey;
+    private treeDescendantKeys;
+    private toggleTreeSelection;
+    private emitTreeSelectionChanged;
+    /** `grouping.autoExpandAll` from the child element or object input; dx default is true. */
+    private readonly groupAutoExpand;
+    /** The current expand default — `expandAll()` flips it to true; an input change resets it. */
+    private readonly groupExpandDefault;
+    /**
+     * Per-groupKey manual toggles. Reset when the autoExpandAll option flips or the group
+     * configuration changes (dx repaints and re-applies the default; drag-created groups inherit it).
+     */
+    private readonly groupExpandOverride;
+    private isGroupExpanded;
+    protected readonly groupPanelVisible: _angular_core.Signal<boolean>;
+    protected readonly isGrouped: _angular_core.Signal<boolean>;
+    private readonly totalItems;
+    private readonly groupItems;
+    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>>;
+    protected readonly pagingEnabled: _angular_core.Signal<boolean>;
+    protected readonly effectivePageSize: _angular_core.Signal<number>;
+    protected readonly pageCount: _angular_core.Signal<number>;
+    /** The filtered/sorted rows visible on the current page (all rows when paging is off). */
+    private readonly pagedRows;
+    protected readonly pagerVisible: _angular_core.Signal<boolean>;
+    protected readonly pageSizes: _angular_core.Signal<number[]>;
+    protected readonly pageNumbers: _angular_core.Signal<number[]>;
+    /** True when the host element is `<nxe-tree-list>` (vs `<nxe-data-grid>`). */
+    protected readonly treeMode: boolean;
+    private readonly expandOverride;
+    /** Tree assembled from the flat dataSource via keyExpr/parentIdExpr/rootValue. */
+    private readonly treeRoots;
+    private readonly treeExpanded;
+    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[]>;
+    /** Computes + formats a summary item over a set of rows. */
+    private summaryText;
+    /**
+     * DevExtreme `calculateCustomSummary` protocol replay (orbit addition): `start`, then
+     * `calculate` once per row (`options.value` = the row object, matching the app's
+     * `generateSummaryFunction` which reads row properties), then `finalize`.
+     */
+    private customSummaryValue;
+    protected toggleGroup(groupKey: string): void;
+    protected goToPage(index: number): void;
+    protected prevPage(): void;
+    protected nextPage(): void;
+    protected changePageSize(size: number): void;
+    protected onPageSizeSelect(event: Event): void;
+    protected readonly pageInfo: _angular_core.Signal<string>;
+    private static readonly fieldArrayEqual;
+    /**
+     * Declarative seed: ordered dataFields of columns declaring `groupIndex`. Custom equality so
+     * unrelated column-input churn (captions, widths, lookups) can never reset runtime drag state.
+     */
+    private readonly declaredGroupFields;
+    /**
+     * THE group state — array order == group level. Runtime gestures (drag-to-group, chip
+     * drag-out/reorder, clearGrouping) win until the declarative seed itself changes
+     * (generic-list re-seeds `groupIndex` from localStorage through `filterResource`).
+     */
+    private readonly groupedFields;
+    /**
+     * Per-grouped-column sort direction (dx: grouping a column sorts it ascending; clicking its
+     * group-panel chip cycles asc↔desc). Pruned to the currently grouped fields so a re-grouped
+     * column starts fresh at `asc`.
+     */
+    private readonly groupSortDir;
+    /** Columns moved into group rows, in group-level order. */
+    protected readonly groupColumns: _angular_core.Signal<NxeColumnComponent[]>;
+    /** The active sort direction of a grouped column (chip indicator + group-order comparator). */
+    protected groupDir(col: NxeColumnComponent): 'asc' | 'desc';
+    /** Chip click (dx): cycle the grouped column's sort asc↔desc — never back to none. */
+    protected sortGroupColumn(col: NxeColumnComponent): void;
+    /** Gesture: drag a header into the group panel — append as the last group level. */
+    protected groupByColumn(col: NxeColumnComponent): void;
+    /** Gesture: drag a chip out of the group panel — remove that group level. */
+    protected ungroupColumn(field: string): void;
+    /**
+     * Gesture: reorder chips within the group panel — move a group level.
+     *
+     * Emission contract: generic-list's frozen handler replays each event as a positional SWAP,
+     * while a chip drag is a MOVE. The two only coincide for adjacent positions, so a distance-n
+     * move emits n adjacent-swap events (each adjacent swap == the corresponding move step) —
+     * the replayed array converges to exactly the grid's order.
+     */
+    protected moveGroup(from: number, to: number): void;
+    /**
+     * Real dx `clearGrouping()`: ungroup everything. Removal events fire in DESCENDING level
+     * order so generic-list's `splice(previousValue, 1)` replay converges to `[]`.
+     */
+    private clearGroupingInternal;
+    private emitGroupIndexChange;
+    private readonly declaredFieldOrder;
+    /** Runtime column order; header drag-reorder wins until the declared column set changes. */
+    private readonly fieldOrder;
+    private readonly declaredWidthsKey;
+    /**
+     * Manual column widths (px). Populated on the first resize with a snapshot of every rendered
+     * width — freezing the layout like dx — and reset when declared widths change.
+     */
+    private readonly widthOverride;
+    /** Visible data columns: `visible`/`columnOption` honoured, grouped columns excluded. */
+    protected readonly visibleColumns: _angular_core.Signal<NxeColumnComponent[]>;
+    /**
+     * How many header rows the band structure needs, counted over the VISIBLE tree.
+     *
+     * Pruning matters: a band whose every leaf is hidden or grouped away contributes no row, so
+     * a grid that loses its last band collapses back to a single header row rather than keeping
+     * an empty one.
+     */
+    protected readonly headerDepth: _angular_core.Signal<number>;
+    /**
+     * The header as rows of cells: bands carry `colspan`, leaves above the bottom row carry
+     * `rowspan`, which is dx's own banded markup.
+     */
+    protected readonly headerRows: _angular_core.Signal<NxeHeaderCell[][]>;
+    /** Drag-reorder drop: move visible column `fromVis` to insertion `slot` (dx visibleIndex). */
+    protected moveColumnByVisible(fromVis: number, slot: number): void;
+    /** 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;
+    /** Command columns preceding the data columns — the offset dx's 1-based aria-colindex counts from. */
+    protected leadCellCount(): number;
+    /** Resize commit: freeze all rendered widths (dx post-resize behavior) + emit width events. */
+    private commitColumnResize;
+    protected readonly filterRowVisible: _angular_core.Signal<boolean>;
+    protected readonly masterDetailEnabled: _angular_core.Signal<boolean>;
+    private readonly expandedDetails;
+    protected isDetailExpanded(row: any): boolean;
+    protected toggleDetail(row: any, event: Event): void;
+    protected detailTemplate(): TemplateRef<unknown>;
+    protected detailContext(row: any, rowIndex: number): {
+        $implicit: {
+            data: any;
+            rowIndex: number;
+            key: any;
+        };
+    };
+    /** Group indent levels (dx renders one 30px command column per group level; grid mode only). */
+    protected readonly groupLevelCount: _angular_core.Signal<number>;
+    protected indents(count: number): number[];
+    /** Visible columns from the first alignByColumn target onward — each gets its own summary td. */
+    protected groupRowTrailing(item: {
+        level: number;
+        alignedSums: Map<string, string>;
+    }): NxeColumnComponent[];
+    /** dx group-cell span: everything after the expand cell not taken by aligned summary cells. */
+    protected groupCellColspan(item: {
+        level: number;
+        alignedSums: Map<string, string>;
+    }): number;
+    /** Total column count including command columns (indents/checkbox/expand/edit) for colspans. */
+    protected readonly allColCount: _angular_core.Signal<number>;
+    protected readonly cellEditingEnabled: _angular_core.Signal<boolean>;
+    protected readonly rowEditingEnabled: _angular_core.Signal<boolean>;
+    protected readonly rowEditCommandVisible: _angular_core.Signal<boolean>;
+    /** The single cell in edit mode (`cell` mode): row ref + dataField. */
+    protected readonly editingCell: _angular_core.WritableSignal<{
+        row: any;
+        field: string;
+    }>;
+    /** 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 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`). */
+    private writeCellValue;
+    protected cancelCellEdit(): void;
+    /**
+     * Leave cell-edit state when focus goes somewhere outside the cell.
+     *
+     * The built-in editor commits on its own blur, but a projected `editCellTemplate` has no such
+     * contract, so the cell needs to notice for itself. Nothing is committed here: those templates
+     * write through the live row object, so leaving edit state is purely a view change.
+     *
+     * A projected picker opens its panel in a CDK overlay appended to `<body>`, which means focus
+     * legitimately leaves the `<td>` while the edit is still going on — hence the second guard.
+     */
+    protected onEditCellFocusOut(row: any, col: NxeColumnComponent, event: FocusEvent): void;
+    private writeCell;
+    protected startRowEdit(row: any, event: Event): void;
+    protected bufferRowEdit(col: NxeColumnComponent, rawInput: any): void;
+    /** dx row-mode Save: apply the buffer to the row and record an `update` change. */
+    protected saveRowEdit(row: any, event: Event): void;
+    protected cancelRowEdit(event: Event): void;
+    protected editorInputValue(row: any, col: NxeColumnComponent): string;
+    /**
+     * Rowspan map over `renderRows`: `"<renderIndex>:<field>"` → span (>1 = merged head,
+     * 0 = suppressed continuation, absent = normal cell). Hierarchical: a value break in an
+     * earlier merge column breaks all later ones; group/detail rows break every run.
+     */
+    protected readonly mergeSpans: _angular_core.Signal<ReadonlyMap<string, number>>;
+    protected mergeSpan(renderIndex: number, col: NxeColumnComponent): number | null;
+    protected isMergeSuppressed(renderIndex: number, col: NxeColumnComponent): boolean;
+    private readonly columnByField;
+    private readonly filterRowPredicate;
+    /** Builds one column's filter-row matcher; null when the entry has no effective value yet. */
+    private buildFilterRowMatcher;
+    private matchScalar;
+    private dayKey;
+    /**
+     * The applied header filters: runtime overrides win; untouched columns fall back to their
+     * declarative `filterValues` seed. Values are normalized through `hfKey`.
+     */
+    private readonly effectiveHeaderFilters;
+    private readonly headerFilterPredicate;
+    /** dataSource → filter-row filters → header filters (sorting happens in `displayRows`). */
+    private readonly filteredRows;
+    /**
+     * dx sort semantics: grouped columns lead the sort expression in level order (each by its
+     * group direction), then the user/declarative sort applies WITHIN the innermost groups.
+     * Ungrouped grids keep the single-column behavior unchanged.
+     */
+    protected readonly displayRows: _angular_core.Signal<any[]>;
+    protected readonly loading: _angular_core.Signal<boolean>;
+    /** The active sort: an explicit user click, else the first column declaring `sortOrder`. */
+    private effectiveSort;
+    protected align(col: NxeColumnComponent): string;
+    protected colWidth(col: NxeColumnComponent): string | null;
+    protected getRaw(row: any, dataField: string): any;
+    /** 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 cellContext(row: any, rowIndex: number, columnIndex: number, col: NxeColumnComponent): {
+        $implicit: NxeCellInfo;
+    };
+    protected editCellContext(row: any, rowIndex: number, columnIndex: number, col: NxeColumnComponent): {
+        $implicit: NxeEditCellInfo;
+    };
+    protected groupCellContext(item: {
+        column: NxeColumnComponent;
+        text: string;
+        value: any;
+        rows: readonly any[];
+        level: number;
+        captionSuffix: string;
+    }): {
+        $implicit: NxeGroupCellInfo;
+    };
+    /**
+     * dx `onCellPrepared` / `onRowPrepared`.
+     *
+     * Emitted from a render hook rather than an effect, because the payload carries the real
+     * `<td>`: it cannot exist before the DOM does. `afterRenderEffect` is the sanctioned
+     * primitive for that here, and the walk runs inside `untracked()` so a handler that happens
+     * to read a signal cannot enrol it in this hook's dependency set — the invisible-dependency
+     * failure the `effect()` ban exists to prevent.
+     */
+    private emitPreparedEvents;
+    /** 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. */
+    protected onChipClick(col: NxeColumnComponent): void;
+    protected onHeaderClick(col: NxeColumnComponent): void;
+    protected sortDir(col: NxeColumnComponent): 'asc' | 'desc' | null;
+    protected onRowEnter(index: number): void;
+    protected onRowLeave(): void;
+    protected isHovered(index: number): boolean;
+    protected isSelected(row: any): boolean;
+    /** Row body click: single-select (LOV pickers) or toggle when checkboxes are hidden. */
+    protected onDataRowClick(row: any, rowIndex?: number): void;
+    protected onCheckboxClick(row: any, event: Event): void;
+    private toggleRow;
+    protected toggleSelectAll(event: Event): void;
+    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>;
+    private frMenuOverlayRef?;
+    private readonly frMenuPanel;
+    /** Which editor a filter cell renders (mirrors dx: select for lookup/boolean, typed inputs). */
+    protected frEditorKind(col: NxeColumnComponent): 'lookup' | 'boolean' | 'date' | 'number' | 'text';
+    /** dx shows the operation-chooser magnifier only for typed (non-select) editors. */
+    protected frHasOpMenu(col: NxeColumnComponent): boolean;
+    private frDefaultOp;
+    protected frOp(col: NxeColumnComponent): NxeFilterOp;
+    protected frText(col: NxeColumnComponent): string;
+    protected frText2(col: NxeColumnComponent): string;
+    protected frOpIconClass(col: NxeColumnComponent): string;
+    protected opIconSlug(op: NxeFilterOp): string;
+    protected setFilterRowText(col: NxeColumnComponent, text: string, second?: boolean): void;
+    protected openFilterOpMenu(col: NxeColumnComponent, event: Event): void;
+    protected frMenuOps(): {
+        op: NxeFilterOp;
+        label: string;
+    }[];
+    protected selectFilterOp(op: NxeFilterOp): void;
+    /** dx Reset menu item: restore the default operation and clear the editor. */
+    protected resetFilterRow(): void;
+    protected closeFilterOpMenu(): void;
+    protected readonly headerFilterEnabled: _angular_core.Signal<boolean>;
+    protected hasHeaderFilter(col: NxeColumnComponent): boolean;
+    /** Whether this column shows a funnel — the grid has header filtering on AND the column opts in.
+        Named because the header cell asks three times (the caption's indicator class, the wrapper's
+        existence, the funnel itself) and the group-panel chip asks again. */
+    protected headerFilterVisible(col: NxeColumnComponent): boolean;
+    /**
+     * Normalizes a raw cell value to its header-filter key: blank-ish → the `(Blanks)` sentinel,
+     * date columns → a `yyyy-MM-dd` day key (the tree's leaf unit), else the raw value.
+     */
+    private hfKey;
+    /** dx does NOT cascade header-filter lists for client arrays (bright audit V6). */
+    private hfBaseRows;
+    private hfBoolLabel;
+    /** (Select All) checkbox state — spec-pinned alias of the model's computed
+        ((Select All) operates on the VISIBLE keys: dx scopes it to the search). */
+    protected readonly hfAllChecked: _angular_core.Signal<boolean>;
+    /** Default true — see NxeHeaderFilterComponent.searchEnabled. The two branches have to agree,
+        since a grid can be configured either by the content child or by the object input. */
+    protected hfSearchEnabled(): boolean;
+    protected openHeaderFilter(col: NxeColumnComponent, event: Event): void;
+    protected hfApply(): void;
+    protected closeHeaderFilter(): void;
+    private setColumnVisible;
+    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>;
+}
+
+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 };