@guiexpert/table 1.1.93 → 1.1.96

package/lib/table/formula/formula-options.if.d.ts

@@ -0,0 +1,41 @@
+import { FormulaError } from './formula-error.js';
+
+/**
+ * A value inside a formula: a number, a text, a boolean, blank (`null`) or an error.
+ *
+ * @example
+ * const fn: FormulaFunction = (x: FormulaValue) => typeof x === "number" ? x * 1.19 : x;
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type FormulaValue = number | string | boolean | null | FormulaError;
+/**
+ * An own function for formulas. It gets the evaluated arguments (never an error – an error argument is returned
+ * without calling the function) and returns a number, text, boolean or `null`. Anything else, an exception or
+ * `NaN` becomes `#VALUE!` resp. `#NUM!`.
+ *
+ * @example
+ * const VAT: FormulaFunction = (net) => Number(net) * 0.19;
+ * compileFormula("VAT([price])", { functions: { VAT } });
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export type FormulaFunction = (...args: FormulaValue[]) => unknown;
+/**
+ * Options of {@link compileFormula}.
+ *
+ * @example
+ * const options: FormulaOptionsIf = {
+ *   functions: { NET: (gross) => Number(gross) / 1.19 }
+ * };
+ * ColumnDef.create({ property: "net", headerLabel: "Net", formula: "NET([gross])", formulaOptions: options });
+ *
+ * @since 1.1.95
+ * @category Calculated columns & formulas
+ */
+export interface FormulaOptionsIf {
+    /** Own functions by name (case-insensitive). They may replace built-in ones. */
+    functions?: Record<string, FormulaFunction>;
+}

package/lib/table/formula/formula-values.d.ts

@@ -0,0 +1,13 @@
+import { FormulaError } from './formula-error.js';
+import { FormulaValue } from './formula-options.if.js';
+
+export declare function isBlank(v: FormulaValue): boolean;
+/** A value from the data (a field) as formula value: Date → ms, function/object → #VALUE!. */
+export declare function fromData(v: unknown, name: string, trusted?: boolean): FormulaValue;
+export declare function toNumber(v: FormulaValue): number | FormulaError;
+export declare function toText(v: FormulaValue): string | FormulaError;
+export declare function toBoolean(v: FormulaValue): boolean | FormulaError;
+/** A number result: NaN / ±Infinity → #NUM!, -0 → 0. */
+export declare function numberResult(n: number): number | FormulaError;
+/** Compares two values: numbers numerically, texts case-insensitively, blank = 0 = "" = FALSE. */
+export declare function compareValues(a: FormulaValue, b: FormulaValue): number | FormulaError;

package/lib/table/formula/functions.d.ts

@@ -0,0 +1,18 @@
+import { FormulaValue } from './formula-options.if.js';
+
+/** A built-in function with eagerly evaluated arguments (errors are returned before the call). */
+export interface BuiltInFunction {
+    readonly min: number;
+    readonly max: number;
+    readonly fn: (args: FormulaValue[]) => FormulaValue;
+}
+/** Functions with lazily evaluated arguments – handled by the evaluator itself. */
+export declare const LAZY_FUNCTIONS: Record<string, {
+    min: number;
+    max: number;
+}>;
+/** SUM, AVG … with exactly one field reference: an aggregate over the (filtered) rows of the table. */
+export declare const AGGREGATE_FUNCTIONS: Record<string, "sum" | "avg" | "min" | "max" | "count">;
+/** Rounds half away from zero (like Excel) without binary artefacts: ROUND(1.005, 2) = 1.01. */
+export declare function roundHalfAwayFromZero(x: number, digits: number): number;
+export declare const BUILT_IN_FUNCTIONS: Record<string, BuiltInFunction>;

package/lib/table/formula/parser.d.ts

@@ -0,0 +1,10 @@
+import { FormulaNode } from './formula-ast.if.js';
+
+/** The maximum length of a formula (characters). */
+export declare const MAX_FORMULA_LENGTH = 10000;
+/** The maximum nesting depth (parentheses, function calls, unary operators). */
+export declare const MAX_FORMULA_DEPTH = 64;
+/** The maximum number of binary operators (a long chain is a deep tree, too). */
+export declare const MAX_FORMULA_OPERATORS = 1000;
+/** Parses a formula into an AST. Throws a {@link FormulaSyntaxError}. */
+export declare function parseFormula(source: string): FormulaNode;

