@guiexpert/table 1.1.93 → 1.1.96

package/lib/table/data/tablemodel/areamodel/area-model-pivot-footer.d.ts

@@ -0,0 +1,47 @@
+import { AreaModel } from './area-model.js';
+import { HasDefaultRowHeightIf } from './has-default-row-height-if.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { AreaModelPivot } from './area-model-pivot.js';
+
+/**
+ * The total row of a pivot table: the label `"Total"` in the group column and the column totals (cells, subtotals,
+ * grand total) of the {@link AreaModelPivot}. The totals come from the source rows (merged states), never from the
+ * displayed rows – an average stays the average of all rows. Created by {@link PivotFactory.createTableModel}
+ * (`totalRow: false` → no row).
+ *
+ * @example
+ * const footer = tableModel.getAreaModel("footer") as AreaModelPivotFooter;
+ * footer.getValueAt(0, pivotModel.getPivotBody().getColumnIndex([]));   // 450 – the grand total
+ *
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class AreaModelPivotFooter<T = any> extends AreaModel implements HasDefaultRowHeightIf {
+    private readonly body;
+    defaultRowHeight: number;
+    /** Marker (works across copies of the core). */
+    readonly type = "AreaModelPivotFooter";
+    private readonly textRenderer;
+    /**
+     * @param {AreaModelPivot<T>} body - the pivot body (its columns and totals)
+     * @param {number} [defaultRowHeight=34] - row height in px
+     */
+    constructor(body: AreaModelPivot<T>, defaultRowHeight?: number);
+    /** 1 – or 0 with `totalRow: false` or without row fields (the body shows the total then). */
+    getRowCount(): number;
+    getRowHeight(_rowIndex: number): number;
+    getConstantRowHeight(): number | undefined;
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    getTextValueAt(rowIndex: number, columnIndex: number): string;
+    getCellRenderer(_rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+    /**
+     * True for the label cell ("Total") – the table gives it `role="rowheader"`.
+     *
+     * @param {number} rowIndex - footer row
+     * @param {number} columnIndex - column index
+     * @returns {boolean} true for the group column of the total row
+     */
+    isRowHeaderCell(rowIndex: number, columnIndex: number): boolean;
+    private isLabelColumn;
+}

package/lib/table/data/tablemodel/areamodel/area-model-pivot.d.ts

