@nexterajs/ui 0.0.1

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

@@ -0,0 +1,1470 @@
+import { NxeColumnFormat, NxeGridInstance, NxeExcelExportOptions, NxeScrollingComponent, NxeHeaderFilterModel } from '@nexterajs/ui/grid';
+import * as _angular_core from '@angular/core';
+import { OnDestroy, TemplateRef, Signal, EventEmitter } from '@angular/core';
+
+type NxePivotArea = 'row' | 'column' | 'data' | 'filter';
+type NxePivotSummaryType = 'sum' | 'count' | 'min' | 'max' | 'avg' | 'custom';
+/** dx `summaryDisplayMode` values (P2-C3; transcribed from m_summary_display_modes.js). */
+type NxePivotSummaryDisplayMode = 'absoluteVariation' | 'percentVariation' | 'percentOfColumnTotal' | 'percentOfRowTotal' | 'percentOfColumnGrandTotal' | 'percentOfRowGrandTotal' | 'percentOfGrandTotal';
+/** dx date `groupInterval` names (m_local_store `DATE_INTERVAL_SELECTORS`); numbers = step. */
+type NxePivotGroupInterval = 'year' | 'quarter' | 'month' | 'day' | 'dayOfWeek' | number;
+/**
+ * The `e` object a `calculateSummaryValue` callback receives — dx `SummaryCell` (P2-C3,
+ * transcribed method-for-method from m_summary_display_modes.js over the engine's visible-tree
+ * cell store; the display modes and running totals run on the very same machinery). `parent()`
+ * of a top-level cell is the grand total on that axis; `parent()` of the grand total is null.
+ * `value()` reads the ORIGINAL aggregate, `value(true)` the post-processed one; a
+ * row/column/data field (object, or dataField/caption/name id) reads that field's value at the
+ * cell's path instead.
+ */
+interface NxePivotSummaryCell {
+    parent(direction: 'row' | 'column'): NxePivotSummaryCell | null;
+    children(direction: 'row' | 'column'): NxePivotSummaryCell[];
+    child(direction: 'row' | 'column', fieldValue: any): NxePivotSummaryCell | null;
+    grandTotal(direction?: 'row' | 'column'): NxePivotSummaryCell;
+    next(direction: 'row' | 'column', allowCrossGroup?: boolean): NxePivotSummaryCell | null;
+    prev(direction: 'row' | 'column', allowCrossGroup?: boolean): NxePivotSummaryCell | null;
+    field(area: 'row' | 'column' | 'data'): NxePivotField | null;
+    slice(field: NxePivotField | string | number, value: any): NxePivotSummaryCell | null;
+    value(fieldOrCalculated?: NxePivotField | string | number | boolean, isCalculatedValue?: boolean): any;
+    isPostProcessed(field?: NxePivotField | string | number): boolean;
+}
+/**
+ * The options object dx threads through a `calculateCustomSummary` callback (transcribed from
+ * DevExtreme 24.2.3 local_store/m_local_store `getAggregator`): ONE object per cell, mutated in
+ * place across the whole protocol — `{summaryProcess:'start', totalValue:undefined}` first, then
+ * per defined raw value `summaryProcess='calculate'` + `value`, then `summaryProcess='finalize'`
+ * with `value` DELETED; the cell renders whatever `totalValue` holds after 'finalize'.
+ */
+interface NxePivotCustomSummaryInfo {
+    summaryProcess: 'start' | 'calculate' | 'finalize';
+    /** The current record's raw value — present only during 'calculate' (deleted for 'finalize'). */
+    value?: any;
+    /** The accumulator/result — whatever the callback leaves here after 'finalize' is the cell. */
+    totalValue?: any;
+}
+/** A DevExtreme PivotGrid field descriptor (the subset the app passes). */
+interface NxePivotField {
+    caption?: string;
+    dataField?: string;
+    dataType?: 'string' | 'number' | 'date' | 'boolean';
+    /** Placement; a field with no `area` is defined-but-not-displayed (DevExtreme parity). */
+    area?: NxePivotArea;
+    areaIndex?: number;
+    summaryType?: NxePivotSummaryType;
+    /** dx custom-summary protocol — used when `summaryType === 'custom'` (see the info type). */
+    calculateCustomSummary?: (options: NxePivotCustomSummaryInfo) => void;
+    /** Number-mask string (`#,##0.00`), date format string, or `{ type }`. */
+    format?: NxeColumnFormat;
+    expanded?: boolean;
+    sortOrder?: 'asc' | 'desc';
+    /** dx: 'value' (default — raw values), 'displayText' (formatted/customizeText'd labels),
+     *  'none' (load order). The local-store default is 'value' (XmlaStore's is 'displayText'). */
+    sortBy?: 'value' | 'displayText' | 'none';
+    /** Column width in px, applied to the field's area column(s) — row-header column for a row
+     *  field, every leaf data column for a data field (dx m_data_controller cell width). */
+    width?: number;
+    /** dx: `false` removes a row/column field from its axis entirely and hides a data field's
+     *  columns (dx keeps hidden measures aggregating for sortBySummaryField etc. — the nxe
+     *  engine has no such reader, so it drops them from the model wholesale). */
+    visible?: boolean;
+    /** dx: read INSTEAD of `dataField` wherever the field's raw value is taken from a record
+     *  (dimension grouping and measure aggregation both) — m_local_store `prepareFields` only
+     *  builds a dataField selector when none is given (a selector also disables
+     *  `groupInterval` bucketing entirely, exactly as dx skips such fields). */
+    selector?: (data: any) => any;
+    customizeText?: (cellInfo: {
+        value: any;
+        valueText: string;
+    }) => string;
+    /** dx m_local_store `prepareFields` bucketing (P2-C3): on a `dataType: 'date'` field the
+     *  named interval replaces the raw value with `getFullYear()` / quarter 1-4 / month 1-12 /
+     *  day-of-month / `getDay()` 0-6; on a `dataType: 'number'` field a positive numeric step
+     *  groups to `Math.floor(value / step) * step` (labelled "start - end"). */
+    groupInterval?: NxePivotGroupInterval;
+    /** dx `summaryDisplayMode` (P2-C3): post-aggregation display expression over the visible
+     *  cross-tab. Percent modes default the field's format to dx's `'percent'` (precision 0)
+     *  when no explicit format exists. */
+    summaryDisplayMode?: NxePivotSummaryDisplayMode;
+    /** dx `calculateSummaryValue` (P2-C3): per-cell post-aggregation callback; wins over
+     *  `summaryDisplayMode`. Receives the dx-shaped {@link NxePivotSummaryCell}. */
+    calculateSummaryValue?: (e: NxePivotSummaryCell) => any;
+    /** dx `runningTotal` (P2-C3): accumulate along a 'row' (across columns) or a 'column'
+     *  (down rows), resetting at group boundaries unless `allowCrossGroupCalculation`. */
+    runningTotal?: 'row' | 'column';
+    /** dx `allowCrossGroupCalculation` (P2-C3): running totals / variation modes continue
+     *  across group boundaries instead of resetting. */
+    allowCrossGroupCalculation?: boolean;
+    /** dx `filterValues` (P2-C3): engine-side record filter, applied at intake before tree
+     *  building/aggregation — on row/column fields and on `area: 'filter'` fields alike. With
+     *  `groupInterval` set, values are compared against the GROUP value (dx filters through
+     *  the prepared selector). */
+    filterValues?: any[];
+    /** dx `filterType` (default 'include'): 'exclude' inverts the `filterValues` match. */
+    filterType?: 'include' | 'exclude';
+    [key: string]: any;
+}
+/**
+ * P3-C2 (field panel) — one field's panel-owned override, keyed by the field's index in the
+ * caller's `fields` array and merged over that field when the component constructs its engine.
+ * The caller's field objects are NEVER mutated (report-output-pivot serializes its own fields
+ * array in `onSave`); `area: null` marks a REMOVED field (P3-C3: the chooser's All-Fields
+ * tree drop or checkbox uncheck — dx's only removal paths; a drop outside every area snaps
+ * back and removes nothing) — the field leaves the layout but stays defined (dx: it remains
+ * available in the field chooser).
+ */
+interface NxePivotFieldOverride {
+    area?: NxePivotArea | null;
+    areaIndex?: number;
+    sortOrder?: 'asc' | 'desc';
+    expanded?: boolean;
+    /** P3-C4 (chip header filter): the applied allowed-value list; `null` = the user explicitly
+     *  cleared the filter (full-check → OK), so a declarative `filterValues` seed on the
+     *  caller's field can't resurrect — the same null rule the grid's hfOverride uses. */
+    filterValues?: any[] | null;
+    /** Written alongside `filterValues` on apply (always 'include' — see DEFAULTS.md P3-C4). */
+    filterType?: 'include' | 'exclude';
+}
+/** dx `dxPivotGrid.texts` — the subset the pivot renders (missing entries take the dx defaults). */
+interface NxePivotTexts {
+    grandTotal?: string;
+    /** Subtotal-row caption pattern (`{0}` = the closing value) — stored for future subtotal rows. */
+    total?: string;
+    noData?: string;
+}
+/** DevExtreme's default `texts`, applied wherever the host passes none. */
+declare const NXE_PIVOT_TEXTS_DEFAULTS: Required<NxePivotTexts>;
+/** The plain `[dataSource]` config object the app binds (also accepted: a `NxePivotDataSource`). */
+interface NxePivotDataSourceOptions {
+    /** Optional since P1-C3: with no/empty `fields` and `retrieveFields` not `false` (the dx
+     *  default), fields are derived from the store's first record — all area-less. */
+    fields?: NxePivotField[];
+    store?: any[];
+    retrieveFields?: boolean;
+    dataFieldArea?: 'row' | 'column';
+}
+/**
+ * A rendered column leaf = (column-path × data-field). Since P2-C2 the column axis is N-level:
+ * `kind` mirrors the row kinds — 'D' a value column (a collapsed parent's inline-aggregate
+ * column included), 'T' a "{value} Total" subtotal column closing an expanded parent, 'GT' the
+ * grand-total column (`colPath: []`).
+ */
+interface NxePivotColumnLeaf {
+    colPath: any[];
+    dataIndex: number;
+    /** 'D' value column, 'T' "{value} Total" column, 'GT' the grand-total column. */
+    kind: NxePivotRowKind;
+    /** Namespaced expand key of the leaf's column node (opaque, `'c:'`…); `''` when no column
+     *  node backs the leaf (grand total / no column fields). */
+    colKey: string;
+    /** Level of the column node the leaf renders under (= `colPath.length - 1`; -1 for 'GT'
+     *  and for the no-column-field leaves). */
+    level: number;
+    /** Derived alias — `kind === 'GT'` (kept for the pre-P2-C2 model contract). */
+    isGrandTotal: boolean;
+}
+/**
+ * One column-header cell spanning `colspan` leaf columns. All header rows are DERIVED from the
+ * leaf array by run-length encoding over consecutive leaves' `colPath` prefixes (P2-C2), so a
+ * span can never misalign with the leaves beneath it. The optional keys are present ONLY when
+ * meaningful (dx emits its attributes the same way): `rowspan` when > 1, `isTotal` on
+ * "{value} Total" cells, and the expand trio on chevron cells.
+ */
+interface NxePivotHeaderCell {
+    text: string;
+    colspan: number;
+    isGrandTotal: boolean;
+    /** Set when > 1: a 'T'/'GT'/collapsed-parent cell filling the remaining value rows (dx
+     *  `depthSize`, m_data_controller). */
+    rowspan?: number;
+    /** True on "{value} Total" cells (dx `dx-row-total dx-total`, on both axes). */
+    isTotal?: boolean;
+    /** True when the cell carries an expand/collapse chevron (dx `dx-expand-icon-container`). */
+    expandable?: boolean;
+    expanded?: boolean;
+    /** The column node's namespaced expand key — present exactly when `expandable`. */
+    pathKey?: string;
+}
+/** dx `rowHeaderLayout` — 'standard' renders one row-header column per row field; 'tree' one indented column. */
+type NxePivotRowHeaderLayout = 'standard' | 'tree';
+/** dx `showTotalsPrior` — where total rows/columns render relative to the data they close. */
+type NxePivotTotalsPrior = 'none' | 'rows' | 'columns' | 'both';
+/** Body-row kind: 'D' data row, 'T' "{value} Total" subtotal row, 'GT' the grand-total footer. */
+type NxePivotRowKind = 'D' | 'T' | 'GT';
+/**
+ * One row-header cell a body `<tr>` renders (standard layout). An EXPANDED parent's label cell
+ * attaches to its first child's row and `rowspan`s the subtree (dx semantics: the parent
+ * contributes no value row of its own); a collapsed parent / total label `colspan`s the
+ * remaining row-header columns.
+ */
+interface NxePivotRowHeaderCell {
+    text: string;
+    /** 0-based row-header column the cell starts in (= its node's level). */
+    col: number;
+    rowspan: number;
+    colspan: number;
+    /** True when the cell carries an expand/collapse chevron (a parent node's label). */
+    expandable: boolean;
+    expanded: boolean;
+    /** True for a "{value} Total" label cell (dx `dx-row-total dx-total`). */
+    isTotal: boolean;
+    pathKey: string;
+}
+/** A visible body row. `rows` carries kinds 'D'/'T' only — the grand total stays the footer. */
+interface NxePivotBodyRow {
+    kind: NxePivotRowKind;
+    label: string;
+    level: number;
+    path: any[];
+    pathKey: string;
+    hasChildren: boolean;
+    expanded: boolean;
+    /** Derived alias — `kind === 'GT'` (always false in `rows`; kept for facade parity). */
+    isGrandTotal: boolean;
+    /** Row-header cells this row renders (standard: 0..n cells; tree: exactly one). */
+    headerCells: NxePivotRowHeaderCell[];
+    /** `dataFieldArea: 'row'` with ≥2 measures (P2-C3): the measure this row renders — every
+     *  axis row splits into one row per data field, exactly as dx appends metric children to
+     *  each row header item (m_data_controller; with ONE measure the level is omitted, same
+     *  rule as columns). Absent on the default measures-on-columns model. */
+    dataIndex?: number;
+    /** The measure-caption cell text of a measures-on-rows row (tree layout renders it as the
+     *  second row-header column; standard layout also carries it inside `headerCells`). */
+    measureCaption?: string;
+    /** Measures-on-rows tree layout: the dimension label cell's rowspan on the FIRST measure
+     *  row of each axis row; `0` on continuation rows (no dimension cell at all). Absent on
+     *  the default model — the renderer treats absent as a plain single-row label. */
+    measureRowspan?: number;
+    /** Unique per rendered row (pathKey alone repeats once measure rows split); the template
+     *  tracks `trackKey ?? pathKey`. Absent on the default model. */
+    trackKey?: string;
+}
+/**
+ * The fully-computed cross-tab the grid renders and the Excel export walks. `cell()` resolves
+ * an aggregated value for a (rowPath × leaf) intersection; `text()` formats it for display.
+ */
+interface NxePivotModel {
+    rowFields: NxePivotField[];
+    columnFields: NxePivotField[];
+    dataFields: NxePivotField[];
+    cornerText: string;
+    /** Column-area header rows (excludes the top-left corner). Last row = data-field captions. */
+    columnHeaderRows: NxePivotHeaderCell[][];
+    leaves: NxePivotColumnLeaf[];
+    rows: NxePivotBodyRow[];
+    /** Resolved layout (`'tree'` when the caller passes none — the pre-parity model contract). */
+    rowHeaderLayout: NxePivotRowHeaderLayout;
+    /** Row-header `<th>` columns: standard → one per row field (min 1); tree → 1. */
+    rowHeaderColCount: number;
+    /** Resolved dx flags, round-tripped so callers/goldens can pin them. `showRowTotals`
+     *  renders only in standard layout (dx: "applies only if rowHeaderLayout is standard");
+     *  `showColumnTotals` renders "{value} Total" columns on the N-level column axis (P2-C2). */
+    showRowTotals: boolean;
+    showColumnTotals: boolean;
+    showTotalsPrior: NxePivotTotalsPrior;
+    showRowGrandTotals: boolean;
+    /** Grand-total footer cells (row grand total), one per leaf — present when enabled and
+     *  measures live on columns (the default). Null when `grandTotalRows` carries the footer. */
+    grandTotalCells: {
+        value: number | null;
+        text: string;
+    }[] | null;
+    /** Measures-on-rows footer (P2-C3): one footer row per data field, replacing
+     *  `grandTotalCells` when `dataFieldArea: 'row'` with ≥2 measures is active. */
+    grandTotalRows?: {
+        dataIndex: number;
+        caption: string;
+        cells: {
+            value: number | null;
+            text: string;
+        }[];
+    }[] | null;
+    /** Resolved `dataFieldArea` ('column' unless overridden — dx m_widget default). */
+    dataFieldArea?: 'row' | 'column';
+    /** Per-table-column px widths (`field.width`), aligned to `rowHeaderColCount` row-header
+     *  columns followed by `leaves` — `null` where no width is configured. */
+    colWidths: (number | null)[];
+    /** W4 Lane 4: per-leaf FORMATTED column labels, one entry per `colPath` level (`[]` for
+     *  the grand-total and no-column-field leaves) — `bindChart` series naming. */
+    colLabels: string[][];
+    /** Resolved display strings ({@link NXE_PIVOT_TEXTS_DEFAULTS} merged under any `texts` input). */
+    texts: Required<NxePivotTexts>;
+    /** Dense value matrix built once per `getModel()`: `matrix[r][l]` = `rows[r]` × `leaves[l]`
+     *  (subtotal rows/columns included; the grand-total ROW stays `grandTotalCells`).
+     *  Typed escape (W4 Lane 4): a `summaryType: 'custom'` cell renders whatever the callback
+     *  left in `totalValue` — a NON-NUMERIC value (dx allows it) rides through these slots at
+     *  runtime; `text()`/the export pass such values through as text. */
+    matrix: (number | null)[][];
+    /** `matrix` formatted per each leaf's data field — what the DOM and the export render. */
+    textMatrix: string[][];
+    cell(rowPath: any[], leaf: NxePivotColumnLeaf): number | null;
+    text(rowPath: any[], leaf: NxePivotColumnLeaf): string;
+    numFmt(dataIndex: number): string | undefined;
+}
+/**
+ * W4 Lane 2 — the dx `PivotGridCell` subset the outputs carry (transcribed from
+ * m_data_controller getCellsInfo / getViewHeaderItems, 24.2.3). A DATA cell carries the
+ * rowPath/columnPath/dataIndex/value/text/rowType/columnType block; a HEADER cell carries
+ * text/type/expanded (+ `path` where the cell owns an expand key — a narrowing recorded in
+ * DEFAULTS.md: dx paths every header cell, nxe paths the expandable ones).
+ */
+interface NxePivotCellData {
+    /** Cell text as rendered. */
+    text?: string;
+    /** Header cells: the cell's value path along its axis (see the interface note). */
+    path?: any[];
+    /** Header cells: 'D' value, 'T' "{value} Total", 'GT' grand total (dx `type`). */
+    type?: NxePivotRowKind;
+    /** Header cells: expand state (present on expandable cells, like dx's `expanded`). */
+    expanded?: boolean;
+    colspan?: number;
+    rowspan?: number;
+    /** Data cells: the aggregated value (post display-mode/running-total, as rendered). */
+    value?: any;
+    /** Data cells: the row's axis path (`[]` on the grand-total row). */
+    rowPath?: any[];
+    /** Data cells: the column leaf's axis path (`[]` on the grand-total column). */
+    columnPath?: any[];
+    /** Data cells: the row's kind — 'D' | 'T' | 'GT' (dx `rowType`). */
+    rowType?: NxePivotRowKind;
+    /** Data cells: the column leaf's kind (dx `columnType`). */
+    columnType?: NxePivotRowKind;
+    /** Data cells: index of the cell's data field among ALL data fields (dx `dataIndex`). */
+    dataIndex?: number;
+    dataType?: NxePivotField['dataType'];
+    format?: NxeColumnFormat;
+}
+/**
+ * dx `onCellClick` / `onCellPrepared` payload (m_widget `_createCellArgs`): the area, the
+ * DOM-ish indices, the cell element, the cell data, and the three field lists. `onCellClick`
+ * is CANCELABLE: setting `cancel: true` in a handler prevents the expand/collapse a chevron
+ * click would perform (dx gates its own toggle on `!args.cancel`).
+ */
+interface NxePivotCellEvent {
+    area: 'row' | 'column' | 'data';
+    /** DOM `tr.rowIndex` on clicks (dx `_createCellArgs`); model-local row on prepared. */
+    rowIndex: number;
+    /** DOM `cell.cellIndex` on clicks; model-local column on prepared. */
+    columnIndex: number;
+    cellElement?: HTMLElement | null;
+    cell: NxePivotCellData;
+    rowFields: NxePivotField[];
+    columnFields: NxePivotField[];
+    dataFields: NxePivotField[];
+    /** The originating DOM event (clicks only). */
+    event?: Event;
+    /** onCellClick only — set true to cancel the chevron's expand/collapse. */
+    cancel?: boolean;
+}
+/** dx `onOptionChanged` payload subset ({name, fullName, value, previousValue}). */
+interface NxePivotOptionChangedEvent {
+    name: string;
+    fullName: string;
+    value: any;
+    previousValue: any;
+    component?: NxePivotGridInstance;
+}
+/** dx `onContentReady` payload subset. */
+interface NxePivotContentReadyEvent {
+    component: NxePivotGridInstance;
+    element: HTMLElement;
+}
+/** dx `onExporting` payload (ExportController.exportTo, m_export.js): cancelable, and the
+ *  handler may rewrite `fileName` (dx default 'PivotGrid'). */
+interface NxePivotExportingEvent {
+    fileName: string;
+    cancel: boolean;
+    component?: NxePivotGridInstance;
+}
+/** The `.instance` facade the chart exposes (target of `bindChart`). */
+interface NxeChartInstance {
+    readonly _isNxeChart: true;
+    /** Push pivot-derived series data; `bindChart` calls this. */
+    render(series: NxeChartSeries): void;
+}
+/** Series payload handed to the chart by `bindChart`. */
+interface NxeChartSeries {
+    /** X-axis category labels (the pivot column leaves / row leaves). */
+    categories: string[];
+    /** One series per data field; `values` aligned to `categories`. */
+    series: {
+        name: string;
+        values: number[];
+    }[];
+}
+/**
+ * W4 Lane 4 — the dx `bindChart` integration options subset (m_chart_integration.js).
+ * The nxe chart renders ONE pane and ONE value axis, and its fixed orientation equals dx's
+ * `inverted: true` mapping (rows → categories/arguments, column leaves → series) — the
+ * established nxe contract since P1 (DEFAULTS.md). Consequences:
+ * - `dataFieldsDisplayMode` ('singleAxis' | 'splitAxes' | 'splitPanes', dx default
+ *   'splitAxes'): accepted; no structural effect on a single-pane single-axis chart.
+ * - `alternateDataFields` (dx default true): orders multi-measure series — column-major with
+ *   the measure inner (true) or measure-major (false), dx's data-item interleaving.
+ * - `putDataFieldsInto` ('series' default | 'args' | 'both'): with 2+ measures, where the
+ *   ` | {measure caption}` suffix lands — on the series names, on the category labels
+ *   (which then split per measure), or both (dx: sparse items; nxe fills mismatches with 0).
+ */
+interface NxePivotBindChartOptions {
+    dataFieldsDisplayMode?: 'singleAxis' | 'splitAxes' | 'splitPanes';
+    alternateDataFields?: boolean;
+    putDataFieldsInto?: 'series' | 'args' | 'both';
+    [key: string]: any;
+}
+/** The pivot-grid `.instance` facade (DevExtreme parity). */
+interface NxePivotGridInstance {
+    getDataSource(): {
+        reload(): void;
+    };
+    bindChart(chart: NxeChartInstance | any, options?: NxePivotBindChartOptions | any): void;
+    /** Export hook — the current computed cross-tab model (null until data loads). */
+    getExportModel(): NxePivotModel | null;
+    /** dx parity: RENDER-ONLY re-render/re-layout (dx Widget.repaint never touches the data
+     *  source) — re-runs the measurement pass; expand/layout state and aggregates are kept
+     *  (W4 Lane 1; the pre-W4 facade re-aggregated and wiped chevron state). */
+    repaint(): void;
+    /**
+     * Expand every node on BOTH axes (oracle §e: dx's toolbar expand-all sets `expanded` on
+     * every row+column field and reloads) and wipe the per-node chevron overrides. Optional
+     * ONLY because pre-P1-C3 spec literals implement this interface without it — the real
+     * component always provides both.
+     */
+    expandAll?(): void;
+    /** Collapse-all counterpart of {@link expandAll} (same override-wipe semantics). */
+    collapseAll?(): void;
+    /**
+     * W4 Lane 2 — dx `exportToExcel()` (the built-in export path, m_export.js `exportTo`):
+     * fires the cancelable `onExporting` (default fileName 'PivotGrid', the handler may
+     * rename), then drives the standard `exportPivotGrid({component})` pipeline into an
+     * in-house workbook and saves `<fileName>.xlsx`. Optional for the same reason as
+     * {@link expandAll} (pre-existing spec literals implement this interface).
+     */
+    exportToExcel?(): Promise<void>;
+    /**
+     * W4 Lane 2 — dx `option(name[, value])` for the DOCUMENTED pivot options that map to
+     * component inputs (allowExpandAll, allowFiltering, allowSorting, allowSortingBySummary,
+     * dataFieldArea, height, rowHeaderLayout, showBorders, showColumnGrandTotals,
+     * showColumnTotals, showRowGrandTotals, showRowTotals, showTotalsPrior, texts,
+     * wordWrapEnabled). One-arg = get (also supports 'dataSource', get-only); two-arg = set,
+     * recorded as an override that WINS over the input binding and fires `onOptionChanged`.
+     * Unsupported names (dataSource set, nested 'a.b' paths, fieldChooser/fieldPanel/
+     * stateStoring/scrolling — those live on projected config children) are ignored on set
+     * and return undefined on get (DEFAULTS.md).
+     */
+    option?(name: string, value?: any): any;
+    /** W4 Lane 2 — dx `updateDimensions()`: re-runs the render/measurement pass (the band
+     *  anchor / dimension sync), exactly like `repaint()` minus dx's full re-render. */
+    updateDimensions?(): void;
+    /** W4 Lane 2 — dx `getFieldChooserPopup()` narrowed to the two members anyone calls:
+     *  `show()` opens the chooser overlay (a no-op re-show when already open, dx-true),
+     *  `hide()` disposes it. */
+    getFieldChooserPopup?(): {
+        show(): void;
+        hide(): void;
+    };
+}
+
+/** Options for {@link exportPivotGrid} — mirrors DevExtreme's `exportPivotGrid({component, worksheet})`. */
+interface NxeExportPivotGridOptions {
+    component: NxePivotGridInstance;
+    /** exceljs `Worksheet` or the in-house one (structural cousins, loosely typed). */
+    worksheet: any;
+    /** 1-based {row, column} the cross-tab starts at (default top-left of the sheet). */
+    topLeftCell?: {
+        row: number;
+        column: number;
+    };
+}
+/**
+ * Replacement for DevExtreme's `exportPivotGrid({component, worksheet})` (from
+ * `devextreme/excel_exporter`). Walks the pivot's computed cross-tab model — stacked column
+ * headers (colspan AND rowspan merges — N-level column hierarchies, subtotal/grand-total
+ * columns, P2-C2), the row headers (standard layout: one column per row field with
+ * rowspan/colspan merges + "{value} Total" rows; tree layout: one indented column), the data
+ * cells, and the grand-total footer — into the supplied exceljs worksheet, then resolves. The
+ * caller keeps the surrounding `formatExcel(workbook)` + `writeBuffer()` + `saveAs()` pipeline
+ * unchanged (drop-in import swap).
+ */
+declare function exportPivotGrid(opts: NxeExportPivotGridOptions): Promise<void>;
+/** Injectable wrapper for {@link exportNxeGridToExcel} / {@link exportPivotGrid}. */
+declare class NxeExcelExportService {
+    exportDataGrid(grid: NxeGridInstance, opts: NxeExcelExportOptions): Promise<void>;
+    exportPivotGrid(opts: NxeExportPivotGridOptions): Promise<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeExcelExportService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<NxeExcelExportService>;
+}
+
+interface NxePivotModelOptions {
+    /** Field-level expansion is seeded from `field.expanded`; these are per-node chevron overrides. */
+    expandedOverrides: ReadonlyMap<string, boolean>;
+    /**
+     * Facade expand-all/collapse-all state: `true`/`false` behaves as if EVERY row+column
+     * field's `expanded` were set to it (oracle §e — dx's toolbar buttons set `expanded` on all
+     * fields of both axes and reload); `undefined` follows the fields. Per-node
+     * `expandedOverrides` still win on top (the caller wipes them when toggling this).
+     */
+    allExpanded?: boolean;
+    showRowGrandTotals: boolean;
+    showColumnGrandTotals: boolean;
+    /**
+     * dx `rowHeaderLayout`. Defaults to 'tree' — the pre-parity model contract (callers that
+     * predate the flag keep their flat parent-inline rows); the component always passes its
+     * own input, whose default is dx's 'standard'.
+     */
+    rowHeaderLayout?: NxePivotRowHeaderLayout;
+    /** dx `showRowTotals` (default true). Renders only in standard layout, exactly as dx:
+     *  "applies only if rowHeaderLayout is 'standard'" — tree layout ignores it. */
+    showRowTotals?: boolean;
+    /** dx `showColumnTotals` (default true): "{value} Total" columns close expanded column
+     *  parents (active since P2-C2 — the column axis renders all N levels). */
+    showColumnTotals?: boolean;
+    /** dx `showTotalsPrior` (default 'none'); 'rows'/'both' place each "{value} Total" row
+     *  BEFORE its children, 'columns'/'both' each "{value} Total" column BEFORE its children. */
+    showTotalsPrior?: NxePivotTotalsPrior;
+    /** Display strings (dx `texts`); merged over {@link NXE_PIVOT_TEXTS_DEFAULTS}. */
+    texts?: NxePivotTexts;
+    /** dx widget `dataFieldArea` (default 'column'); 'row' moves the measures onto the row
+     *  axis as its innermost level when ≥2 exist (P2-C3). Falls back to the data-source
+     *  options' own `dataFieldArea` when unset here. */
+    dataFieldArea?: 'row' | 'column';
+}
+declare class NxePivotDataSource {
+    private readonly options;
+    private readonly agg;
+    /**
+     * Records that survived `filterValues` and reached the axis trees — the analogue of dx's
+     * loaded row matrix (`data.values`), which `isEmpty()` tests. Deliberately NOT `agg.size`:
+     * a record whose measure is null/non-numeric builds axis nodes but no aggregate.
+     */
+    private loadedCount;
+    private rowTree;
+    /** Column-axis roots (display order) — all N levels render since P2-C2. */
+    private colTree;
+    /** The column axis tree (node lookup by pathKey for the header run-length derivation). */
+    private colAxis;
+    /** The row axis tree (W4 Lane 2: expand-key → value-path lookups for event payloads). */
+    private rowAxis;
+    /** Store-derived fields when no explicit fields were given (dx `retrieveFields` default). */
+    private readonly derivedFields;
+    /** The normalized clones (caption defaulted, area lower-cased), aligned 1:1 with
+     *  `fields()` — the field panel reads chips/sort state here (P3-C2). */
+    private readonly normalizedFields;
+    readonly rowFields: NxePivotField[];
+    readonly columnFields: NxePivotField[];
+    /** ALL data-area fields incl. `visible: false` ones (dx `descriptions.values`) — hidden
+     *  measures aggregate and stay addressable by their dataIndex; only rendering skips them. */
+    readonly dataFields: NxePivotField[];
+    /** The data fields that actually RENDER (leaves, captions, footers, export, chart). */
+    private readonly visibleDataFields;
+    /** `area: 'filter'` fields — they exist solely to carry `filterValues` (P2-C3). */
+    readonly filterFields: NxePivotField[];
+    constructor(options: NxePivotDataSourceOptions);
+    /** DevExtreme parity: `getDataSource().reload()` re-aggregates the (possibly mutated) store. */
+    reload(): void;
+    fields(): NxePivotField[];
+    /**
+     * P3-C2 (field panel): one panel area's chips — the area's VISIBLE fields in `areaIndex`
+     * order, each carrying its index in the `fields()` array (the panel's override key) and its
+     * normalized clone (caption defaulted, area lower-cased). `visible: false` fields never
+     * chip, matching dx's panel/chooser (m_field_chooser_base `getAreaFields` filters
+     * `visible !== false` for EVERY area — data/filter included, unlike the aggregation arrays,
+     * which keep hidden data/filter fields working).
+     *
+     * P3-C4: `includeHidden` mirrors dx m_data_source's module-local `getAreaFields`
+     * (`canAddFieldInArea = area === 'data' || field.visible !== false`) — the areaIndex
+     * RENUMBERING after a drop runs over the DATA area's hidden fields too (dx
+     * `_createDescriptions` → `normalizeIndexes(getAreaFields(fields, areaName), 'areaIndex')`),
+     * while hidden row/column/filter fields stay outside the numbering, dx-true.
+     */
+    areaFields(area: NxePivotArea, includeHidden?: boolean): {
+        fieldIndex: number;
+        field: NxePivotField;
+    }[];
+    /**
+     * P3-C4 (chip header filter) — dx `getFieldValues(index)` (m_data_source.js:524) scoped to
+     * the local store: the field's DISTINCT PREPARED values (the `groupInterval` group value
+     * where one is set — dx loads the field as a lone expanded column through prepareFields)
+     * with their display labels (`fieldText`: interval labels, date formats, customizeText),
+     * sorted ascending by raw value. Built from the UNFILTERED store: dx passes `filters: []`
+     * unless `headerFilter.showRelevantValues` is on (default false — the nxe panel always
+     * shows the full list, exactly like the grid's non-cascading lists), and the field's own
+     * `filterValues` are always ignored (`filterValues: null` on the load field). Dedupe is
+     * by `valueOf()` (dates by instant), the dx grouping key.
+     */
+    getFieldValues(index: number): {
+        value: any;
+        text: string;
+    }[];
+    /** The normalized clone of `fields()[index]` (P3-C2 — chip captions/sort state read here). */
+    fieldAt(index: number): NxePivotField | undefined;
+    /**
+     * P3-C2 (field panel): a NEW data source over the SAME store/options with `fields`
+     * replacing the field list — how the component applies its fieldOverride merge without
+     * ever touching the caller's options (report-output-pivot serializes its own fields
+     * array in `onSave`).
+     */
+    cloneWithFields(fields: NxePivotField[]): NxePivotDataSource;
+    /**
+     * dx m_local_store `areValuesEqual`, verbatim: `valueOf()` comparison (dates by time), and
+     * an ARRAY filter value compares element-wise (dx's `levels` shape — kept for parity even
+     * though nxe has no grouped hierarchy fields).
+     */
+    private static areValuesEqual;
+    /**
+     * dx m_local_store `createDimensionFilters` + `createFilter` (P2-C3): one predicate per
+     * row/column/filter-area field with a non-empty `filterValues`, comparing the PREPARED
+     * value (the group value when `groupInterval` is set) against each filter value;
+     * `filterType: 'exclude'` inverts. Returns null when nothing filters — the fast path.
+     */
+    private buildRecordFilter;
+    private build;
+    /**
+     * W4 Lane 2: resolve a namespaced expand key (`'r:'`/`'c:'` + encoded value path) back to
+     * its node's raw value path — the `path` a dx header-cell event payload carries. Returns
+     * null for an unknown/empty key (e.g. the grand-total pseudo cells, which have no node).
+     */
+    nodePath(pathKey: string): any[] | null;
+    /**
+     * W4 Lane 3 — dx `isEmpty()` (m_data_source.js): `!dataFields.length || !data.values.length`.
+     * dx's `data.values` is the LOADED row matrix, which exists for every record regardless of
+     * whether its measure aggregated to a number, so this counts loaded records rather than
+     * aggregates: a store whose only measure is text (or null throughout) still renders its full
+     * cross-tab with blank cells in dx — testing `agg.size` instead stamped "No data" over it.
+     */
+    isEmpty(): boolean;
+    /**
+     * dx custom-summary protocol (m_local_store `getAggregator`), run per aggregated cell: ONE
+     * options object per cell is passed through 'start', then 'calculate' once per defined raw
+     * value (`options.value` set), then 'finalize' (`options.value` deleted); the cell's result
+     * is whatever the callback left in `totalValue`. dx interleaves the 'calculate' calls of
+     * different cells while streaming records; nxe runs each cell's protocol contiguously after
+     * the load — the per-cell sequence (dx's documented contract) is identical.
+     */
+    private runCustomSummaries;
+    /**
+     * Sort one axis level in place, honouring `sortOrder` + `sortBy` (dx m_data_source_utils
+     * `getMemberForSortBy`): default/'value' compares the raw values, 'displayText' compares the
+     * formatted labels (format + customizeText already applied), 'none' keeps load order
+     * (reversed for desc — dx compares the load index).
+     */
+    private sortLevel;
+    private compareValues;
+    private sortTree;
+    /** Raw aggregate at (rowPath × colPath × data field) — the pre-display-mode value. */
+    private valueAt;
+    cell(rowPath: any[], leaf: NxePivotColumnLeaf): number | null;
+    text(rowPath: any[], leaf: NxePivotColumnLeaf): string;
+    numFmt(dataIndex: number): string | undefined;
+    /** Build the renderable/exportable cross-tab model for the given expand state + totals flags. */
+    getModel(opts: NxePivotModelOptions): NxePivotModel;
+    /**
+     * Recursive column-leaf emission over the N-level column tree — the ONE place the visible
+     * column order is decided; header rows are derived from its output. dx semantics (oracle §a
+     * mirrored to columns + `oracle/hierarchy-*-matrix.json`; dx m_data_controller
+     * `getViewHeaderItems`): an EXPANDED parent contributes no value column of its own — its
+     * children render, and (with `showColumnTotals`) a "{value} Total" column carrying the
+     * parent's aggregates closes the group AFTER the children (dx splices the 'T' item as a
+     * sibling at `index + 1`; `showTotalsPrior` 'columns'/'both' splices at `index`, i.e.
+     * BEFORE). A COLLAPSED parent is a single 'D' column with inline aggregates. The grand
+     * total stays LAST regardless of totalsPrior — the established nxe deviation (DEFAULTS.md:
+     * dx would move it first, as it moves the grand-total row on the row axis).
+     */
+    private buildLeaves;
+    /**
+     * The header cell above leaf-run position `r` exists iff this returns non-null; leaves with
+     * EQUAL ids at row `r` merge into one run-length cell. A 'D' prefix id merges an expanded
+     * parent's label over its whole visible subtree (children's 'T' columns included — capture:
+     * colSpan 21 spans nested totals); the parent's OWN 'T' leaf and the 'GT' leaves carry
+     * distinct ids so they never fold into a value cell.
+     */
+    private headerIdAt;
+    /** Materialize the run-length cell for `span` consecutive leaves starting at `leaf`, row `r`. */
+    private headerCellAt;
+    /**
+     * Header rows DERIVED from the leaf array by run-length encoding — never a second
+     * independent walk of the column tree, so span/leaf misalignment is structurally
+     * impossible. Value rows = the deepest visible level (dx `depthSize`); the measure-caption
+     * row is appended LAST and ONLY when two or more data fields exist (oracle §b: with exactly
+     * one measure dx drops the caption row entirely — `oracle/single-measure-matrix.json`).
+     */
+    private buildColumnHeaders;
+    /**
+     * `dataFieldArea: 'row'` with ≥2 measures (P2-C3): split every body row into one row per
+     * data field — dx appends metric children (caption / `dataIndex` / `isMetric`, type
+     * inherited) to EVERY row header item, D, T and GT alike (m_data_controller
+     * getViewHeaderItems). The dimension label cells attach to the FIRST measure row with
+     * their rowspans multiplied (each underlying axis row now spans M rendered rows); every
+     * measure row appends the caption cell as the innermost row-header column.
+     */
+    private splitRowsByMeasures;
+    /**
+     * P2-C3: run the dx post-aggregation passes (`summaryDisplayMode` / `calculateSummaryValue`
+     * via applyDisplaySummaryMode, then `runningTotal` via applyRunningTotal — the
+     * m_data_source._update ordering) over the VISIBLE axis trees of this model build. dx
+     * computes these on its loaded data, which only contains children for expanded paths — the
+     * visible tree IS dx's loaded tree, so prev/next/children navigation and group-boundary
+     * resets see exactly what dx sees. Returns null (the untouched fast path) when no data
+     * field opts in or nothing aggregated.
+     */
+    private buildPostProcessed;
+    /** Visible-tree projection of one axis (collapsed nodes stay leaves), dx loaded-data shape. */
+    private buildSummaryNodes;
+    /** Tree layout (and the pre-parity default): one indented column, parents inline with aggregates. */
+    private flattenTreeRows;
+    /**
+     * Standard layout (dx default): N row-header columns. An EXPANDED parent contributes no
+     * value row — its label cell rowspans its children's rows, its own tr carries the first
+     * child's values, and (with `showRowTotals`) a full-width "{value} Total" row closes the
+     * group AFTER the children (`totalsPrior` moves it before). A COLLAPSED parent is one row:
+     * label colspans the remaining header columns, aggregates inline.
+     */
+    private flattenStandardRows;
+    private isExpanded;
+}
+
+/**
+ * `nxe-state-storing` — accepts DevExtreme `dxo-state-storing` config (orbit addition).
+ *
+ * LIVE since P3-C4 for `type: 'custom'`: `NxePivotGridComponent` contentChild's this and (a)
+ * fires `customSave(state)` after every layout mutation — panel/chooser chip drag, sort
+ * toggle, header-filter apply, chooser check/uncheck, facade expandAll/collapseAll — with a
+ * dx-shaped state whose `fields` are the serialized effectiveFields (the POST-drag layout,
+ * FULL field copies — see buildStorageState), and (b) honors `customLoad` once
+ * on init (value or Promise, per dx's `fromPromise` contract). The `localStorage`/
+ * `sessionStorage` types and `storageKey` remain accepted-but-inert (DEFAULTS.md, dated
+ * P3-C4 rows — including the missing dx `savingTimeout` debounce).
+ */
+declare class NxeStateStoringComponent {
+    readonly enabled: _angular_core.InputSignal<boolean>;
+    readonly type: _angular_core.InputSignal<"custom" | "localStorage" | "sessionStorage">;
+    readonly storageKey: _angular_core.InputSignal<string>;
+    readonly customSave: _angular_core.InputSignal<(state: any) => void>;
+    readonly customLoad: _angular_core.InputSignal<() => any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeStateStoringComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeStateStoringComponent, "nxe-state-storing", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "storageKey": { "alias": "storageKey"; "required": false; "isSignal": true; }; "customSave": { "alias": "customSave"; "required": false; "isSignal": true; }; "customLoad": { "alias": "customLoad"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * `nxe-field-panel` — DevExtreme `dxo-field-panel` config (orbit addition), LIVE since P3-C2:
+ * `NxePivotGridComponent` contentChild's it and renders `nxe-pivot-field-panel` above the
+ * cross-tab when `visible` is true.
+ *
+ * Defaults are dx's `fieldPanel` defaults (dxPivotGrid docs, verified 2026-09-02): `visible`
+ * FALSE — nothing renders unless the host opts in (the calc tabs project no `nxe-field-panel`
+ * at all) — and the five feature flags TRUE. report-output-pivot binds all six from its saved
+ * `panelConfig`; an `undefined` bound into a flag is treated as "not false" (= the dx default)
+ * by the pivot's template, so a not-yet-loaded config never blanks an area.
+ */
+declare class NxeFieldPanelComponent {
+    readonly visible: _angular_core.InputSignal<boolean>;
+    readonly showDataFields: _angular_core.InputSignal<boolean>;
+    readonly showRowFields: _angular_core.InputSignal<boolean>;
+    readonly showColumnFields: _angular_core.InputSignal<boolean>;
+    readonly showFilterFields: _angular_core.InputSignal<boolean>;
+    readonly allowFieldDragging: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeFieldPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeFieldPanelComponent, "nxe-field-panel", never, { "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "showDataFields": { "alias": "showDataFields"; "required": false; "isSignal": true; }; "showRowFields": { "alias": "showRowFields"; "required": false; "isSignal": true; }; "showColumnFields": { "alias": "showColumnFields"; "required": false; "isSignal": true; }; "showFilterFields": { "alias": "showFilterFields"; "required": false; "isSignal": true; }; "allowFieldDragging": { "alias": "allowFieldDragging"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** One rendered chip. `sortOrder` is the EFFECTIVE order (dx: fields sort asc by default). */
+interface NxePivotPanelChip {
+    fieldIndex: number;
+    caption: string;
+    sortOrder: 'asc' | 'desc';
+    sortable: boolean;
+    /** P3-C4: the chip renders the `.dx-header-filter` funnel (never on data-area chips). */
+    filterable: boolean;
+    /** A filter is applied (`filterValues` non-empty) — full-alpha funnel, no `-empty` class. */
+    filterActive: boolean;
+}
+/** A funnel click — the pivot opens the shared header-filter panel anchored to the chip. */
+interface NxePivotFilterOpenEvent {
+    fieldIndex: number;
+    /** The chip element (dx anchors the popup to `e.currentTarget`, the chip itself). */
+    origin: HTMLElement;
+}
+/**
+ * One chip's model, shared by the panel and the chooser (P3-C4). Per-field flag precedence is
+ * dx m_widget `_updateCalculatedOptions`: the widget-level allowSorting/allowFiltering value
+ * stamps a field only while the field's own value is undefined — an explicit `false` opts the
+ * field out under a permissive widget, an explicit `true` opts it in under a restrictive one.
+ * The DATA area never sorts by click (that is allowSortingBySummary's context-menu territory)
+ * and never funnels (dx renderField skips both states for `field.area === 'data'`,
+ * m_field_chooser_base). `filterActive` mirrors dx `_isHeaderFilterEmpty` inverted.
+ */
+declare function buildChip(fieldIndex: number, field: NxePivotField, group: NxePivotArea, widgetAllowSorting: boolean, widgetAllowFiltering: boolean): NxePivotPanelChip;
+interface PanelArea {
+    group: NxePivotArea;
+    chips: NxePivotPanelChip[];
+    emptyText: string;
+}
+/**
+ * A chip drop or chooser toggle. `area: null` = REMOVE the field from the layout — emitted
+ * only by the chooser (a drop on its All-Fields tree, or a checkbox uncheck). dx m_sortable
+ * fires no change at all for a release outside every group's fields box (the chip snaps
+ * back), so the PANEL never emits null: an off-panel release is a no-op — corrected in P3-C3
+ * (the P3-C2 cut mis-transcribed outside-drop as removal).
+ */
+interface NxePivotFieldMoveEvent {
+    fieldIndex: number;
+    area: NxePivotArea | null;
+    areaIndex: number;
+}
+declare class NxePivotFieldPanelComponent implements OnDestroy {
+    /** The pivot's CURRENT engine — overrides already merged, so chips track every mutation. */
+    readonly engine: _angular_core.InputSignal<NxePivotDataSource>;
+    readonly showFilterFields: _angular_core.InputSignal<boolean>;
+    readonly showDataFields: _angular_core.InputSignal<boolean>;
+    readonly showColumnFields: _angular_core.InputSignal<boolean>;
+    readonly showRowFields: _angular_core.InputSignal<boolean>;
+    readonly allowFieldDragging: _angular_core.InputSignal<boolean>;
+    /** dx widget `allowSorting` (default false): chip click toggles the field's sortOrder.
+     *  A field's own `allowSorting` overrides it (dx m_widget `_updateCalculatedOptions`
+     *  stamps the widget flag onto a field only while the field's own value is undefined). */
+    readonly allowSorting: _angular_core.InputSignal<boolean>;
+    /** dx widget `allowFiltering` (default false, P3-C4): dimension chips render the
+     *  header-filter funnel. Same per-field precedence as `allowSorting`. */
+    readonly allowFiltering: _angular_core.InputSignal<boolean>;
+    /** Widget `showBorders`: the panel bands sit INSIDE the border box (dx draws the outer
+     *  border around the filter/chip bands — `.dx-pivotgrid-border .dx-filter-header` et al). */
+    readonly showBorders: _angular_core.InputSignal<boolean>;
+    /** P3-C3: the pivot's `.dx-pivotgrid-toolbar` template (field-chooser button) — rendered
+     *  where dx prepends its toolbar container (m_widget.js `_renderDescriptionArea`). */
+    readonly toolbarTemplate: _angular_core.InputSignal<TemplateRef<unknown>>;
+    /** Which panel band hosts the toolbar (the pivot resolves dx's placement branches):
+     *  'filter' = the filter-header cell; 'column' = the column-header cell (dx's middle
+     *  branch — showFilterFields off but data/column bands shown; the cell renders for the
+     *  toolbar even when showColumnFields is off, exactly as dx's always-present
+     *  $columnHeader does); null = the toolbar lives in the cross-tab corner (or no
+     *  chooser) — nothing renders here. */
+    readonly toolbarArea: _angular_core.InputSignal<"column" | "filter">;
+    /** A chip was dropped — the pivot recomputes areaIndexes and writes its override map. */
+    readonly fieldMove: _angular_core.OutputEmitterRef<NxePivotFieldMoveEvent>;
+    /** A sortable chip was clicked — the pivot flips the field's effective sortOrder. */
+    readonly sortToggle: _angular_core.OutputEmitterRef<{
+        fieldIndex: number;
+    }>;
+    /** A chip's funnel was clicked — the pivot opens the header-filter panel (P3-C4). */
+    readonly filterOpen: _angular_core.OutputEmitterRef<NxePivotFilterOpenEvent>;
+    /** The ROW fields area — NxePivotGridComponent outlets this into its corner cell (dx hosts
+     *  the row chips inside `.dx-area-description-cell`, never in a band of their own). */
+    readonly rowAreaTemplate: _angular_core.Signal<TemplateRef<unknown>>;
+    private readonly elementRef;
+    private readonly zone;
+    protected readonly filterArea: _angular_core.Signal<PanelArea>;
+    protected readonly dataArea: _angular_core.Signal<PanelArea>;
+    protected readonly columnArea: _angular_core.Signal<PanelArea>;
+    protected readonly rowArea: _angular_core.Signal<PanelArea>;
+    /** The toolbar renders in the column-header cell (dx's middle placement branch). */
+    protected readonly columnToolbar: _angular_core.Signal<boolean>;
+    private drag;
+    private readonly gesture;
+    ngOnDestroy(): void;
+    protected onChipPointerDown(chip: NxePivotPanelChip, area: NxePivotArea, event: PointerEvent): void;
+    protected onChipClick(chip: NxePivotPanelChip): void;
+    protected onChipFilterClick(chip: NxePivotPanelChip, event: MouseEvent): void;
+    private buildArea;
+    /** Hit-test root: the whole pivot — the row area lives in the cross-tab corner cell. */
+    private dragRoot;
+    /**
+     * Drop zones. For filter/data/column the fields-area element is both hit rect and highlight
+     * target; for ROW the enclosing corner cell (`th.dx-area-description-cell`) is — dx's row
+     * area IS the corner, so a drop anywhere on it must land in rows, not read as "outside".
+     */
+    private dropZones;
+    private trackPointer;
+    /** dx `.dx-position-indicator`: a 2px gray bar between chips, inside the (positioned) area. */
+    private placeIndicator;
+    private completeDrop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxePivotFieldPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePivotFieldPanelComponent, "nxe-pivot-field-panel", never, { "engine": { "alias": "engine"; "required": false; "isSignal": true; }; "showFilterFields": { "alias": "showFilterFields"; "required": false; "isSignal": true; }; "showDataFields": { "alias": "showDataFields"; "required": false; "isSignal": true; }; "showColumnFields": { "alias": "showColumnFields"; "required": false; "isSignal": true; }; "showRowFields": { "alias": "showRowFields"; "required": false; "isSignal": true; }; "allowFieldDragging": { "alias": "allowFieldDragging"; "required": false; "isSignal": true; }; "allowSorting": { "alias": "allowSorting"; "required": false; "isSignal": true; }; "allowFiltering": { "alias": "allowFiltering"; "required": false; "isSignal": true; }; "showBorders": { "alias": "showBorders"; "required": false; "isSignal": true; }; "toolbarTemplate": { "alias": "toolbarTemplate"; "required": false; "isSignal": true; }; "toolbarArea": { "alias": "toolbarArea"; "required": false; "isSignal": true; }; }, { "fieldMove": "fieldMove"; "sortToggle": "sortToggle"; "filterOpen": "filterOpen"; }, never, never, true, never>;
+}
+
+/** `dxo-field-chooser` — LIVE since P3-C3: with `enabled` the pivot renders the
+ *  `.dx-pivotgrid-field-chooser-button` toolbar button and opens the chooser popup
+ *  (nxe-pivot-field-chooser) in a CDK overlay. Defaults are dxPivotGrid's `fieldChooser`
+ *  defaults (m_widget.js): enabled true, width/height 600, allowSearch false,
+ *  applyChangesMode 'instantly' (no OK/Cancel — changes hit the pivot live). */
+declare class NxeFieldChooserComponent {
+    readonly enabled: _angular_core.InputSignal<boolean>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly width: _angular_core.InputSignal<number>;
+    readonly allowSearch: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeFieldChooserComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeFieldChooserComponent, "nxe-field-chooser", never, { "enabled": { "alias": "enabled"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "allowSearch": { "alias": "allowSearch"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class NxePivotGridComponent implements OnDestroy {
+    readonly dataSource: _angular_core.InputSignal<NxePivotDataSourceOptions | NxePivotDataSource>;
+    /** dx `allowFiltering` (default false) — LIVE since P3-C4: filterable dimension chips
+     *  (panel AND chooser) render the `.dx-header-filter` funnel and open the shared
+     *  header-filter panel; per-field `field.allowFiltering` overrides the widget flag
+     *  (dx m_widget `_updateCalculatedOptions`). */
+    readonly allowFiltering: _angular_core.InputSignal<boolean>;
+    /** dx `allowSortingBySummary`: accepted + round-tripped, INERT — dx exposes it only
+     *  through the data-cell/total context menu ("Sort by This Column"), Phase 4 territory
+     *  (DEFAULTS.md, dated P3-C4 note). */
+    readonly allowSortingBySummary: _angular_core.InputSignal<boolean>;
+    /** dx: gates the context-menu "Expand All"/"Collapse All" items (default false). Accepted +
+     *  round-tripped; no context menu exists until Phase 4 (DEFAULTS.md). The facade's
+     *  `expandAll()`/`collapseAll()` work regardless, exactly as dx's data-source methods do. */
+    readonly allowExpandAll: _angular_core.InputSignal<boolean>;
+    readonly showBorders: _angular_core.InputSignal<boolean>;
+    /** dx default TRUE (m_widget.js defaultOptions): `dx-word-wrap` on the table lets header
+     *  cells wrap; data cells stay nowrap either way (dx.light's direct td rule). */
+    readonly wordWrapEnabled: _angular_core.InputSignal<boolean>;
+    readonly rowHeaderLayout: _angular_core.InputSignal<NxePivotRowHeaderLayout>;
+    /** dx `height`: number (px) or CSS string, applied to the widget root — the internal
+     *  scroll container tracks it at 100%. */
+    readonly height: _angular_core.InputSignal<string | number>;
+    readonly texts: _angular_core.InputSignal<NxePivotTexts>;
+    readonly showColumnTotals: _angular_core.InputSignal<boolean>;
+    readonly showRowTotals: _angular_core.InputSignal<boolean>;
+    readonly showColumnGrandTotals: _angular_core.InputSignal<boolean>;
+    readonly showRowGrandTotals: _angular_core.InputSignal<boolean>;
+    /** dx `showTotalsPrior` — 'rows'/'both' place each "{value} Total" row before its children. */
+    readonly showTotalsPrior: _angular_core.InputSignal<NxePivotTotalsPrior>;
+    /** dx `dataFieldArea` (default 'column'): 'row' renders the measures as the innermost ROW
+     *  level when two or more exist (with one, dx omits the metric level on either axis).
+     *  Left undefined the engine falls back to the dataSource options' own `dataFieldArea`. */
+    readonly dataFieldArea: _angular_core.InputSignal<"row" | "column">;
+    /** dx `allowSorting` (default false, P3-C2): field-panel chips toggle their field's
+     *  sortOrder on click and carry the `.dx-sort` arrow in `.dx-column-indicators`. */
+    readonly allowSorting: _angular_core.InputSignal<boolean>;
+    /**
+     * Facade `option(name, value)` writes land here and WIN over the input bindings — the dx
+     * `instance.option(...)` idiom on a component whose declarative config are signal inputs.
+     * Every live read site goes through the `*Eff` computeds below, so a set is immediately
+     * effective; the input keeps feeding the value while no override exists.
+     */
+    private readonly optionOverrides;
+    private effOf;
+    protected readonly allowFilteringEff: Signal<boolean>;
+    protected readonly allowSortingEff: Signal<boolean>;
+    protected readonly allowSortingBySummaryEff: Signal<boolean>;
+    protected readonly allowExpandAllEff: Signal<boolean>;
+    protected readonly showBordersEff: Signal<boolean>;
+    protected readonly wordWrapEnabledEff: Signal<boolean>;
+    protected readonly rowHeaderLayoutEff: Signal<NxePivotRowHeaderLayout>;
+    protected readonly heightEff: Signal<string | number>;
+    protected readonly textsEff: Signal<NxePivotTexts>;
+    protected readonly showColumnTotalsEff: Signal<boolean>;
+    protected readonly showRowTotalsEff: Signal<boolean>;
+    protected readonly showColumnGrandTotalsEff: Signal<boolean>;
+    protected readonly showRowGrandTotalsEff: Signal<boolean>;
+    protected readonly showTotalsPriorEff: Signal<NxePivotTotalsPrior>;
+    protected readonly dataFieldAreaEff: Signal<"row" | "column">;
+    /** The documented option names `option()` gets/sets (DEFAULTS.md lists the exclusions). */
+    private readonly effOptions;
+    /**
+     * dx-shaped outputs (W4 Lane 2) — no consumer binds them today; parity insurance.
+     * Classic EventEmitters, NOT `output()`: `.observed` gates the per-cell walks so a pivot
+     * with no listeners pays nothing (dx does the same — m_area_item only walks its cells
+     * when `onCellPrepared || hasEvent`).
+     */
+    readonly onCellClick: EventEmitter<NxePivotCellEvent>;
+    readonly onCellPrepared: EventEmitter<NxePivotCellEvent>;
+    readonly onContentReady: EventEmitter<NxePivotContentReadyEvent>;
+    readonly onOptionChanged: EventEmitter<NxePivotOptionChangedEvent>;
+    readonly onExporting: EventEmitter<NxePivotExportingEvent>;
+    /**
+     * dx `onOptionChanged` source: one snapshot of every documented option's EFFECTIVE value
+     * (facade overrides included, so `option(name, v)` and an input-binding change emit through
+     * the same diff — never twice). `dataSource` rides along, get-only.
+     */
+    private readonly optionSnapshot;
+    protected readonly fieldChooser: Signal<NxeFieldChooserComponent>;
+    /** The projected `nxe-field-panel` config (P3-C2) — the panel renders when it is visible. */
+    protected readonly fieldPanel: Signal<NxeFieldPanelComponent>;
+    /** The projected `nxe-state-storing` config — LIVE since P3-C4 for `type: 'custom'`:
+     *  every layout mutation fires `customSave(state)` and `customLoad` is honored on init. */
+    protected readonly stateStoring: Signal<NxeStateStoringComponent>;
+    /** dx `fieldPanel.visible` (default false): gates the panel, the corner's chips-vs-caption
+     *  switch, and the dx marker classes on the host. */
+    protected readonly panelVisible: Signal<boolean>;
+    /** The rendered panel component — source of the corner-hosted row-area template. */
+    private readonly panelCmp;
+    /** The ROW fields area, outletted into the corner cell (dx hosts the row chips inside
+     *  `.dx-area-description-cell` — oracle §c; the corner shows NO caption text then). */
+    protected readonly panelRowAreaTpl: Signal<_angular_core.TemplateRef<unknown>>;
+    /** The `.dx-pivotgrid-field-chooser-button` renders only when an `nxe-field-chooser` is
+     *  projected with `enabled` not false (the DA page passes [enabled]="true"). */
+    protected readonly chooserEnabled: Signal<boolean>;
+    /** dx toolbar placement (m_widget.js `_renderDescriptionArea`, verbatim branch order):
+     *  (a) panel visible && showFilterFields -> the `.dx-filter-header` band;
+     *  (b) panel visible && (showDataFields || showColumnFields) -> the `.dx-column-header`
+     *      band (dx-compat's dormant column-header button rules go live);
+     *  (c) else -> the cross-tab corner `.dx-area-description-cell`, where the
+     *      transparent-until-hover button rules (dx-compat ~1113-1118) apply. */
+    protected readonly chooserToolbarHost: Signal<"column" | "filter" | "corner">;
+    /** The panel-hosted placements, bound into the panel's `toolbarArea` input. */
+    protected readonly panelToolbarArea: Signal<"column" | "filter">;
+    protected readonly chooserInCorner: Signal<boolean>;
+    private chooserOverlayRef;
+    private readonly overlay;
+    private readonly viewContainerRef;
+    private readonly elementRef;
+    /** Bumped by `getDataSource().reload()` to force a re-aggregate. */
+    private readonly reloadTick;
+    /**
+     * W4 Lane 1: bumped by `repaint()` / `updateDimensions()` — RENDER-ONLY. dx `repaint()` is
+     * the plain Widget re-render (m_widget.js inherits it): it re-renders/re-layouts the
+     * existing data-controller state and never touches the data source, so it must NOT
+     * re-aggregate (the pre-W4 facade bumped `reloadTick`, which re-instantiated the engine
+     * and reset the state linkedSignals — wiping the user's expand/layout state on every
+     * sidebar toggle of the DA page). The signals already keep the DOM fresh; the observable
+     * effect of a repaint is re-running the measurement pass below (dx re-layout).
+     */
+    private readonly renderTick;
+    private readonly boundChart;
+    /** W4 Lane 4: the dx `bindChart(chart, integrationOptions)` options — a NEW object per
+     *  bindChart call, so re-binding re-renders (dx runs `updateChart` on every bind). */
+    private readonly chartBindOptions;
+    /**
+     * P3-C2: the field panel's mutations (chip drag between/within areas, click-to-sort — and
+     * since P3-C4 the header-filter applies), keyed by the field's index in the caller's
+     * `fields` array and MERGED over those fields when the engine is constructed — the caller's
+     * array/objects are never mutated (report-output-pivot serializes its own fields in
+     * `onSave`). Resets whenever the caller swaps `dataSource` (the DA page replaces the object
+     * on view select), exactly as dx resets the layout when a new state loads. (P3-C4 migrated
+     * that page's `onExpandAll` off its cloneDeep+swap onto the facade
+     * `expandAll()`/`collapseAll()`, so expand-all no longer wipes a dragged layout.)
+     */
+    private readonly fieldOverrides;
+    protected readonly engine: Signal<NxePivotDataSource>;
+    /**
+     * The "layout changed" hook (P3-C2, consumed since P3-C4): the caller's fields with the
+     * panel's overrides merged — a NEW array identity after every mutation (drag move, sort
+     * toggle, filter apply), the caller's own array untouched. `fireStateSave()` serializes
+     * THIS array into the `customSave` state after each mutation, so a consumer's Save
+     * persists the post-drag layout; `getExportModel()`/the Excel export read the same
+     * overridden engine, so exports reflect a move immediately.
+     */
+    readonly effectiveFields: Signal<NxePivotField[]>;
+    /**
+     * Per-node chevron overrides — W4 Lane 1: keyed on the `dataSource` INPUT identity (like
+     * {@link fieldOverrides}), NOT on the engine instance. dx keeps its expand state inside the
+     * data source (`getExpandedPaths` re-feeds `rowExpandedPaths`/`columnExpandedPaths` into
+     * every `_loadCore`, m_data_source.js), so `repaint()` (render-only), `reload()`
+     * (re-aggregate, state kept) and layout mutations (sort/move — dx keeps expandedPaths
+     * across them) all PRESERVE it; only a real dataSource swap (the DA page's `initChart`
+     * builds a new options object per view select) resets. Stale keys after an area move
+     * simply stop matching any node — harmless, dx-alike.
+     */
+    private readonly manualExpanded;
+    protected readonly model: Signal<NxePivotModel>;
+    /** Host height style — dx `height`: numbers are px, strings pass through, unset removes it. */
+    protected readonly hostHeight: Signal<string>;
+    /** The projected `nxe-scrolling` config — `mode: 'virtual'` opts into row windowing. */
+    protected readonly scrolling: Signal<NxeScrollingComponent>;
+    /** Scroll offset of `.nxe-pivotgrid-scroll` (its own scroll handler feeds it). */
+    private readonly scrollTop;
+    /** The scroll container's clientHeight, measured in the render effect (0 = unmeasured). */
+    private readonly viewportHeight;
+    /**
+     * Row windowing arms for `rowHeaderLayout: 'tree'` ONLY: the standard layout's expanded
+     * parents ROWSPAN their whole subtree, so slicing rows would orphan/clip the merged label
+     * cells (the dated DEFAULTS.md row) — dx sidesteps this with separate area panes. The DA
+     * page projects `mode="virtual"` but renders standard → no-op there; the calc tabs' tree
+     * pivots benefit. RENDER-ONLY: the model, export and chart always see every row.
+     */
+    protected readonly virtualActive: Signal<boolean>;
+    /** First windowed row (model index) — snapped back to a measures-on-rows group head. */
+    private readonly winStart;
+    /** One past the last windowed row (model index). */
+    private readonly winEnd;
+    /**
+     * The body rows the template renders: `{row, ri}` pairs where `ri` is the MODEL row index
+     * (matrix addressing must not shift with the window). The full array when windowing is off.
+     */
+    protected readonly viewRows: Signal<{
+        row: NxePivotBodyRow;
+        ri: number;
+    }[]>;
+    /** Spacer heights standing in for the unrendered rows (keep the scrollbar honest). */
+    protected readonly topSpacerH: Signal<number>;
+    protected readonly bottomSpacerH: Signal<number>;
+    /** Total table columns (spacer colspan): row-header cols (+measure col) + leaves. */
+    protected readonly totalColCount: Signal<number>;
+    protected onPivotScroll(event: Event): void;
+    /**
+     * dx `.dx-pivotgrid-nodata` (gridCoreUtils.renderNoDataText): shown when the data source
+     * `isEmpty()` — no VISIBLE data field or nothing aggregated (empty/fully-filtered store);
+     * text `texts.noData` (dx default "No data"). The reloadTick read re-checks after an
+     * in-place instance reload.
+     */
+    protected readonly showNoData: Signal<boolean>;
+    constructor();
+    protected toggle(pathKey: string, expanded: boolean): void;
+    /** W4 Lane 3 (a11y): Enter/Space on a focused expandable header cell toggles it (dx-like
+     *  keyboard expansion; preventDefault stops Space from scrolling the container). */
+    protected onExpandKey(event: Event, pathKey: string, expanded: boolean): void;
+    private domIndices;
+    private finishCellArgs;
+    private colHeaderArgs;
+    /** Standard-layout row-header cell (also the split measure-caption cells it renders). */
+    private rowHeaderArgs;
+    /** Tree-layout dimension label cell (synthesized from the row — tree rows carry one cell). */
+    private treeLabelArgs;
+    /** Tree-layout measure-caption cell (measures-on-rows). */
+    private measureCellArgs;
+    private dataCellArgs;
+    /** Grand-total footer data cell (both footer shapes). */
+    private gtDataArgs;
+    private gtHeaderArgs;
+    private cellEl;
+    protected onColHeaderCellClick(event: Event, cell: NxePivotHeaderCell): void;
+    protected onRowHeaderCellClick(event: Event, row: NxePivotBodyRow, hc: NxePivotRowHeaderCell | null): void;
+    protected onMeasureCellClick(event: Event, row: NxePivotBodyRow): void;
+    protected onDataCellClick(event: Event, ri: number, li: number): void;
+    protected onGtHeaderCellClick(event: Event, text: string): void;
+    protected onGtDataCellClick(event: Event, li: number, di: number, value: number | null, text: string): void;
+    /**
+     * Chevron click — dx `_handleCellClick`: fire the cancelable `onCellClick`, then toggle
+     * unless a handler set `cancel: true`. stopPropagation keeps the host cell's own click
+     * handler from emitting a second event for the same gesture.
+     */
+    protected onColExpandClick(event: Event, cell: NxePivotHeaderCell): void;
+    protected onRowExpandClick(event: Event, row: NxePivotBodyRow, hc: NxePivotRowHeaderCell | null): void;
+    /** dx m_area_item `_triggerOnCellPrepared`: one event per rendered cell, DOM in hand. */
+    private emitCellsPrepared;
+    /**
+     * A field-panel chip was dropped, or the chooser toggled/moved a field (P3-C2/P3-C3).
+     * Recompute areaIndexes like dx: remove the field from its current area, insert at the
+     * drop position (`area: null` = REMOVAL — the chooser's All-Fields tree drop or checkbox
+     * uncheck; panel/chooser drops outside every area never emit), then renumber the touched
+     * areas 0..n-1 — all recorded as overrides, never as writes into the caller's field
+     * objects.
+     *
+     * P3-C4 (closes the P3-C2 deferral (d)): the renumbering runs over the lists dx's
+     * `normalizeIndexes` sees (m_data_source `_createDescriptions` over its module-local
+     * `getAreaFields`) — the DATA area's `visible: false` fields are IN the numbering, hidden
+     * row/column/filter fields are not. The emitted `areaIndex` is a VISIBLE slot (the
+     * panel/chooser hit-test only visible chips), so the insertion offsets past the hidden
+     * fields before it, exactly like dx's `invisibleFieldsIndexOffset` (m_field_chooser_base
+     * `renderSortable.onChanged`).
+     */
+    protected onPanelFieldMove(e: NxePivotFieldMoveEvent): void;
+    /**
+     * A sortable chip was clicked (P3-C2). dx toggles the FIELD's sortOrder desc↔asc off the
+     * effective order (fields sort ascending by default, so the first click yields 'desc');
+     * the override feeds the engine's existing per-level sort.
+     */
+    protected onPanelSortToggle(e: {
+        fieldIndex: number;
+    }): void;
+    /** The field whose header-filter popup is open (`null` = closed). */
+    private readonly hfFieldIndex;
+    /**
+     * The shared header-filter model (W2b extraction) over the ENGINE's distinct values: dx
+     * feeds this popup from `dataSource.getFieldValues(index)` (m_field_chooser_base
+     * `subscribeToEvents` — the field loaded as a lone expanded column), so the adapter's
+     * "rows" ARE those `{value, text}` items — post-groupInterval group values with their
+     * display labels, from the UNFILTERED store (dx `showRelevantValues` default false).
+     * Blank-ish values fold into the model's `(Blanks)` bucket, first (dx
+     * `headerFilter.texts.emptyValue` = "(Blanks)"). `isDate` is pinned false: dx's PIVOT list
+     * is flat even for date fields (the Year>Month>Day tree is the grid's own semantics —
+     * DEFAULTS.md, dated P3-C4 note). The model's column token is the FIELD object (a bare
+     * fieldIndex would read falsy for index 0 — the model treats a falsy column as closed).
+     */
+    protected readonly hf: NxeHeaderFilterModel<NxePivotField>;
+    private hfOverlayRef;
+    /** A chip funnel was clicked (panel or chooser) — open the shared header-filter popup. */
+    protected openPivotHeaderFilter(e: NxePivotFilterOpenEvent): void;
+    /**
+     * The field's applied `filterValues` as model keys — blank-ish raws fold into the
+     * `(Blanks)` sentinel; `filterType: 'exclude'` inverts over the field's distinct keys
+     * (dx `processItems` marks each item selected iff included, inverted for exclude).
+     */
+    private appliedKeys;
+    /**
+     * OK — dx's menu apply writes `{filterValues, filterType}` onto the field and reloads
+     * (m_field_chooser_base `apply` → `_applyChanges`); here they land in the fieldOverride
+     * map → the engine refilters at record intake (P2-C3). Full-checked = filter CLEARED (the
+     * model's null rule — `filterValues: null` so a declarative seed can't resurrect). The
+     * stored set is always the INCLUDE set (dx sometimes stores the complement with
+     * `filterType: 'exclude'` — DEFAULTS.md, dated P3-C4 note).
+     */
+    private applyPivotHeaderFilter;
+    private closePivotHeaderFilter;
+    /**
+     * dx StateStoringController: after every data change the pivot's data controller pushes
+     * `dataSource.state()` into the controller and `save()`s (m_data_controller ~854-856) —
+     * for `type: 'custom'` that ends in `customSave(state)` (m_state_storing_core
+     * `_saveState`). Here it fires synchronously per LAYOUT MUTATION (drag, sort toggle,
+     * filter apply, chooser check/uncheck) — no `savingTimeout` debounce (dx default 2000ms)
+     * and no save on plain loads (DEFAULTS.md, dated P3-C4 notes). The
+     * localStorage/sessionStorage types stay inert.
+     */
+    private fireStateSave;
+    /**
+     * The dx-shaped state: `fields` serialized from {@link effectiveFields} (the caller's
+     * fields with every override merged — the POST-mutation layout), plus the state's
+     * expanded-path arrays (always empty here — nxe holds chevron state internally;
+     * DEFAULTS.md).
+     *
+     * Each entry is a FULL shallow copy of the effective field — every own enumerable
+     * property, function members (selector/customizeText/calculateCustomSummary/
+     * calculateSummaryValue) included — which trivially guarantees the dx state keys
+     * (dataField + area/areaIndex/expanded/sortOrder/filterValues/filterType and the
+     * caption/format/summaryType passthrough) wherever the field defines them.
+     *
+     * THE FULL COPY IS LOAD-BEARING (P3-C4 review): report-output-pivot's
+     * `sendStorageRequest` REPLACES its live `pivotGridDataSource.fields` with this very
+     * array, and the engine computed re-reads `opts.fields` on its next rebuild — the next
+     * mutation, or a facade `reload()` (since W4 Lane 1 `repaint()` is render-only and no
+     * longer rebuilds the engine; the replaced fields carry the same values the engine
+     * already renders, so nothing is lost in the interim). A slim
+     * dx-keys-only payload would strip dataType/groupInterval (date bucketing degrades),
+     * `visible: false` (hidden helper measures reappear), width/sortBy/summaryDisplayMode/
+     * name, and the per-field allowSorting/allowFiltering opt-outs out of the LIVE config on
+     * that rebuild. dx never fed its state back into a live widget — only its SAVED JSON was
+     * slim — and the production REPORT_SETTING `otherValue1` payloads carry full field defs
+     * (captions/dataTypes/formats) anyway; `JSON.stringify` drops the function members
+     * harmlessly when the Save dialog serializes later.
+     */
+    private buildStorageState;
+    /**
+     * dx stateStoring `customLoad` contract (m_state_storing_core `_loadState` + `load`): the
+     * return value goes through `fromPromise` — a plain state object OR a Promise of one both
+     * work — and applies only when non-null and not an empty object; a rejected promise
+     * applies nothing.
+     */
+    private runCustomLoad;
+    /**
+     * Apply a loaded state's `fields` over the caller's fields as overrides — dx
+     * `setFieldsState` (m_data_source): state fields match by `name` falling back to
+     * `dataField` (same-id fields pair by order), and each match writes the state properties
+     * onto the field, `undefined` area CLEARING it. Narrowings (DEFAULTS.md): only the
+     * override-expressible properties apply (area/areaIndex/sortOrder/expanded/filterValues/
+     * filterType — not sortBy/summaryType/summaryDisplayMode), and a field ABSENT from the
+     * state keeps its own config where dx would reset its state properties.
+     */
+    private applyLoadedState;
+    /**
+     * P3-C3: open the field chooser popup — dx `_fieldChooserPopup.show()` off the toolbar
+     * button. CDK overlay centered in the viewport (the dx popup's default position), pane
+     * carrying `nxePane('nxe-fieldchooser-pane')` (the widget font contract for body-level
+     * panes). NO backdrop: dx renders this popup with `shading: false` and its
+     * `hideOnOutsideClick` default (false), so the pivot behind stays fully interactive
+     * while the instantly-applying chooser is open and an outside click neither closes nor
+     * blocks — only the title-bar X and Escape (OverlayKeyboardDispatcher routes body
+     * keydowns to the topmost overlay with observers) close it. The chooser gets the LIVE
+     * engine signal, so applyChangesMode-'instantly' mutations flow chooser ->
+     * onPanelFieldMove/onPanelSortToggle -> fieldOverrides -> engine -> every rendered
+     * surface, with the popup still open.
+     */
+    protected toggleFieldChooser(): void;
+    private closeFieldChooser;
+    ngOnDestroy(): void;
+    /**
+     * W4 Lane 4 — series derive from the COLUMN LEAVES (kind 'D' — subtotal 'T' columns and
+     * the grand-total column are presentation, charting them would double-count), one series
+     * per (column path × visible measure), fixing the P2-C2 minor: the old code charted only
+     * the grand-total leaf and, with grand totals OFF, silently fell back to the FIRST leaf
+     * (one arbitrary column mislabeled as the measure's totals). Categories stay the
+     * non-subtotal body rows — the established nxe orientation (== dx `inverted: true`;
+     * DEFAULTS.md). Honors the dx integration options (see {@link NxePivotBindChartOptions}):
+     * `alternateDataFields` (series order), `putDataFieldsInto` ('series'/'args'/'both'),
+     * `dataFieldsDisplayMode` (accepted, structural no-op on the single-pane nxe chart).
+     * Works identically for `dataFieldArea: 'row'` — dx's chart reads the data source, never
+     * the widget layout, so measures-on-rows charts the same series.
+     */
+    private buildSeries;
+    private readonly facade;
+    /**
+     * dx `option(name[, value])` (W4 Lane 2). Get: the EFFECTIVE value (override ?? input);
+     * `'dataSource'` is additionally readable. Set: only the documented names in
+     * {@link effOptions} — the write lands in {@link optionOverrides}, wins over the input
+     * binding, and flows through the option-snapshot diff into `onOptionChanged`. Unsupported
+     * names (dataSource, nested `'a.b'` paths, the projected-config children) are a silent
+     * no-op on set / undefined on get, recorded in DEFAULTS.md.
+     */
+    private optionFacade;
+    /**
+     * dx `exportToExcel()` — the widget's built-in export path (m_export.js `exportTo`): fire
+     * the cancelable `onExporting` with dx's default fileName 'PivotGrid' (a handler may
+     * rename or cancel), then run the SAME `exportPivotGrid({component})` pipeline
+     * report-output-pivot drives from its own toolbar (that page-side path stays untouched
+     * and, like dx's standalone exporter, never fires the widget event).
+     */
+    private runExportToExcel;
+    /** Download seam (specs spy here — nxeSaveAs clicks a synthetic anchor). */
+    protected saveExportedWorkbook(blob: Blob, fileName: string): void;
+    /**
+     * Oracle §e: dx's expand-all/collapse-all set `expanded` on EVERY field of the data source
+     * and reload — and the dx-era report page did the same blanket `field.expanded` mutation,
+     * which is why its Save persisted the expanded state and a reload restored it. Mirrored
+     * here (P3-C4, replacing the earlier private allExpanded model flag) as `expanded`
+     * fieldOverrides on EVERY field — data and filter fields included, exactly like the old
+     * page's loop and dx's own mutation: the caller's objects stay untouched, the state
+     * survives engine rebuilds, and it serializes through {@link effectiveFields} into the
+     * `customSave` payload with no special-casing. The per-node chevron map is wiped
+     * EXPLICITLY below (since W4 Lane 1 it is keyed on the dataSource input and survives
+     * engine rebuilds, so the old implicit reset no longer happens) — dx-identical: individual
+     * toggles then work on top. `fireStateSave()` closes the Save-after-expandAll loop (it
+     * no-ops when no `nxe-state-storing` is projected).
+     */
+    private setAllExpanded;
+    get instance(): NxePivotGridInstance;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxePivotGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePivotGridComponent, "nxe-pivot-grid", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; "allowFiltering": { "alias": "allowFiltering"; "required": false; "isSignal": true; }; "allowSortingBySummary": { "alias": "allowSortingBySummary"; "required": false; "isSignal": true; }; "allowExpandAll": { "alias": "allowExpandAll"; "required": false; "isSignal": true; }; "showBorders": { "alias": "showBorders"; "required": false; "isSignal": true; }; "wordWrapEnabled": { "alias": "wordWrapEnabled"; "required": false; "isSignal": true; }; "rowHeaderLayout": { "alias": "rowHeaderLayout"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "texts": { "alias": "texts"; "required": false; "isSignal": true; }; "showColumnTotals": { "alias": "showColumnTotals"; "required": false; "isSignal": true; }; "showRowTotals": { "alias": "showRowTotals"; "required": false; "isSignal": true; }; "showColumnGrandTotals": { "alias": "showColumnGrandTotals"; "required": false; "isSignal": true; }; "showRowGrandTotals": { "alias": "showRowGrandTotals"; "required": false; "isSignal": true; }; "showTotalsPrior": { "alias": "showTotalsPrior"; "required": false; "isSignal": true; }; "dataFieldArea": { "alias": "dataFieldArea"; "required": false; "isSignal": true; }; "allowSorting": { "alias": "allowSorting"; "required": false; "isSignal": true; }; }, { "onCellClick": "onCellClick"; "onCellPrepared": "onCellPrepared"; "onContentReady": "onContentReady"; "onOptionChanged": "onOptionChanged"; "onExporting": "onExporting"; }, ["fieldChooser", "fieldPanel", "stateStoring", "scrolling"], never, true, never>;
+}
+
+declare class NxePivotFieldChipComponent {
+    readonly chip: _angular_core.InputSignal<NxePivotPanelChip>;
+    /** Raw pointerdown — the host decides whether a drag gesture may begin. */
+    readonly chipPointerDown: _angular_core.OutputEmitterRef<PointerEvent>;
+    /** Chip click (the host consults its gesture's click suppression before sorting). */
+    readonly chipClick: _angular_core.OutputEmitterRef<void>;
+    /** The funnel was clicked — the host opens the header-filter panel for this field. */
+    readonly chipFilterClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    protected onFunnelClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxePivotFieldChipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePivotFieldChipComponent, "div[nxePivotFieldChip]", never, { "chip": { "alias": "chip"; "required": true; "isSignal": true; }; }, { "chipPointerDown": "chipPointerDown"; "chipClick": "chipClick"; "chipFilterClick": "chipFilterClick"; }, never, never, true, never>;
+}
+
+/** One All-Fields tree row (the fixture's flat leaf list — local fields have no groups). */
+interface ChooserTreeItem {
+    fieldIndex: number;
+    caption: string;
+    selected: boolean;
+    isMeasure: boolean | undefined;
+}
+interface ChooserArea {
+    group: NxePivotArea;
+    caption: string;
+    icon: string;
+    chips: NxePivotPanelChip[];
+}
+declare class NxePivotFieldChooserComponent implements OnDestroy {
+    /** The pivot's LIVE engine signal (overrides merged) — instant applies re-read it here. */
+    readonly engine: _angular_core.InputSignal<Signal<NxePivotDataSource>>;
+    /** dx `fieldChooser.width`/`height` — applied to the popup box; dxPivotGrid defaults 600
+     *  (m_widget.js `fieldChooser` defaults; the DA page passes height 400). */
+    readonly width: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    /** dx `fieldChooser.allowSearch` (default false — the capture has NO search box). */
+    readonly allowSearch: _angular_core.InputSignal<boolean>;
+    /** Widget `allowSorting`: dimension chips inside the chooser sort on click, same as the
+     *  panel's (dx stamps the widget flag onto every field; data chips never sort). */
+    readonly allowSorting: _angular_core.InputSignal<boolean>;
+    /** Widget `allowFiltering` (P3-C4): dimension chips inside the chooser carry the same
+     *  header-filter funnel as the panel's (dx renderField is FieldChooserBase machinery —
+     *  shared by both surfaces). Same per-field precedence as `allowSorting`. */
+    readonly allowFiltering: _angular_core.InputSignal<boolean>;
+    /** Every chooser mutation (checkbox toggle, drag between areas) — the pivot feeds these
+     *  through the SAME `onPanelFieldMove` renumbering the field panel uses. */
+    readonly fieldMove: _angular_core.OutputEmitterRef<NxePivotFieldMoveEvent>;
+    /** A sortable chip inside the chooser was clicked. */
+    readonly sortToggle: _angular_core.OutputEmitterRef<{
+        fieldIndex: number;
+    }>;
+    /** A chip's funnel was clicked — the pivot opens the header-filter panel (P3-C4). */
+    readonly filterOpen: _angular_core.OutputEmitterRef<NxePivotFilterOpenEvent>;
+    /** The title-bar X — the pivot disposes the overlay (Escape/backdrop close there too). */
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly texts: {
+        allFields: string;
+        rowFields: string;
+        columnFields: string;
+        filterFields: string;
+        dataFields: string;
+        title: string;
+    };
+    protected readonly allIcon: string;
+    protected readonly searchText: _angular_core.WritableSignal<string>;
+    private readonly elementRef;
+    private readonly zone;
+    /** Popup box size — dx puts fieldChooser.width/height on `.dx-overlay-content` (600 dflt). */
+    protected readonly boxWidth: Signal<string>;
+    protected readonly boxHeight: Signal<string>;
+    /**
+     * All Fields tree rows: every defined `visible !== false` field (m_field_chooser.js
+     * `_createFieldsDataSource`), checked when it HAS an area (`selected: isDefined(field.area)`),
+     * ordered by dx `compareItems` — plain text comparison here (no groups, no isMeasure).
+     */
+    protected readonly treeItems: Signal<ChooserTreeItem[]>;
+    protected readonly rowArea: Signal<ChooserArea>;
+    protected readonly columnArea: Signal<ChooserArea>;
+    protected readonly filterArea: Signal<ChooserArea>;
+    protected readonly dataArea: Signal<ChooserArea>;
+    protected onCheckboxClick(item: ChooserTreeItem): void;
+    protected onSearchInput(event: Event): void;
+    protected onChipClick(chip: NxePivotPanelChip): void;
+    protected onChipFilterClick(chip: NxePivotPanelChip, event: MouseEvent): void;
+    private drag;
+    private readonly gesture;
+    ngOnDestroy(): void;
+    protected onChipPointerDown(chip: NxePivotPanelChip, area: NxePivotArea, event: PointerEvent): void;
+    private buildArea;
+    private host;
+    /**
+     * dx m_field_chooser_base.js `renderSortable.onDragging` cancel rules: a true measure may
+     * only sit in data; an explicit non-measure never in data; undefined = unrestricted.
+     */
+    private allowedIn;
+    private trackPointer;
+    /** dx `.dx-position-indicator-vertical`: a 2px bar between the stacked chips. */
+    private placeIndicator;
+    private completeDrop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxePivotFieldChooserComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxePivotFieldChooserComponent, "nxe-pivot-field-chooser", never, { "engine": { "alias": "engine"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "allowSearch": { "alias": "allowSearch"; "required": false; "isSignal": true; }; "allowSorting": { "alias": "allowSorting"; "required": false; "isSignal": true; }; "allowFiltering": { "alias": "allowFiltering"; "required": false; "isSignal": true; }; }, { "fieldMove": "fieldMove"; "sortToggle": "sortToggle"; "filterOpen": "filterOpen"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/** `dxo-common-series-settings` — the series type (only `bar` is used). */
+declare class NxeCommonSeriesSettingsComponent {
+    readonly type: _angular_core.InputSignal<"area" | "line" | "bar" | "spline">;
+    readonly argumentField: _angular_core.InputSignal<string>;
+    readonly valueField: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeCommonSeriesSettingsComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeCommonSeriesSettingsComponent, "nxe-common-series-settings", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "argumentField": { "alias": "argumentField"; "required": false; "isSignal": true; }; "valueField": { "alias": "valueField"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** `dxo-size` — fixed chart height. */
+declare class NxeSizeComponent {
+    readonly width: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeSizeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeSizeComponent, "nxe-size", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** `dxo-adaptive-layout` — responsive breakpoint width (the chart fills its container above it). */
+declare class NxeAdaptiveLayoutComponent {
+    readonly width: _angular_core.InputSignal<number>;
+    readonly height: _angular_core.InputSignal<number>;
+    readonly keepLabels: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeAdaptiveLayoutComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeAdaptiveLayoutComponent, "nxe-adaptive-layout", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "keepLabels": { "alias": "keepLabels"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface BarRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    fill: string;
+}
+declare class NxeChartComponent {
+    readonly dataSource: _angular_core.InputSignal<NxeChartSeries>;
+    protected readonly commonSeries: _angular_core.Signal<NxeCommonSeriesSettingsComponent>;
+    protected readonly size: _angular_core.Signal<NxeSizeComponent>;
+    protected readonly adaptiveLayout: _angular_core.Signal<NxeAdaptiveLayoutComponent>;
+    /** Series pushed by `pivotGrid.bindChart(...)`; falls back to the `[dataSource]` input. */
+    private readonly pushed;
+    protected readonly series: _angular_core.Signal<NxeChartSeries>;
+    protected readonly chartHeight: _angular_core.Signal<number>;
+    protected readonly chartWidth: _angular_core.Signal<number>;
+    protected readonly hasData: _angular_core.Signal<boolean>;
+    private readonly PAD;
+    protected readonly bars: _angular_core.Signal<BarRect[]>;
+    protected readonly legend: _angular_core.Signal<{
+        name: string;
+        fill: string;
+    }[]>;
+    protected readonly baselineY: _angular_core.Signal<number>;
+    protected readonly axisLeft: _angular_core.Signal<number>;
+    protected readonly axisRight: _angular_core.Signal<number>;
+    private readonly facade;
+    get instance(): NxeChartInstance;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NxeChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NxeChartComponent, "nxe-chart", never, { "dataSource": { "alias": "dataSource"; "required": false; "isSignal": true; }; }, {}, ["commonSeries", "size", "adaptiveLayout"], never, true, never>;
+}
+
+export { NXE_PIVOT_TEXTS_DEFAULTS, NxeAdaptiveLayoutComponent, NxeChartComponent, NxeCommonSeriesSettingsComponent, NxeExcelExportService, NxeFieldChooserComponent, NxeFieldPanelComponent, NxePivotDataSource, NxePivotFieldChipComponent, NxePivotFieldChooserComponent, NxePivotFieldPanelComponent, NxePivotGridComponent, NxeSizeComponent, NxeStateStoringComponent, buildChip, exportPivotGrid };
+export type { NxeChartInstance, NxeChartSeries, NxeExportPivotGridOptions, NxePivotArea, NxePivotBindChartOptions, NxePivotBodyRow, NxePivotCellData, NxePivotCellEvent, NxePivotColumnLeaf, NxePivotContentReadyEvent, NxePivotCustomSummaryInfo, NxePivotDataSourceOptions, NxePivotExportingEvent, NxePivotField, NxePivotFieldMoveEvent, NxePivotFieldOverride, NxePivotFilterOpenEvent, NxePivotGridInstance, NxePivotGroupInterval, NxePivotHeaderCell, NxePivotModel, NxePivotModelOptions, NxePivotOptionChangedEvent, NxePivotPanelChip, NxePivotRowHeaderCell, NxePivotRowHeaderLayout, NxePivotRowKind, NxePivotSummaryCell, NxePivotSummaryDisplayMode, NxePivotSummaryType, NxePivotTexts, NxePivotTotalsPrior };