package/lib/table/formula/tokenizer.d.ts

@@ -0,0 +1,22 @@
+import { FormulaError } from './formula-error.js';
+
+/** The kinds of tokens of a formula. */
+export type FormulaTokenKind = "number" | "string" | "field" | "ident" | "op" | "(" | ")" | "," | "eof";
+/** One token: kind, text (number/string already decoded) and position in the source. */
+export interface FormulaToken {
+    readonly kind: FormulaTokenKind;
+    readonly text: string;
+    readonly value?: number;
+    readonly pos: number;
+}
+/** Thrown by tokenizer and parser, caught by `compileFormula` – never leaves the formula module. */
+export declare class FormulaSyntaxError extends Error {
+    readonly pos: number;
+    constructor(message: string, pos: number);
+    toFormulaError(): FormulaError;
+}
+/**
+ * Splits a formula into tokens. Whitespace is ignored. Throws a {@link FormulaSyntaxError} for an unknown character,
+ * an unterminated string or field reference.
+ */
+export declare function tokenize(source: string): FormulaToken[];

package/lib/table/instanceof-workaround.d.ts

@@ -1,3 +1,13 @@
+import { RowNumberColumnDef } from './data/common/row-number-column-def.js';
+import { AreaModelAggregateFooter } from './data/tablemodel/areamodel/area-model-aggregate-footer.js';
+import { AreaModelRowGroups } from './data/tablemodel/areamodel/area-model-row-groups.js';
+import { RowGroupIf } from './rowgroup/row-group.if.js';
+import { RowGroupColumnDef } from './rowgroup/row-group-column-def.js';
+import { TreeRowIf } from './data/common/tree-row-if.js';
+import { AreaModelPivot } from './data/tablemodel/areamodel/area-model-pivot.js';
+import { PivotTableModel } from './pivot/pivot-table-model.js';
+import { PivotColumnDef } from './pivot/pivot-column-def.js';
+
 /**
  * Checks if the given row is a tree row.
  *
@@ -17,6 +27,16 @@ export declare function isTreeRow(row: any): boolean;
  * @category Utilities
  */
 export declare function isAreaModelTree(model: any): boolean;
+/**
+ * True for a {@link CheckboxCellRenderer} – also from another copy of the core (no `instanceof`).
+ *
+ * @example
+ * isCheckboxCellRenderer(new CheckboxCellRenderer()); // true
+ *
+ * @since 1.1.91
+ * @category Utilities
+ */
+export declare function isCheckboxCellRenderer(o: any): boolean;
 /**
  * Checks if the given object is a CheckboxColumnDef.
  *
@@ -25,14 +45,131 @@ export declare function isAreaModelTree(model: any): boolean;
  *
  * @category Utilities
  */
+export declare function isCheckboxColumnDef(o: any): boolean;
 /**
- * True for a {@link CheckboxCellRenderer} – also from another copy of the core (no `instanceof`).
+ * True for a {@link RowNumberColumnDef} – also from another copy of the core (no `instanceof`).
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getColumnDef(0)`
+ * @returns {boolean} true for a row number column
  *
  * @example
- * isCheckboxCellRenderer(new CheckboxCellRenderer()); // true
+ * const hasRowNumbers = isRowNumberColumnDef(tableModel.getColumnDef(0));
  *
- * @since 1.1.91
- * @category Utilities
+ * @since 1.1.93
+ * @category Row numbers
  */