@@ -0,0 +1,281 @@
+import { AreaModelTree } from './area-model-tree.js';
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+import { ColumnDefIf } from '../column/column-def.if.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { FilterFunction } from '../../common/filter-function.js';
+import { SortItem } from '../../common/sort-item.js';
+import { RowGroupIf } from '../../../rowgroup/row-group.if.js';
+import { PivotConfigIf } from '../../../pivot/pivot-config.if.js';
+import { PivotColumnInfoIf } from '../../../pivot/pivot-column-info.if.js';
+import { PivotResult } from '../../../pivot/pivot-result.js';
+import { RowGroupColumnOptionsIf } from '../../../rowgroup/row-group-column-options.if.js';
+
+/**
+ * The body of a pivot table: one row per row group (a tree for several row fields, with subtotals in the group rows),
+ * one column per column key × value, plus subtotal and total columns. Created by {@link PivotFactory.createTableModel}
+ * – the factory also builds the grouped header and the total row.
+ *
+ * It is a tree ({@link AreaModelTree}, `isAreaModelTree` is true): rows are tree rows with a {@link RowGroupIf} as
+ * `data`; expanding, `tableApi.expandAll()`, keyboard, screen reader attributes and remembering expanded rows work as
+ * in a tree table. The cells come from a {@link PivotResult} ({@link getResult}).
+ *
+ * - **Filter**: `externalFilterFunction` gets your **source objects** (as in a flat table and a row grouping) – it
+ *   filters before the aggregation; all cells and totals follow. Rows without a matching source row disappear; the
+ *   columns stay (they come from all rows).
+ * - **Sorting**: by a value column → the rows of every level by that value (empty cells last); by the group column →
+ *   by key. `tableApi.sort(fn)` compares two {@link RowGroupIf}.
+ * - Cells are not editable. Changed source data: {@link TableApi.setPivotConfig} with new rows or `tableApi.repaint()` (same
+ *   keys), new keys or fields: {@link TableApi.setPivotConfig}.
+ *
+ * @example
+ * const tableModel = PivotFactory.createTableModel<Sale>({
+ *   rows: sales, rowFields: ["region"], columnFields: ["monat"], values: ["umsatz"]
+ * });
+ * const pivotBody = tableModel.getPivotBody();
+ * pivotBody.getValueAt(0, pivotBody.getColumnIndex(["Jan"]));   // 150 – Nord, Jan
+ *
+ * @see Training: [Pivot tables](https://gui.expert/training/pivot-tables/)
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Pivot
+ */
+export declare class AreaModelPivot<T = any> extends AreaModelTree<any> {
+    /** Marker for {@link isAreaModelPivot} (works across copies of the core). `type` stays `"AreaModelTree"`. */
+    readonly kind = "AreaModelPivot";
+    private config;
+    private sourceRows;
+    private result;
+    private rowFields;
+    private groupColumnOptions;
+    private readonly textRenderer;
+    private infoByProperty;
+    private userFilter?;
+    private accepted?;
+    private dirty;
+    private builds;
+    /**
+     * @param {T[]} rows - the source rows (not changed)
+     * @param {PivotConfigIf<T>} config - row fields, column fields, values
+     * @param {Partial<RowGroupColumnOptionsIf<T>>} [groupColumn] - label options of the group column (`showCount`, `label`)
+     * @param {number} [defaultRowHeight=34] - row height in px
+     */
+    constructor(rows: T[], config: PivotConfigIf<T>, groupColumn?: Partial<RowGroupColumnOptionsIf<T>>, defaultRowHeight?: number);
+    /**
+     * The current configuration.
+     *
+     * @returns {PivotConfigIf<T>} a copy
+     *
+     * @example
+     * pivotBody.getConfig().columnFields;   // ["monat"]
+     */
+    getConfig(): PivotConfigIf<T>;
+    /**
+     * The pivot: row and column hierarchies and all values (also subtotals and totals) – for drill-down, own
+     * evaluations or a chart next to the table.
+     *
+     * @returns {PivotResult<T>} the result (do not modify)
+     *
+     * @example
+     * const result = pivotBody.getResult();
+     * result.columnLeaves.map(c => c.label);   // ["Jan", "Feb"]
+     * result.getValue();                       // 450
+     */
+    getResult(): PivotResult<T>;
+    /**
+     * The rows the pivot is built from.
+     *
+     * @returns {T[]} the source rows (do not modify the array – use `tableApi.setPivotConfig({}, rows)`)
+     *
+     * @example
+     * pivotBody.getSourceRows().length;   // 6
+     */
+    getSourceRows(): T[];
+    /**
+     * Counts how often the pivot was built (start, new configuration, new rows).
+     *
+     * @returns {number} the number of builds
+     *
+     * @example
+     * const before = pivotBody.getBuildCount();
+     */
+    getBuildCount(): number;
+    /**
+     * Builds the pivot again (keys, rows) – {@link PivotTableModel.setPivotConfig} calls it, followed
+     * by the new columns ({@link setColumnDefs}). Expanded rows whose path stays keep their state; the filter stays, the
+     * sorting is reset.
+     *
+     * @param {PivotConfigIf<T>} config - the configuration
+     * @param {T[]} [rows] - new source rows (default: the current ones)
+     * @internal
+     */
+    configure(config: PivotConfigIf<T>, rows?: T[]): void;
+    /**
+     * Sets the columns (group column, value columns) after a new layout. @internal
+     *
+     * @param {ColumnDefIf[]} columnDefs - all columns of the table
+     */
+    setColumnDefs(columnDefs: ColumnDefIf[]): void;
+    /**
+     * The property of a column (follows moved columns).
+     *
+     * @param {number} columnIndex - column index
+     * @returns {string | undefined} the property, e.g. {@link RowGroupColumnDef.PROPERTY} for the group column
+     *
+     * @example
+     * pivotBody.getPropertyAt(0);   // "RowGroupColumn"
+     */
+    getPropertyAt(columnIndex: number): string | undefined;
+    /**
+     * The row group of a displayed row.
+     *
+     * @param {number} rowIndex - index of the displayed body row
+     * @returns {RowGroupIf<T> | undefined} the group, undefined for the total row of a pivot without row fields
+     *
+     * @example
+     * pivotBody.getRowGroup(0)?.path;   // ["Nord"]
+     */
+    getRowGroup(rowIndex: number): RowGroupIf<T> | undefined;
+    /**
+     * What a column shows: a column key, a subtotal or a total, and which value.
+     *
+     * @param {number} columnIndex - column index
+     * @returns {PivotColumnInfoIf | undefined} undefined for the group column (and row numbers)
+     *
+     * @example
+     * pivotBody.getColumnInfo(1)?.column?.label;   // "Jan"
+     */
+    getColumnInfo(columnIndex: number): PivotColumnInfoIf | undefined;
+    /**
+     * The property of a value column – for `tableApi.getColumnIndex()`, `sortByColumn()`, `setColumnWidth()` …
+     *
+     * @param {unknown[]} columnPath - the column keys from the top column field down, e.g. `[2026, 1]`; `[]` = the total column
+     * @param {number | string} [value=0] - the index or name of the value
+     * @returns {string | undefined} the property, undefined if there is no such column
+     *
+     * @example
+     * tableApi.sortByColumn(pivotBody.getColumnProperty([])!, "desc");   // rows by their total, largest first
+     */
+    getColumnProperty(columnPath: unknown[], value?: number | string): string | undefined;
+    /**
+     * The index of a value column (see {@link getColumnProperty}).
+     *
+     * @param {unknown[]} columnPath - the column keys, `[]` = the total column
+     * @param {number | string} [value=0] - the index or name of the value
+     * @returns {number} the column index or -1
+     *
+     * @example
+     * pivotBody.getColumnIndex(["Jan"]);   // 1
+     */
+    getColumnIndex(columnPath: unknown[], value?: number | string): number;
+    /**
+     * The source rows behind a cell (drill-down): the rows of its row group and column key that the filter keeps.
+     *
+     * @param {number} rowIndex - index of the displayed body row
+     * @param {number} columnIndex - column index (the group column: all rows of the row group)
+     * @returns {T[]} a new array in source order
+     *
+     * @example
+     * pivotBody.getCellSourceRows(0, 1).map(s => s.umsatz);   // [100, 50] – Nord, Jan
+     */
+    getCellSourceRows(rowIndex: number, columnIndex: number): T[];
+    getValueAt(rowIndex: number, columnIndex: number): any;
+    /**
+     * The value of a pivot cell as shown: the aggregate, or with „Show values as“ ({@link PivotValueIf.showValuesAs})
+     * its share of the row total, column total, grand total or parent row.
+     *
+     * @param {RowGroupIf<T> | undefined} group - the row group; `undefined` = all rows (the total row)
+     * @param {PivotColumnInfoIf} info - the column ({@link getColumnInfo})
+     * @returns {unknown} the shown value, `undefined` for an empty cell
+     *
+     * @example
+     * const body = (tableModel as PivotTableModel).getPivotBody();
+     * body.getShownValue(body.getRowGroup(0), body.getColumnInfo(2)!);   // 0.4 – 40 % of the row
+     *
+     * @since 1.1.95
+     */
+    getShownValue(group: RowGroupIf<T> | undefined, info: PivotColumnInfoIf): unknown;
+    /**
+     * Row drag: `false` – the table does not move rows of a pivot table itself (pivot rows are aggregates). With
+     * `rowDragOptions.managed: false` the app gets the events and decides.
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    canMoveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
+    /**
+     * Row drag: does nothing (see {@link canMoveRows}).
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    moveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
+    getTextValueAt(rowIndex: number, columnIndex: number): string;
+    /** Value columns: the {@link AggregateCellRenderer} (text node); the group column: none (label as text). */
+    getCellRenderer(_rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+    /**
+     * True for the label cell of a row (the table gives it `role="rowheader"`).
+     *
+     * @param {number} rowIndex - index of the displayed body row
+     * @param {number} columnIndex - column index
+     * @returns {boolean} true for the group column
+     */
+    isRowHeaderCell(rowIndex: number, columnIndex: number): boolean;
+    /** Pivot cells are computed – not editable. */
+    isEditable(_rowIndex: number, _columnIndex: number): boolean;
+    /** Pivot cells are computed – `setValue` does nothing (`false`). */
+    setValue(_rowIndex: number, _columnIndex: number, _value: any): boolean;
+    /**
+     * Filters the **source rows** before the aggregation: `predictFn` gets your objects (as in a flat table), index and
+     * array of the source rows. All cells and totals follow; rows without a matching source row disappear. Usually
+     * called by `tableApi.externalFilterChanged()` with `tableOptions.externalFilterFunction`.
+     *
+     * @param {FilterFunction<S>} predictFn - returns a truthy value for the rows to count
+     *
+     * @example
+     * tableOptions.externalFilterFunction = (sale: Sale) => sale.produkt === "A";
+     * tableApi.externalFilterChanged();   // Nord: Jan 100, Feb 120 · Süd: Jan 80, Feb 30
+     */
+    externalFilterChanged<S>(predictFn: FilterFunction<S>): void;
+    /**
+     * Sorts the rows of every level: by a value column by its values (empty cells last, in both directions), by the
+     * group column by key. A new pivot ({@link TableApi.setPivotConfig}) starts unsorted (the columns are different).
+     *
+     * @param {SortItem[]} sortItems - primary key first
+     * @returns {boolean} false for an empty list
+     *
+     * @example
+     * pivotBody.doSort([new SortItem(pivotBody.getColumnIndex([]), "desc")]);   // by the total, largest first
+     * tableApi.repaint();
+     */
+    doSort(sortItems: SortItem[]): boolean;
+    /**
+     * Sorts the rows of every level with your function – it gets two {@link RowGroupIf} (siblings).
+     *
+     * @param {(a: any, b: any) => number} compareFn - compares two row groups
+     *
+     * @example
+     * tableApi.sort((a: RowGroupIf, b: RowGroupIf) => b.count - a.count);   // most source rows first
+     */
+    sort(compareFn: (a: any, b: any) => number): void;
+    /**
+     * Computes the cells again on the next read – the table calls it after filter, sorting and `tableApi.repaint()`.
+     *
+     * @example
+     * sales[0].umsatz = 999;   // changed outside the table
+     * tableApi.repaint();      // calls invalidateDerivedValues() – all cells are computed again
+     */
+    invalidateDerivedValues(): void;
+    private isSubtotalSuppressed;
+    /** The label of a row in the group column. */
+    protected getGroupLabel(group: RowGroupIf<T>): string;
+    private ensureComputed;
+    /** The filter result per source row (1 = counted). */
+    private acceptedBy;
+    private createRowComparator;
+    /** (Re)builds the pivot and the tree rows; keeps the expanded state of known row groups and the filter (a new pivot is unsorted). */
+    private build;
+    private createRow;
+    private isExpandedByDefault;
+}

package/lib/table/data/tablemodel/areamodel/area-model-row-groups.d.ts

@@ -0,0 +1,336 @@
+import { AreaModelTree } from './area-model-tree.js';
+import { RowDropTargetIf } from '../../../row-drag/row-drop-target.if.js';
+import { TreeRowIf } from '../../common/tree-row-if.js';
+import { ColumnDefIf } from '../column/column-def.if.js';
+import { CellRendererIf } from '../../../renderer/cell-render.if.js';
+import { FilterFunction } from '../../common/filter-function.js';
+import { SortItem } from '../../common/sort-item.js';
+import { DerivedValuesChangeIf } from './derived-values-change.if.js';
+import { RowGroupField } from '../../../rowgroup/row-group-field.type.js';
+import { RowGroupModelOptionsIf } from '../../../rowgroup/row-group-model-options.if.js';
+import { RowGroup } from '../../../rowgroup/row-group.js';
+
+/**
+ * The body of a row grouping: flat rows grouped by one or more levels, each group a row with an arrow, a label
+ * (`"Nord (3)"`) and aggregates per column (sum, average, …); below it the sub-groups or the original rows. Usually
+ * created by {@link RowGroupFactory.createTableModel}, which also adds the group column, hides the grouped columns and
+ * adds a total row.
+ *
+ * It is a tree ({@link AreaModelTree}, `isAreaModelTree` is true): group rows are {@link TreeRowIf tree rows} with a
+ * {@link RowGroupIf} as `data`, detail rows hold your objects. Expanding, `tableApi.expandAll()`, keyboard, screen
+ * reader attributes and remembering expanded groups (`autoRestoreOptions`) work as in a tree table.
+ *
+ * - **Filter**: `externalFilterFunction` gets your object (as in a flat table) – never a group. Groups without a match
+ *   disappear; aggregates and counts follow the filter.
+ * - **Sorting**: by an aggregated column → groups by aggregate, rows by value; by the group column → groups by key;
+ *   `tableApi.sort(fn)` sorts the rows inside their groups with `fn(a, b)` on your objects.
+ * - **Editing**: group rows are not editable. A changed value recomputes only the groups of that row; a changed
+ *   grouped value moves the row to its new group.
+ * - **Regrouping**: {@link TableApi.setRowGroupBy} (or {@link setGroupBy} + `tableApi.repaintHard()`) – expanded
+ *   groups, filter, sorting and checked rows stay.
+ * - Aggregates are computed when a group row is read after a change – once, not per repaint or scroll frame.
+ *
+ * @example
+ * const tableModel = RowGroupFactory.createTableModel<Sale>({
+ *   rows: sales, columnDefs, groupBy: ["region", "produkt"], aggregations: { umsatz: "sum" }
+ * });
+ * const body = tableModel.getBodyModel() as AreaModelRowGroups<Sale>;
+ * body.getGroups().map(g => g.results.umsatz);   // [270, 180]
+ *
+ * @see Training: [Row grouping](https://gui.expert/training/row-grouping/)
+ *
+ * @typeParam T - the row type
+ * @since 1.1.94
+ * @category Row grouping
+ */
+export declare class AreaModelRowGroups<T = any> extends AreaModelTree<any> {
+    /** Marker for {@link isAreaModelRowGroups} (works across copies of the core). `type` stays `"AreaModelTree"`. */
+    readonly kind = "AreaModelRowGroups";
+    /** The options (groupBy as set by {@link setGroupBy}). */
+    readonly options: RowGroupModelOptionsIf<T>;
+    /** Properties of the columns the factory hid for the current grouping. @internal */
+    hiddenColumnProperties: string[];
+    private sourceRows;
+    private fields;
+    private groups;
+    private readonly specs;
+    private readonly specByKey;
+    private readonly textRenderer;
+    /** the tree row of every group by id */
+    private groupRowById;
+    /** the tree row of every source row by source index */
+    private detailRows;
+    /** the filter of the user (gets the objects) and its result per source index */
+    private userFilter?;
+    private accepted?;
+    private allDirty;
+    private readonly dirtyLeaves;
+    private totals;
+    private lastSort?;
+    private batchDepth;
+    private regroupPending;
+    private builds;
+    /**
+     * @param {T[]} rows - the rows (not changed by the model)
+     * @param {ColumnDefIf[]} columnDefs - the columns of the table, usually with a {@link RowGroupColumnDef}
+     * @param {RowGroupModelOptionsIf<T>} options - levels, aggregations, expanded state …
+     * @param {number} [defaultRowHeight=34] - row height in px
+     */
+    constructor(rows: T[], columnDefs: ColumnDefIf[], options: RowGroupModelOptionsIf<T>, defaultRowHeight?: number);
+    /**
+     * The rows the groups are built from.
+     *
+     * @returns {T[]} the source rows (do not modify the array – use {@link setRows})
+     *
+     * @example
+     * const all = body.getSourceRows().length;
+     */
+    getSourceRows(): T[];
+    /**
+     * Replaces the rows and groups them again (expanded groups, filter and sorting stay). Repaint with
+     * `tableApi.repaintHard()` – the row count changes.
+     *
+     * @param {T[]} rows - the new rows
+     *
+     * @example
+     * body.setRows(await loadSales());
+     * tableApi.repaintHard();
+     */
+    setRows(rows: T[]): void;
+    /**
+     * The current levels.
+     *
+     * @returns {RowGroupField<T>[]} a copy of the levels
+     *
+     * @example
+     * body.getGroupBy();   // ["region", "produkt"]
+     */
+    getGroupBy(): RowGroupField<T>[];
+    /**
+     * Groups the rows by other levels. Expanded groups whose path stays keep their state; filter, sorting and checked
+     * rows stay. An empty list shows the rows without groups. Prefer {@link TableApi.setRowGroupBy}: it also shows and
+     * hides the grouped columns and repaints.
+     *
+     * @param {RowGroupField<T>[]} groupBy - the new levels, top first
+     *
+     * @example
+     * body.setGroupBy(["produkt"]);
+     * tableApi.repaintHard();
+     */
+    setGroupBy(groupBy: RowGroupField<T>[]): void;
+    /**
+     * Builds the groups again from the current rows – after grouped values were changed outside the table (inside the
+     * table, editing a grouped value moves the row by itself). Repaint with `tableApi.repaintHard()`.
+     *
+     * @example
+     * sales[0].region = "Süd";   // a live update of a grouped value
+     * body.regroup();
+     * tableApi.repaintHard();
+     */
+    regroup(): void;
+    /**
+     * The groups of the top level (with sub-groups, counts and aggregates).
+     *
+     * @returns {RowGroup<T>[]} the groups in display order (do not modify)
+     *
+     * @example
+     * body.getGroups().map(g => `${g.label}: ${g.results.umsatz}`);   // ["Nord: 270", "Süd: 180"]
+     */
+    getGroups(): RowGroup<T>[];
+    /**
+     * The group with the given keys.
+     *
+     * @param {unknown[]} path - the keys from the top level down, e.g. `["Nord", "A"]`
+     * @returns {RowGroup<T> | undefined} the group, undefined if there is none
+     *
+     * @example
+     * body.findGroup(["Nord", "A"])?.results.umsatz;   // 220
+     */
+    findGroup(path: unknown[]): RowGroup<T> | undefined;
+    /**
+     * The group of a displayed row.
+     *
+     * @param {number} rowIndex - index of the displayed body row
+     * @returns {RowGroup<T> | undefined} the group of a group row, undefined for a detail row
+     *
+     * @example
+     * const group = body.getRowGroup(0);   // the first group (if the first row is a group row)
+     */
+    getRowGroup(rowIndex: number): RowGroup<T> | undefined;
+    /**
+     * Your object of a displayed detail row.
+     *
+     * @param {number} rowIndex - index of the displayed body row
+     * @returns {T | undefined} the object, undefined for a group row
+     *
+     * @example
+     * const sale = body.getDetailRow(1);
+     */
+    getDetailRow(rowIndex: number): T | undefined;
+    /**
+     * True if the displayed row is a group row.
+     *
+     * @param {number} rowIndex - index of the displayed body row
+     * @returns {boolean} true for a group row
+     *
+     * @example
+     * const bold = body.isGroupRowIndex(rowIndex);
+     */
+    isGroupRowIndex(rowIndex: number): boolean;
+    /**
+     * The aggregates over all rows the filter keeps (the same as the total row).
+     *
+     * @returns {Record<string, unknown>} key → result
+     *
+     * @example
+     * body.getTotals().umsatz;   // 450
+     */
+    getTotals(): Record<string, unknown>;
+    /**
+     * The checked objects (detail rows) – with a checkbox column or `showCheckboxWihoutExtraColumn`.
+     *
+     * @returns {T[]} the checked objects in source order
+     *
+     * @example
+     * const selected = body.getCheckedRows();
+     */
+    getCheckedRows(): T[];
+    /**
+     * Expands the groups above a level and collapses the others: `0` collapses all, `1` opens the top level, a large
+     * number opens all. Repaint with `tableApi.repaintHard()`.
+     *
+     * @param {number} level - the number of open levels
+     *
+     * @example
+     * body.expandToLevel(1);
+     * tableApi.repaintHard();
+     */
+    expandToLevel(level: number): void;
+    /**
+     * Counts how often the groups were built (start, {@link setRows}, {@link setGroupBy}, {@link regroup}, an edited
+     * grouped value). The table compares it before and after an edit to know that the rows moved (→ hard repaint).
+     *
+     * @returns {number} the number of builds
+     *
+     * @example
+     * const before = body.getBuildCount();
+     * body.setValue(1, 1, "Ost");
+     * const moved = body.getBuildCount() !== before;   // true: "region" is grouped
+     */
+    getBuildCount(): number;
+    /**
+     * Runs several `setValue` calls as one change: a row whose grouped value changes moves only at the end, so the row
+     * indices of the other calls stay valid (`tableApi.updateCells()` uses it).
+     *
+     * @param {() => void} fn - the changes
+     * @returns {boolean} true if the groups were built again at the end
+     *
+     * @example
+     * const moved = body.batch(() => {
+     *   body.setValue(1, 1, "Süd");      // region – moves the row
+     *   body.setValue(2, 4, 999);        // still the row that was at index 2
+     * });
+     */
+    batch(fn: () => void): boolean;
+    /** Group rows: the label resp. the aggregate of the column; detail rows: the value of the row (calculated or path). */
+    protected getRawValueOfRow(row: TreeRowIf<any>, property: string): any;
+    /**
+     * Row drag: `false` – the table does not move rows of a grouped table itself (group rows are built from the data, a change of group means changing data). With
+     * `rowDragOptions.managed: false` the app gets the events and decides.
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    canMoveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
+    /**
+     * Row drag: does nothing (see {@link canMoveRows}).
+     *
+     * @returns {boolean} always false
+     * @since 1.1.95
+     */
+    moveRows(_rowIndices: number[], _target: RowDropTargetIf): boolean;
+    getTextValueAt(rowIndex: number, columnIndex: number): string;
+    /** Group rows: the {@link AggregateCellRenderer} for aggregates, no renderer otherwise; detail rows: the column's. */
+    getCellRenderer(rowIndex: number, columnIndex: number): CellRendererIf | undefined;
+    getCustomClassesAt(rowIndex: number, columnIndex: number): string[];
+    /**
+     * True for the label cell of a group row (the table gives it `role="rowheader"`).
+     *
+     * @param {number} rowIndex - index of the displayed body row
+     * @param {number} columnIndex - column index
+     * @returns {boolean} true for the group label
+     */
+    isGroupLabelCell(rowIndex: number, columnIndex: number): boolean;
+    /** Group rows and the group column are not editable. */
+    isEditable(rowIndex: number, columnIndex: number): boolean;
+    /**
+     * Sets a value of a detail row (group rows: `false`). Only the groups of that row are computed again; if a grouped
+     * value changed, the row moves to its new group (the row count may change).
+     */
+    setValue(rowIndex: number, columnIndex: number, value: any): boolean;
+    /**
+     * Filters the rows: `predictFn` gets **your objects** (as in a flat table), index and array of the source rows –
+     * never a group. Groups without a matching row disappear (also below collapsed groups); counts and aggregates follow
+     * the filter. Usually called by `tableApi.externalFilterChanged()` with `tableOptions.externalFilterFunction`.
+     *
+     * @param {FilterFunction<S>} predictFn - returns a truthy value for the rows to show
+     *
+     * @example
+     * tableOptions.externalFilterFunction = (sale: Sale) => sale.monat === "Jan";
+     * tableApi.externalFilterChanged();   // Nord (2) 150 · Süd (1) 80
+     */
+    externalFilterChanged<S>(predictFn: FilterFunction<S>): void;
+    /**
+     * Sorts groups and rows (see the class description); the order is applied again after regrouping.
+     *
+     * @param {SortItem[]} sortItems - primary key first
+     * @returns {boolean} false for an empty list
+     *
+     * @example
+     * body.doSort([new SortItem(tableApi.getColumnIndex("umsatz"), "desc")]);   // groups by sum, rows by value
+     * tableApi.repaint();
+     */
+    doSort(sortItems: SortItem[]): boolean;
+    /**
+     * Sorts the rows inside their groups with your function – it gets your objects, as in a flat table. The groups keep
+     * their order. Used by `tableApi.sort(fn)`.
+     *
+     * @param {(a: any, b: any) => number} compareFn - compares two of your objects
+     *
+     * @example
+     * tableApi.sort((a: Sale, b: Sale) => b.umsatz - a.umsatz);
+     */
+    sort(compareFn: (a: any, b: any) => number): void;
+    /**
+     * Drops the computed aggregates; with `change` (an edit or `updateCells`) only those of the groups of the changed rows.
+     * The table calls it; the next read computes them again.
+     *
+     * @param {DerivedValuesChangeIf} [change] - the changed rows
+     *
+     * @example
+     * sales[0].umsatz = 999;        // changed outside the table
+     * tableApi.repaint();           // calls invalidateDerivedValues() – all groups are computed again
+     */
+    invalidateDerivedValues(change?: DerivedValuesChangeIf): void;
+    /** After sorting the tree rows: the groups (`getGroups()`, `children`) in display order. */
+    /** An aggregate over a calculated column (key or value = its property) uses the computed value. */
+    private withCalculatedValue;
+    /** A grouping level on a calculated column groups by the computed value. */
+    private withCalculatedKeys;
+    private syncGroupOrder;
+    /** The label of a group row in the group column. */
+    protected getGroupLabel(group: RowGroup<T>): string;
+    /** Computes what is missing: everything after a change of data/filter/grouping, otherwise the dirty paths. */
+    protected ensureAggregates(): void;
+    private markRowDirty;
+    private keysOf;
+    /** A comparator of two sibling rows for one sort column. */
+    private createRowComparator;
+    /**
+     * (Re)builds groups and tree rows from the source rows, keeps the expanded state of known groups, the checked
+     * detail rows, the filter and the sorting.
+     */
+    private build;
+    private createGroupRow;
+    private isExpandedByDefault;
+}