-export declare function isCheckboxCellRenderer(o: any): boolean;
-export declare function isCheckboxColumnDef(o: any): boolean;
+export declare function isRowNumberColumnDef(o: any): o is RowNumberColumnDef;
+/**
+ * True for an {@link AreaModelAggregateFooter} – also from another copy of the core (no `instanceof`).
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getAreaModel("footer")`
+ * @returns {boolean} true for a footer with totals
+ *
+ * @example
+ * const footer = tableModel.getAreaModel("footer");
+ * const totals = isAreaModelAggregateFooter(footer) ? footer.getResults() : {};
+ *
+ * @since 1.1.94
+ * @category Aggregation
+ */
+export declare function isAreaModelAggregateFooter(o: any): o is AreaModelAggregateFooter;
+/**
+ * True for a group of a row grouping ({@link RowGroupIf}) – the `data` of a group row. Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `treeRow.data`
+ * @returns {boolean} true for a group
+ *
+ * @example
+ * const row = tableModel.getBodyModel().getRowByIndex(rowIndex);
+ * if (isTreeRow(row) && isRowGroup(row.data)) console.log(row.data.label, row.data.count);
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isRowGroup(o: any): o is RowGroupIf;
+/**
+ * True for a group row of a row grouping: a tree row whose `data` is a {@link RowGroupIf} (detail rows hold your objects).
+ *
+ * @param {any} row - a body row, e.g. `tableModel.getBodyModel().getRowByIndex(rowIndex)` or `mouseEvent.row`
+ * @returns {boolean} true for a group row
+ *
+ * @example
+ * const eventListener = new EventAdapter();
+ * eventListener.onMouseClicked = (evt: GeMouseEvent) => {
+ *   const row = tableModel.getBodyModel().getRowByIndex(evt.rowIndex);
+ *   if (isGroupRow(row)) console.log("group", row.data.path);
+ * };
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isGroupRow(row: any): row is TreeRowIf<RowGroupIf>;
+/**
+ * True for the body model of a row grouping ({@link AreaModelRowGroups}). It is a tree as well
+ * (`isAreaModelTree` is true). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getBodyModel()`
+ * @returns {boolean} true for a row grouping
+ *
+ * @example
+ * const body = tableModel.getBodyModel();
+ * const groups = isAreaModelRowGroups(body) ? body.getGroups() : [];
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isAreaModelRowGroups(o: any): o is AreaModelRowGroups;
+/**
+ * True for the group column of a row grouping ({@link RowGroupColumnDef}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. a column definition
+ * @returns {boolean} true for the group column
+ *
+ * @example
+ * const groupColumnIndex = (tableModel.getColumnDefs() ?? []).findIndex(isRowGroupColumnDef);
+ *
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare function isRowGroupColumnDef(o: any): o is RowGroupColumnDef;
+/**
+ * True for the table model of a pivot table ({@link PivotTableModel}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `tableApi.getTableModel()`
+ * @returns {boolean} true for a pivot table
+ *
+ * @example
+ * const model = tableApi.getTableModel();
+ * const config = isPivotTableModel(model) ? model.getPivotConfig() : undefined;
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function isPivotTableModel(o: any): o is PivotTableModel;
+/**
+ * True for the body of a pivot table ({@link AreaModelPivot}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. `tableModel.getBodyModel()`
+ * @returns {boolean} true for a pivot body
+ *
+ * @example
+ * const body = tableModel.getBodyModel();
+ * const total = isAreaModelPivot(body) ? pivotBody.getResult().getValue() : undefined;
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function isAreaModelPivot(o: any): o is AreaModelPivot;
+/**
+ * True for a value column of a pivot table ({@link PivotColumnDef}). Works across copies of the core.
+ *
+ * @param {any} o - the object to check, e.g. a column definition
+ * @returns {boolean} true for a value, subtotal or total column of a pivot
+ *
+ * @example
+ * const valueColumns = (tableModel.getColumnDefs() ?? []).filter(isPivotColumnDef);
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function isPivotColumnDef(o: any): o is PivotColumnDef;

package/lib/table/pivot/area-model-pivot-header.d.ts

@@ -0,0 +1,9 @@
+import { AreaModelCellGroups } from '../data/tablemodel/areamodel/area-model-cell-groups.js';
+
+/**
+ * The header of a pivot table: header groups with classes for the labels – column groups (`2026`, `Jan`) start at the
+ * left of their span (a wide group stays readable), column labels (`Q1`, `Revenue`) sit above their numbers.
+ */
+export declare class AreaModelPivotHeader extends AreaModelCellGroups {
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+}

package/lib/table/pivot/pivot-column-def.d.ts

@@ -0,0 +1,28 @@
+import { ColumnDef } from '../data/tablemodel/column/column-def.js';
+import { SizeIf } from '../data/common/size.if.js';
+import { PivotColumnInfoIf } from './pivot-column-info.if.js';
+
+/**
+ * A value column of a pivot table – created by {@link PivotFactory} (you don't create them yourself). Its property is
+ * stable for the same column key and value (`pivot:[["monat","s:Jan"],"sum(umsatz)"]`), so widths and sorting are
+ * remembered like for any column; {@link AreaModelPivot.getColumnProperty} builds it for you.
+ *
+ * @example
+ * const columns = tableModel.getColumnDefs()?.filter(isPivotColumnDef) ?? [];
+ * columns.map(c => c.pivot.kind);   // ["value", "value", "total"]
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class PivotColumnDef extends ColumnDef {
+    readonly pivot: PivotColumnInfoIf;
+    /** Marker for {@link isPivotColumnDef} (works across copies of the core). */
+    readonly type = "PivotColumnDef";
+    /**
+     * @param {string} property - the stable property
+     * @param {string} headerLabel - the label in the lowest header row
+     * @param {PivotColumnInfoIf} pivot - what the column shows
+     * @param {SizeIf} [width] - the width (default 100 px)
+     */
+    constructor(property: string, headerLabel: string, pivot: PivotColumnInfoIf, width?: SizeIf);
+}

package/lib/table/pivot/pivot-column-info.if.d.ts

@@ -0,0 +1,25 @@
+import { RowGroupIf } from '../rowgroup/row-group.if.js';
+import { PivotValueInfoIf } from './pivot-value.type.js';
+
+/**
+ * What a value column of a pivot table shows ({@link AreaModelPivot.getColumnInfo}): the values of one column key
+ * (`"value"`), the subtotal of a column group (`"subtotal"`, with {@link PivotConfigIf.columnSubtotals}) or the
+ * total over all column keys (`"total"`).
+ *
+ * @example
+ * const info = pivotModel.getPivotBody().getColumnInfo(columnIndex);
+ * if (info?.kind === "value") console.log(info.column?.path, info.value.name);   // ["Jan"], "sum(umsatz)"
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotColumnInfoIf {
+    /** `"value"` – one column key, `"subtotal"` – a column group, `"total"` – all columns. */
+    readonly kind: "value" | "subtotal" | "total";
+    /** The column key (lowest level) or column group; undefined for the total. */
+    readonly column?: RowGroupIf;
+    /** The value shown in the column. */
+    readonly value: PivotValueInfoIf;
+    /** The index of the value in {@link PivotConfigIf.values}. */
+    readonly valueIndex: number;
+}

package/lib/table/pivot/pivot-config.if.d.ts

@@ -0,0 +1,58 @@
+import { RowGroupField } from '../rowgroup/row-group-field.type.js';
+import { RowGroupExpanded } from '../rowgroup/row-group-model-options.if.js';
+import { PivotValue } from './pivot-value.type.js';
+
+/**
+ * What a pivot table shows: the row fields (grouped like a row grouping), the column fields (their values become
+ * columns) and the values (aggregated per row × column), plus subtotals and totals. Used by
+ * {@link PivotFactory.createTableModel}, {@link pivotRows} and {@link TableApi.setPivotConfig}.
+ *
+ * Fields have the form of a row grouping level ({@link RowGroupField}): a property path, a function (e.g. the quarter
+ * of a date) or {@link RowGroupFieldIf} with `label`, `format` and `order` – `groupBy` of a row grouping works as
+ * `rowFields`.
+ *
+ * @example
+ * const config: PivotConfigIf<Sale> = {
+ *   rowFields: ["region", "produkt"],
+ *   columnFields: [{ value: "monat", order: "insertion" }],   // Jan before Feb (order in the data)
+ *   values: ["umsatz"],                                        // sum of umsatz
+ *   emptyText: "–"
+ * };
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export interface PivotConfigIf<T = any> {
+    /** The row levels, top first. Several levels form a hierarchy with subtotals. An empty list shows one total row. */
+    rowFields: RowGroupField<T>[];
+    /** The fields whose values become columns, top first. Several fields form a multi-row header. Default `[]` (totals only). */
+    columnFields?: RowGroupField<T>[];
+    /** The aggregated values (at least one): `"umsatz"` (sum) or {@link PivotValueIf}. With several values every column key gets one column per value. */
+    values: PivotValue<T>[];
+    /** Show the aggregates in the group rows (subtotals). Default true. */
+    subtotals?: boolean;
+    /**
+     * A total column behind every column group (e.g. "2026 Total" behind its quarters); the group gets a toggle and,
+     * when collapsed, shows only its total. Default: true with two or more column fields.
+     */
+    columnSubtotals?: boolean;
+    /** The total column(s) on the right: `"fixed"` (default, fixed on the right), `true` (last columns, scrolled) or `false`. */
+    totalColumn?: boolean | "fixed";
+    /** The total row in the footer. Default true. */
+    totalRow?: boolean;
+    /**
+     * The maximum number of column keys (of the lowest column level). More keys: the first ones are shown, a warning is
+     * logged and {@link PivotResult.truncated} is true – total column, subtotal columns and total row still count all rows.
+     * Default 1000.
+     */
+    maxColumns?: number;
+    /** Expanded row groups: `true` (default), `false`, open levels as a number (`0` = all closed) or a function per group. */
+    expanded?: RowGroupExpanded<T>;
+    /** The label of empty keys (`null`, `undefined`, `""`) – rows and columns. Default `"(empty)"`. */
+    emptyLabel?: string;
+    /** The text of a cell without data (the value stays `undefined`, not 0). Default `""`. */
+    emptyText?: string;
+    /** The word for totals: header of the total column, label of the total row, suffix of subtotal columns. Default `"Total"`. */
+    totalLabel?: string;
+}

package/lib/table/pivot/pivot-internals.d.ts

@@ -0,0 +1,13 @@
+import { PivotValue, PivotValueInfoIf } from './pivot-value.type.js';
+
+/** A value resolved for a pass over the rows. */
+export interface ResolvedPivotValue<T = any> extends PivotValueInfoIf {
+    /** undefined for `count` (the value does not matter) */
+    readonly getValue?: (row: T) => unknown;
+}
+/** The default maximum number of column keys. */
+export declare const DEFAULT_MAX_COLUMNS = 1000;
+/** The default word for totals. */
+export declare const DEFAULT_TOTAL_LABEL = "Total";
+/** Resolves the values of a pivot configuration: aggregator, getter, unique name, label. */
+export declare function resolvePivotValues<T>(values: PivotValue<T>[] | undefined): ResolvedPivotValue<T>[];

package/lib/table/pivot/pivot-layout.d.ts

@@ -0,0 +1,40 @@
+import { ColumnDefIf } from '../data/tablemodel/column/column-def.if.js';
+import { CellGroupIf } from '../data/tablemodel/cellgroup/cell-group.if.js';
+import { SizeIf } from '../data/common/size.if.js';
+import { RowGroup } from '../rowgroup/row-group.js';
+import { PivotConfigIf } from './pivot-config.if.js';
+import { PivotResult } from './pivot-result.js';
+import { PivotValueInfoIf } from './pivot-value.type.js';
+import { RowGroupField } from '../rowgroup/row-group-field.type.js';
+
+/** Columns, header groups and fixed right columns of a pivot. */
+export interface PivotLayout {
+    /** leading columns (row numbers, group column) + value columns + total columns */
+    columnDefs: ColumnDefIf[];
+    /** the header groups, one leaf per column in the same order */
+    cellGroups: CellGroupIf[];
+    /** the number of total columns fixed on the right */
+    fixedRightColumnCount: number;
+}
+export interface PivotLayoutOptions {
+    /** width of a value column (default 100 px) */
+    valueWidth?: SizeIf;
+    /** ids of collapsed column groups (kept when the layout is built again) */
+    closedIds?: ReadonlySet<string>;
+    /** the widths of existing columns by property (kept when the layout is built again) */
+    widths?: ReadonlyMap<string, SizeIf>;
+}
+/** The property of a value column: column path + value name. */
+export declare function pivotValueProperty(column: RowGroup, value: PivotValueInfoIf): string;
+/** The property of a subtotal column of a column group. */
+export declare function pivotSubtotalProperty(column: RowGroup, value: PivotValueInfoIf): string;
+/** The property of a total column. */
+export declare function pivotTotalProperty(value: PivotValueInfoIf): string;
+/** The default name of a field path in a header: the last part, first letter upper case ("address.city" → "City"). */
+export declare function humanizePath(path: string): string;
+/** The header of the group column of a pivot: the row field labels, e.g. "Region › Produkt" ("" without row fields). */
+export declare function pivotGroupHeaderLabel(rowFields: RowGroupField[]): string;
+/** True if the subtotal columns are on (default: two or more column fields). */
+export declare function hasColumnSubtotals(config: PivotConfigIf): boolean;
+/** Builds the columns and the grouped header of a pivot. */
+export declare function buildPivotLayout<T>(result: PivotResult<T>, config: PivotConfigIf<T>, leading: ColumnDefIf[], options?: PivotLayoutOptions): PivotLayout;

package/lib/table/pivot/pivot-result.d.ts

@@ -0,0 +1,157 @@
+import { PivotConfigIf } from './pivot-config.if.js';
+import { RowGroupIf } from '../rowgroup/row-group.if.js';
+import { RowGroup } from '../rowgroup/row-group.js';
+import { PivotValueInfoIf } from './pivot-value.type.js';
+
+/**
+ * The result of a pivot ({@link pivotRows}, {@link AreaModelPivot.getResult}): the row and column hierarchies and the
+ * aggregated value of every combination – cells, subtotals and totals. DOM-free; the table reads its cells from here.
+ *
+ * - `getValue(row, column)` – a cell; leave out `row` for the column total, `column` for the row total, both for the
+ *   grand total. Groups of higher levels give subtotals.
+ * - A combination without rows is `undefined` (not 0).
+ * - Every cell is computed from the rows (leaf cells) or by merging aggregation **states** – an average of a region is
+ *   the average of its rows, never the average of the product averages. Order of the merges: first along the columns
+ *   (column groups), then along the rows (row groups, total row) – children in key order. This matters for
+ *   `first`/`last` only: a row total adds its rows in source order, a column group merges its keys in key order, so
+ *   the two may differ. Keys cut off by `maxColumns` still count in subtotals and totals.
+ *
+ * @example
+ * const result = pivotRows(sales, { rowFields: ["region"], columnFields: ["monat"], values: ["umsatz"] });
+ * const nord = result.rowGroups[0];                      // Nord
+ * const jan = result.columnLeaves.find(c => c.key === "Jan");
+ * result.getValue(nord, jan);   // 150
+ * result.getValue(nord);        // 270 – the row total
+ * result.getValue(undefined, jan);   // 230 – the column total
+ * result.getValue();            // 450
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class PivotResult<T = any> {
+    /** @internal the source rows */
+    readonly source: ArrayLike<T>;
+    /** The row groups of the top level (with sub-groups); empty without row fields. */
+    readonly rowGroups: RowGroup<T>[];
+    /** The column groups of the top level (with sub-groups); empty without column fields. */
+    readonly columnGroups: RowGroup<T>[];
+    /** The shown column keys of the lowest level in display order – at most {@link PivotConfigIf.maxColumns}. */
+    readonly columnLeaves: RowGroup<T>[];
+    /** The values (name, label, aggregator, format). */
+    readonly values: readonly PivotValueInfoIf[];
+    /** True if there were more column keys than {@link PivotConfigIf.maxColumns} (the rest is not shown as columns). */
+    readonly truncated: boolean;
+    /** the lowest column key (index into allColumnLeaves) of every source row, -1: no column fields */
+    private readonly columnLeafOf;
+    /** all column keys of the lowest level, also the ones cut off by maxColumns (they count in subtotals) */
+    private readonly allColumnLeaves;
+    /** shown column groups (all levels) */
+    private readonly shownColumns;
+    /** non-leaf column groups (shown or not), deepest first */
+    private readonly columnParentsPostOrder;
+    /** non-leaf row groups, deepest first */
+    private readonly rowParentsPostOrder;
+    /** row leaves in display order */
+    private readonly rowLeaves;
+    private cells;
+    /** the values with their getters */
+    private readonly resolved;
+    private accept?;
+    /**
+     * Groups the rows by the row and column fields and aggregates the values. Use {@link pivotRows}.
+     *
+     * @param {ArrayLike<T>} source - the rows (not changed)
+     * @param {PivotConfigIf<T>} config - fields and values
+     * @param {(sourceIndex: number) => boolean} [accept] - a filter: only rows it accepts count
+     */
+    constructor(
+    /** @internal the source rows */
+    source: ArrayLike<T>, config: PivotConfigIf<T>, accept?: (sourceIndex: number) => boolean);
+    /**
+     * Computes all cells again (same keys) – after a filter change or changed values.
+     *
+     * @param {(sourceIndex: number) => boolean} [accept] - a filter: only rows it accepts count
+     *
+     * @example
+     * result.compute(i => sales[i].monat === "Jan");
+     * result.getValue();   // 230
+     */
+    compute(accept?: (sourceIndex: number) => boolean): void;
+    /**
+     * The aggregated value of a cell, a subtotal or a total.
+     *
+     * @param {RowGroupIf<T>} [row] - a row group (any level); undefined = all rows (column totals)
+     * @param {RowGroupIf<T>} [column] - a column key or column group (any level); undefined = all columns (row totals)
+     * @param {number | string} [value=0] - the index or name of the value
+     * @returns {unknown} the result, `undefined` if no row has this combination
+     *
+     * @example
+     * result.getValue(result.rowGroups[0], undefined, "sum(umsatz)");   // the total of the first row group
+     */
+    getValue(row?: RowGroupIf<T>, column?: RowGroupIf<T>, value?: number | string): unknown;
+    /**
+     * The number of rows of a cell, a subtotal or a total (after the filter).
+     *
+     * @param {RowGroupIf<T>} [row] - a row group; undefined = all rows
+     * @param {RowGroupIf<T>} [column] - a column key or group; undefined = all columns
+     * @returns {number} the row count, 0 for a combination without rows
+     *
+     * @example
+     * result.getCount(result.rowGroups[0]);   // 3 – the rows of Nord
+     */
+    getCount(row?: RowGroupIf<T>, column?: RowGroupIf<T>): number;
+    /**
+     * The rows behind a cell (drill-down), after the filter, in source order.
+     *
+     * @param {RowGroupIf<T>} [row] - a row group; undefined = all rows
+     * @param {RowGroupIf<T>} [column] - a column key or group; undefined = all columns
+     * @returns {T[]} a new array
+     *
+     * @example
+     * result.getSourceRows(nord, jan).map(s => s.umsatz);   // [100, 50]
+     */
+    getSourceRows(row?: RowGroupIf<T>, column?: RowGroupIf<T>): T[];
+    /**
+     * True if a column group is shown – false for groups whose keys were all cut off by `maxColumns`.
+     *
+     * @param {RowGroupIf<T>} column - a column group
+     * @returns {boolean} true if it has at least one shown column key
+     */
+    isColumnShown(column: RowGroupIf<T>): boolean;
+    /** @internal the index of a value (by index or name), -1 if unknown */
+    valueIndex(value: number | string): number;
+    private cell;
+    private newCell;
+    /** One pass over the rows of a row leaf: the cells per column key and the row total, then the column groups. */
+    private leafCells;
+    private mergeInto;
+    private mergeMap;
+}
+/**
+ * Pivots rows: groups them by the row fields and by the column fields and aggregates the values of every combination,
+ * with subtotals and totals – the engine behind {@link PivotFactory} (DOM-free, also usable without a table). One pass
+ * over the rows; empty combinations are `undefined`, averages are computed from sum and count.
+ *
+ * @param {ArrayLike<T>} rows - the rows (not changed)
+ * @param {PivotConfigIf<T>} config - row fields, column fields, values (see {@link PivotConfigIf})
+ * @param {(sourceIndex: number) => boolean} [accept] - a filter: only rows it accepts count (index into `rows`)
+ * @returns {PivotResult<T>} the hierarchies and the values
+ *
+ * @example
+ * // case 1: regions × months, sum of umsatz
+ * const result = pivotRows(sales, { rowFields: ["region"], columnFields: ["monat"], values: ["umsatz"] });
+ * result.rowGroups.map(r => `${r.label}: ${result.getValue(r)}`);   // ["Nord: 270", "Süd: 180"]
+ * result.getValue();                                                // 450
+ *
+ * @example
+ * // case 3: the average of a column total is the average of its rows
+ * const avg = pivotRows(sales, { rowFields: ["region"], columnFields: ["monat"],
+ *   values: [{ value: "umsatz", aggregator: "avg" }] });
+ * const jan = avg.columnLeaves.find(c => c.key === "Jan");
+ * avg.getValue(undefined, jan);   // 76.666… (230 / 3) – not 77.5, the mean of 75 and 80
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare function pivotRows<T = any>(rows: ArrayLike<T>, config: PivotConfigIf<T>, accept?: (sourceIndex: number) => boolean): PivotResult<T>;