@masterteam/data-grid 0.0.0-stage → 0.0.2

package/types/masterteam-data-grid.d.ts

@@ -0,0 +1,3422 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Type, Signal, TemplateRef, ElementRef, ComponentRef, OutputRefSubscription, ApplicationRef } from '@angular/core';
+
+type GridIconName = 'sort-asc' | 'sort-desc' | 'sort-none' | 'reset' | 'expand' | 'collapse' | 'pdf' | 'export' | 'asc' | 'desc' | 'hide' | 'blocked' | 'pin' | 'columns' | 'chevron' | 'chevron-start' | 'check' | 'menu' | 'move' | 'left' | 'right' | 'close' | 'copy' | 'cut' | 'paste' | 'save' | 'tree-open' | 'tree-closed' | 'group' | 'csv' | 'excel' | 'search' | 'filter' | 'cancel' | 'small-down' | 'grip' | 'arrows' | 'tree-indeterminate' | 'aggregation' | 'pivot' | 'filter-add' | 'cross' | 'chevron-up' | 'chevron-down' | 'first' | 'previous' | 'next' | 'last' | 'chart' | 'maximize' | 'minimize' | 'chart-link' | 'chart-unlink' | 'chart-edit' | 'chevron-right' | 'eye-off' | 'minus' | 'values' | 'download' | 'link' | 'unlink' | 'settings' | 'chevron-left' | 'chevron-end' | 'filter-active' | 'filters-panel' | 'pin-left' | 'pin-right' | 'unpin' | 'autosize' | 'chart-bar' | 'chart-line' | 'chart-pie' | 'chart-area' | 'chart-scatter' | 'data' | 'format' | 'plus' | 'eye' | 'loading';
+/** Trusted application-owned SVG markup. Missing names retain the built-in DS stroke icon. */
+declare const MT_GRID_ICONS: InjectionToken<Partial<Record<GridIconName, string>>>;
+
+interface MtValueParams<T> {
+    readonly data: T;
+    readonly rowIndex: number;
+    readonly column: MtColumnDef<T>;
+    readonly value: unknown;
+}
+/** What a cell renderer, cell class rule or cell style callback receives. */
+interface MtCellRendererParams<T> extends MtValueParams<T> {
+    /** The value through the column's `valueFormatter` (or its text). */
+    readonly valueFormatted: string;
+    readonly node: MtRowNode<T>;
+    readonly api: MtGridApi<T>;
+    /** The column's `cellRendererParams`, merged in. */
+    readonly [extra: string]: unknown;
+}
+/** A function renderer: text (rendered as sanitised HTML), an element, or nothing for the plain text. */
+type MtCellRendererFn<T> = (params: MtCellRendererParams<T>) => string | HTMLElement | null | undefined;
+/** A component renderer declares `readonly params = input.required<MtCellRendererParams<T>>()`. */
+interface MtCellRendererComponent<T> {
+    readonly params: Signal<MtCellRendererParams<T>>;
+}
+/** A header component owns its label/controls; resizing and column dragging stay with the grid. */
+interface MtHeaderRendererParams<T> {
+    readonly column: MtColumnDef<T>;
+    readonly displayName: string;
+    readonly api: MtGridApi<T>;
+    readonly [extra: string]: unknown;
+}
+interface MtHeaderRendererComponent<T> {
+    readonly params: Signal<MtHeaderRendererParams<T>>;
+}
+/**
+ * Built-in renderers: `checkbox` (a read-only checkbox of a boolean value), `sparkline` (a
+ * line / area / column / bar of a number list, `cellRendererParams.sparklineOptions`),
+ * `animateShowChange` (the value with its ↑ / ↓ delta and a highlight on change) and
+ * `group` (the expand toggle of a master row — or a group row — before the value).
+ */
+type MtBuiltInCellRenderer = 'checkbox' | 'sparkline' | 'animateShowChange' | 'group';
+type MtCellRenderer<T> = MtBuiltInCellRenderer | MtCellRendererFn<T> | Type<MtCellRendererComponent<T>>;
+type MtSparklineType = 'line' | 'area' | 'column' | 'bar';
+interface MtSparklineOptions {
+    /** Default `line`. */
+    readonly type?: MtSparklineType;
+    /** The line / bar colour (default the focus blue). */
+    readonly stroke?: string;
+    readonly strokeWidth?: number;
+    /** The area fill (default the stroke at 25%). */
+    readonly fill?: string;
+    /** Space around the plot (default 3px). */
+    readonly padding?: number;
+    /** Widen the vertical domain. */
+    readonly min?: number;
+    readonly max?: number;
+    /** The nearest point's marker and tooltip while hovering (default true). */
+    readonly highlight?: boolean;
+    readonly tooltipFormatter?: (value: number, index: number) => string;
+}
+type MtCellClassParams<T> = MtCellRendererParams<T>;
+type MtCellClass<T> = string | readonly string[] | ((params: MtCellClassParams<T>) => string | readonly string[] | null | undefined);
+type MtCellClassRules<T> = Readonly<Record<string, (params: MtCellClassParams<T>) => boolean>>;
+type MtCellStyle<T> = Readonly<Record<string, string>> | ((params: MtCellClassParams<T>) => Readonly<Record<string, string>> | null | undefined);
+/** The nested grid of a detail row (the built-in detail renderer). */
+interface MtDetailGridOptions<D> {
+    readonly columnDefs: readonly MtColDef<D>[];
+    readonly getRowId?: (data: D) => string;
+    /** Default 42. */
+    readonly rowHeight?: number;
+    /** Default 48. */
+    readonly headerHeight?: number;
+}
+interface MtGetDetailRowDataParams<T, D> {
+    readonly data: T;
+    readonly node: MtRowNode<T>;
+    /** Hands the detail rows to the grid (synchronously or later). */
+    readonly successCallback: (rows: readonly D[]) => void;
+}
+/** `detailCellRendererParams`: the nested grid and its rows, plus anything a custom detail renderer reads. */
+interface MtDetailCellRendererParams<T, D = unknown> {
+    readonly detailGridOptions?: MtDetailGridOptions<D>;
+    readonly getDetailRowData?: (params: MtGetDetailRowDataParams<T, D>) => void;
+    readonly [extra: string]: unknown;
+}
+type MtCellEditorKind = 'text' | 'number' | 'select' | 'checkbox' | 'richSelect';
+/** How the rich select matches typed text: the start of a value, anywhere in it, or its letters in order. */
+type MtRichSelectSearchType = 'match' | 'matchAny' | 'fuzzy';
+interface MtCellEditorParams {
+    /** The select and rich select editors' options. */
+    readonly values?: readonly unknown[];
+    /** Rich select: the value area is a text field (typing searches; with `filterList` it filters the rows). */
+    readonly allowTyping?: boolean;
+    /** Rich select: typed text filters the rows (default: it moves the highlight to the first match). */
+    readonly filterList?: boolean;
+    /** Rich select: how typed text matches a row (default `fuzzy`). */
+    readonly searchType?: MtRichSelectSearchType;
+    /** Rich select: the matched letters of each row are marked. */
+    readonly highlightMatch?: boolean;
+    /** Rich select: the list's maximum height in px (default: the room under the cell inside the grid). */
+    readonly valueListMaxHeight?: number;
+    /** Rich select: the list's maximum width in px (default: the cell's width). */
+    readonly valueListMaxWidth?: number;
+    /** Rich select: the height of a list row in px (observed default 24). */
+    readonly cellHeight?: number;
+    /** Rich select: the text shown for a value (default `String(value)`). */
+    readonly formatValue?: (value: unknown) => string;
+    /** Rich select without `allowTyping`: the pause after which typed letters start a new search, in ms (default 300). */
+    readonly searchDebounceDelay?: number;
+    readonly [extra: string]: unknown;
+}
+interface MtValueSetterParams<T> {
+    readonly data: T;
+    readonly node: MtRowNode<T>;
+    readonly column: MtColumnDef<T>;
+    readonly colId: string;
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+}
+interface MtValueParserParams<T> {
+    readonly data: T;
+    readonly column: MtColumnDef<T>;
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+}
+/** Where a committed value came from. */
+type MtCellValueChangedSource = 'edit' | 'paste' | 'cut' | 'fill' | 'undo' | 'redo' | 'api';
+interface MtCellValueChangedEvent<T> {
+    readonly data: T;
+    readonly node: MtRowNode<T>;
+    readonly column: MtColumnDef<T>;
+    readonly colId: string;
+    readonly rowIndex: number;
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+    readonly source: MtCellValueChangedSource;
+}
+interface MtCellEditingStartedEvent<T> {
+    readonly data: T;
+    readonly node: MtRowNode<T>;
+    readonly column: MtColumnDef<T>;
+    readonly colId: string;
+    readonly rowIndex: number;
+    readonly value: unknown;
+}
+interface MtCellEditingStoppedEvent<T> extends MtCellEditingStartedEvent<T> {
+    readonly oldValue: unknown;
+    readonly newValue: unknown;
+    readonly valueChanged: boolean;
+}
+interface MtPasteEvent {
+    readonly source: 'ui' | 'api';
+}
+interface MtFillEvent {
+    /** Rows and columns written by the fill. */
+    readonly rows: number;
+    readonly columns: readonly string[];
+}
+interface MtStartEditingCellParams {
+    readonly rowIndex: number;
+    readonly colKey: string;
+    /** A key that starts the editor with its own value. */
+    readonly key?: string;
+}
+interface MtEditingCell {
+    readonly rowIndex: number;
+    readonly colId: string;
+    readonly rowId: string;
+}
+interface MtPaginationChangedEvent {
+    readonly newPage: boolean;
+    readonly newPageSize: boolean;
+    /** Zero-based. */
+    readonly currentPage: number;
+    readonly pageSize: number;
+    readonly totalPages: number;
+    readonly rowCount: number;
+}
+/** `rightAligned`: cells and header at the end; `numericColumn` is the same plus the numeric intent. */
+type MtColumnType = 'rightAligned' | 'numericColumn' | 'currency' | 'percent';
+/** Physical pinned side; `left` stays on the left in RTL like the reference. */
+type MtColumnPinned = 'left' | 'right' | null;
+/** One category identity of a record: a stable id, its localized label and an optional authored colour. */
+interface MtChartCategoryValue {
+    /** Stable identity (an option key, a user id); never a display label. */
+    readonly id: string;
+    readonly label: string;
+    /** Authored semantic colour (hex). Absent or null → the chart's stable palette mapping. */
+    readonly color?: string | null;
+}
+interface MtChartCategoryParams<T> {
+    readonly value: unknown;
+    readonly data: T;
+    readonly column: MtColumnDef<T>;
+}
+/**
+ * Typed category semantics for charts. Charts group records by `id`, show `label`
+ * and use `color`; a record with several values belongs to each of them once.
+ * Columns without this definition group by their formatted text.
+ */
+interface MtChartCategoryDef<T> {
+    readonly values: (params: MtChartCategoryParams<T>) => readonly MtChartCategoryValue[] | MtChartCategoryValue | null | undefined;
+    /** A record may carry several identities, so category totals can exceed the record count. */
+    readonly multiValue?: boolean;
+}
+interface MtColumnDef<T> {
+    /** Integrated chart role; omitted roles are inferred from raw cell values. */
+    readonly chartDataType?: MtChartDataType;
+    /** Identity, label and colour semantics for charting this column as a category. */
+    readonly chartCategory?: MtChartCategoryDef<T>;
+    /**
+     * Unit of a numeric series per record (a currency code, a percent sign). One
+     * consistent unit joins the series name ("Amount (SAR)"); mixed units leave
+     * the name alone and flag the series.
+     */
+    readonly chartUnit?: (params: MtChartCategoryParams<T>) => string | null | undefined;
+    readonly field?: Extract<keyof T, string>;
+    readonly colId?: string;
+    readonly headerName?: string;
+    readonly headerRenderer?: Type<MtHeaderRendererComponent<T>>;
+    readonly headerRendererParams?: Readonly<Record<string, unknown>>;
+    readonly width?: number;
+    readonly initialWidth?: number;
+    readonly minWidth?: number;
+    readonly maxWidth?: number;
+    /** Keep this column's width when fitting the grid (for fixed action/selection columns). */
+    readonly suppressSizeToFit?: boolean;
+    /** Stateful: `undefined` keeps the current visibility on a definition update. */
+    readonly hide?: boolean;
+    readonly initialHide?: boolean;
+    /** Stateful: `undefined` keeps the current pinned side; `null` unpins. */
+    readonly pinned?: MtColumnPinned;
+    readonly initialPinned?: 'left' | 'right';
+    readonly sortable?: boolean;
+    readonly resizable?: boolean;
+    /** Hides this header's menu button; Alt+ArrowDown and right-click still open the menu. */
+    readonly suppressHeaderMenuButton?: boolean;
+    readonly suppressHeaderFilterButton?: boolean;
+    readonly mainMenuItems?: readonly MtMainMenuItem<T>[] | ((params: MtGetMainMenuItemsParams<T>) => readonly MtMainMenuItem<T>[]);
+    readonly cellDataType?: 'text' | 'number' | 'boolean' | 'date' | 'currency' | 'percent';
+    /** Groups the rows by this column; several grouped columns nest in `rowGroupIndex` order. */
+    readonly rowGroup?: boolean;
+    readonly rowGroupIndex?: number | null;
+    /** Render the group cell here when groupDisplayType is custom. */
+    readonly showRowGroup?: boolean | string;
+    /** Populated on generated pivot results before processPivotResultColDef runs. */
+    readonly pivotKeys?: readonly (string | null)[];
+    readonly pivotValueColumn?: string;
+    /** Lets the column be grouped from the header menu ("Group by …") and the row group panel. */
+    readonly enableRowGroup?: boolean;
+    /** Aggregation shown on group rows: a built-in name, a name registered in `aggFuncs`, or a function. */
+    readonly aggFunc?: MtAggFuncName | string | MtAggFunc<T> | null;
+    /** Lets the column be dropped on the Columns tool panel's Values zone (and aggregated from there). */
+    readonly enableValue?: boolean;
+    /** The aggregation a Values drop applies (reference default `sum`). */
+    readonly defaultAggFunc?: MtAggFuncName | string;
+    /** The functions the Values chip offers; by default the built-ins in the reference's order. */
+    readonly allowedAggFuncs?: readonly string[];
+    /** Lets the column be dropped on the Column Labels zone (pivot mode). */
+    readonly enablePivot?: boolean;
+    /** Pivots by this column (a column label); several nest in `pivotIndex` order. */
+    readonly pivot?: boolean;
+    readonly pivotIndex?: number | null;
+    /** This column's context menu items; a list or a callback over the default items. Wins over `getContextMenuItems`. */
+    readonly contextMenuItems?: readonly MtContextMenuItem<T>[] | ((params: MtGetContextMenuItemsParams<T>) => readonly MtContextMenuItem<T>[]);
+    /**
+     * Keeps the column at a physical edge (`true` = `'left'`; in RTL the left edge is the
+     * logical end). It cannot be dragged or API-moved, and other columns cannot be moved
+     * across it (column-locks observations).
+     */
+    readonly lockPosition?: boolean | 'left' | 'right';
+    /** Blocks dragging this header; API moves still apply. */
+    readonly suppressMovable?: boolean;
+    /** Blocks pinning or unpinning by drag; API and state pinning still apply. */
+    readonly lockPinned?: boolean;
+    /** Blocks hiding or showing from the UI (drag out of the grid, Choose Columns); the API still applies. */
+    readonly lockVisible?: boolean;
+    /**
+     * Inside a column group: shown only while the group is open (`'open'`) or closed
+     * (`'closed'`); without it the column shows in both states.
+     */
+    readonly columnGroupShow?: MtColumnGroupShow;
+    readonly valueGetter?: (params: Omit<MtValueParams<T>, 'value'>) => unknown;
+    readonly valueFormatter?: (params: MtValueParams<T>) => string;
+    /**
+     * `rightAligned` / `numericColumn`: the cells and the header align to the end
+     * (`mt-grid-right-aligned-cell`, observed `ag-right-aligned-cell` on the currency columns).
+     */
+    readonly type?: MtColumnType | readonly MtColumnType[];
+    /**
+     * Renders the cell: a built-in (`checkbox`, `sparkline`, `animateShowChange`), a function
+     * returning text / HTML / an element, or a standalone component with a `params` input.
+     */
+    readonly cellRenderer?: MtCellRenderer<T>;
+    /** Optional group-key content. The grid retains its expander, count, keyboard and drag behavior. */
+    readonly groupValueRenderer?: MtCellRenderer<T>;
+    /** Extra parameters merged into the renderer's params (`sparklineOptions` for the sparkline). */
+    readonly cellRendererParams?: Readonly<Record<string, unknown>>;
+    /** Extra classes on the cell: a string, a list, or a callback per cell. */
+    readonly cellClass?: MtCellClass<T>;
+    /** Classes applied while their rule holds, re-evaluated when the value changes. */
+    readonly cellClassRules?: MtCellClassRules<T>;
+    /** Inline styles on the cell (an object or a callback per cell). */
+    readonly cellStyle?: MtCellStyle<T>;
+    /** The cell edits (double-click, Enter, F2, typing); a callback decides per cell. */
+    readonly editable?: boolean | ((params: MtCellRendererParams<T>) => boolean);
+    /** The editor: `text` / `number` (by the value's type by default), `select` (`cellEditorParams.values`), `checkbox`. */
+    readonly cellEditor?: MtCellEditorKind;
+    readonly cellEditorParams?: MtCellEditorParams;
+    /** Writes the committed value (returns whether it changed) instead of `data[field]`. */
+    readonly valueSetter?: (params: MtValueSetterParams<T>) => boolean;
+    /** Turns the editor's value into the stored value before it is written. */
+    readonly valueParser?: (params: MtValueParserParams<T>) => unknown;
+    /** Keeps paste and the fill handle off this column. */
+    readonly suppressPaste?: boolean;
+    readonly suppressFillHandle?: boolean;
+    readonly comparator?: (a: unknown, b: unknown, dataA: T, dataB: T) => number;
+    /**
+     * Column filter: `true` or `'text'` for the text filter, `'number'`, `'date'` (the value
+     * must be a `Date`). Without it the column has no filter button, no floating filter
+     * input and `setFilterModel` ignores it (filter-basics-observations.json).
+     */
+    readonly filter?: MtColumnFilter;
+    readonly filterValueGetter?: (params: Omit<MtValueParams<T>, 'value'>) => unknown;
+    readonly getQuickFilterText?: (params: Omit<MtValueParams<T>, 'value'> & {
+        value: unknown;
+    }) => string;
+    readonly excludeFromQuickFilter?: boolean;
+    readonly suppressFiltersToolPanel?: boolean;
+    /** Shows the column's input in the floating-filter row under the headers. */
+    readonly floatingFilter?: boolean;
+    readonly filterParams?: MtFilterParams;
+    /**
+     * Shows a row-drag handle at the start of this column's cells (a function decides per
+     * row). Dragging reports `rowDragEnter`/`rowDragMove`/`rowDragLeave`/`rowDragEnd`; with
+     * `rowDragManaged` the grid reorders its rows while dragging (selection-3 observations).
+     */
+    readonly rowDrag?: boolean | ((node: MtRowNode<T>) => boolean);
+    /** The drag ghost label; by default the dragged row's value in this column or `N rows`. */
+    readonly rowDragText?: (nodes: readonly MtRowNode<T>[]) => string;
+}
+/**
+ * A column group: its children (columns or nested groups) share a group header cell.
+ * Without a groupId the grid numbers groups in definition pre-order like the reference.
+ */
+interface MtColumnGroupDef<T> {
+    readonly groupId?: string;
+    readonly headerName?: string;
+    readonly children: readonly MtColDef<T>[];
+    /** Open state of a newly introduced group; a known group keeps its state on a definition update. */
+    readonly openByDefault?: boolean;
+    /** Inside a parent group: shown only while the parent is open or closed. */
+    readonly columnGroupShow?: MtColumnGroupShow;
+    /**
+     * Keeps the group's columns together: a dragged child stays inside the group, a column
+     * dragged into it lands at its edge, and `moveColumns` calls that would split it do
+     * nothing.
+     */
+    readonly marryChildren?: boolean;
+}
+/**
+ * When a column or child group shows inside its group. A group can be opened and closed
+ * (expand icon, Enter) only when its open and closed states show different children.
+ */
+type MtColumnGroupShow = 'open' | 'closed';
+/** A columnDefs entry: a column or a column group. */
+type MtColDef<T> = MtColumnDef<T> | MtColumnGroupDef<T>;
+interface MtRowNode<T> {
+    readonly id: string;
+    /** The row's data; absent (`undefined`) on grouping's group and total rows and on tree filler rows; a tree row with children keeps it. */
+    readonly data: T;
+    /** Index in `rowData`; -1 on group and total rows. */
+    readonly sourceIndex: number;
+    /** A group row (or a total row) built by row grouping. */
+    readonly group?: boolean;
+    /** The group's key: the grouped column's value as text, null for an empty value. */
+    readonly key?: string | null;
+    /** The grouped column's field (or id) the group is keyed on. */
+    readonly field?: string;
+    readonly rowGroupColumn?: string;
+    /** 0 for a top-level group; -1 for the grand total row. */
+    readonly level?: number;
+    readonly parent?: MtRowNode<T>;
+    readonly leafGroup?: boolean;
+    readonly expanded?: boolean;
+    /** Direct children: the next level's groups, or the leaf rows. */
+    readonly childrenAfterGroup?: readonly MtRowNode<T>[];
+    /** Every leaf row under the group. */
+    readonly allLeafChildren?: readonly MtRowNode<T>[];
+    /** Aggregated values by column id. */
+    readonly aggData?: Readonly<Record<string, unknown>>;
+    /** A total row (a group's total or the grand total). */
+    readonly footer?: boolean;
+    /** A master row (`masterDetail`): `expanded` tells whether its detail row shows. */
+    readonly master?: boolean;
+    /** The detail row under an expanded master (`detail_<master id>`); `data` is the master's. */
+    readonly detail?: boolean;
+}
+interface MtSortModel {
+    readonly colId: string;
+    readonly sort: 'asc' | 'desc';
+}
+interface MtCellFocusedEvent {
+    readonly rowIndex: number;
+    readonly rowId: string;
+    readonly colId: string;
+}
+interface MtColumnWidth {
+    readonly colId: string;
+    readonly width: number;
+}
+interface MtColumnResizedEvent {
+    readonly columns: readonly MtColumnWidth[];
+    readonly finished: boolean;
+    readonly source: 'api' | 'uiColumnResized' | 'autosizeColumns';
+}
+/** Where a column-state change came from. `columnMenu` covers the header menu and its chooser. */
+type MtColumnEventSource = 'api' | 'uiColumnMoved' | 'uiColumnDragged' | 'columnMenu' | 'contextMenu' | 'rowGroupChanged' | 'toolPanelUi';
+interface MtColumnMovedEvent {
+    /** Moved columns; for state application, every column whose index changed, in previous order. */
+    readonly columns: readonly string[];
+    /** New index in the full column order; `null` when several columns moved by state application. */
+    readonly toIndex: number | null;
+    readonly finished: boolean;
+    readonly source: 'api' | 'uiColumnMoved' | 'columnMenu';
+}
+interface MtColumnPinnedEvent {
+    readonly columns: readonly string[];
+    /** `null` also when the changed columns ended on different sides. */
+    readonly pinned: MtColumnPinned;
+    readonly source: MtColumnEventSource;
+}
+interface MtColumnVisibleEvent {
+    readonly columns: readonly string[];
+    /** `null` when the changed columns did not all become visible or all hidden. */
+    readonly visible: boolean | null;
+    readonly source: MtColumnEventSource;
+}
+/** One column's saved state; `getColumnState()` lists every column, hidden ones included, in order. */
+interface MtColumnState {
+    readonly colId: string;
+    readonly width: number;
+    readonly hide: boolean;
+    readonly pinned: MtColumnPinned;
+    readonly sort: 'asc' | 'desc' | null;
+    /** Multi-sort priority; `null` when unsorted or when applied without an index. */
+    readonly sortIndex: number | null;
+}
+type MtColumnStateUpdate = {
+    readonly colId: string;
+} & Partial<Omit<MtColumnState, 'colId'>>;
+interface MtApplyColumnStateParams {
+    /** Missing properties keep the current value; `pinned: null` / `sort: null` clear. */
+    readonly state?: readonly MtColumnStateUpdate[];
+    /** Listed columns move to the front in the given order; others keep their relative order after them. */
+    readonly applyOrder?: boolean;
+    /** Applied to every column that is not listed in `state`. */
+    readonly defaultState?: Partial<Omit<MtColumnState, 'colId'>>;
+}
+/** One column group's open state; `getColumnGroupState()` lists every group. */
+interface MtColumnGroupState {
+    readonly groupId: string;
+    readonly open: boolean;
+    /** Always `null`, as the reference reports for these groups. */
+    readonly headerName: null;
+}
+interface MtColumnGroupRef {
+    readonly groupId: string;
+    readonly expanded: boolean;
+}
+interface MtColumnGroupOpenedEvent {
+    /** The changed group, or `null` when several changed at once. */
+    readonly columnGroup: MtColumnGroupRef | null;
+    readonly columnGroups: readonly MtColumnGroupRef[];
+}
+/** Column filter kinds; `true` is the text filter. */
+type MtColumnFilter = boolean | 'text' | 'number' | 'date' | 'set' | 'multi';
+type MtTextFilterType = 'contains' | 'notContains' | 'equals' | 'notEqual' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank';
+/** Number and date filters share these; `inRange` excludes both bounds unless `inRangeInclusive`. */
+type MtScalarFilterType = 'equals' | 'notEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'lessThan' | 'lessThanOrEqual' | 'inRange' | 'blank' | 'notBlank';
+interface MtTextFilterModel {
+    readonly filterType: 'text';
+    readonly type: MtTextFilterType | (string & {});
+    readonly filter?: string | null;
+    readonly filterTo?: string | null;
+}
+interface MtNumberFilterModel {
+    readonly filterType: 'number';
+    readonly type: MtScalarFilterType | (string & {});
+    readonly filter?: number | null;
+    readonly filterTo?: number | null;
+}
+/** Dates are `YYYY-MM-DD` (optionally ` HH:mm:ss`), compared by calendar day. */
+interface MtDateFilterModel {
+    readonly filterType: 'date';
+    readonly type: MtScalarFilterType | (string & {});
+    readonly dateFrom?: string | null;
+    readonly dateTo?: string | null;
+}
+type MtSimpleFilterModel = MtTextFilterModel | MtNumberFilterModel | MtDateFilterModel;
+/** Two (or more) conditions of one column joined by AND or OR. */
+interface MtCombinedFilterModel<M extends MtSimpleFilterModel = MtSimpleFilterModel> {
+    readonly filterType: M['filterType'];
+    readonly operator: 'AND' | 'OR';
+    readonly conditions: readonly M[];
+}
+/**
+ * The set filter (live-pivot-setfilter observations): the selected values as their text keys;
+ * `null` stands for blank cells ("(Blanks)"). A model with every value selected is no filter.
+ */
+interface MtSetFilterModel {
+    readonly filterType: 'set';
+    readonly values: readonly (string | null)[];
+}
+interface MtMultiFilterModel {
+    readonly filterType: 'multi';
+    readonly filterModels: readonly (MtColumnFilterModel | null)[];
+}
+interface MtFilterOption {
+    readonly displayKey: string;
+    readonly displayName: string;
+    readonly predicate: (values: readonly unknown[], cellValue: unknown) => boolean;
+    readonly numberOfInputs?: 0 | 1 | 2;
+}
+interface MtMultiFilterDef {
+    readonly filter: 'text' | 'number' | 'date' | 'set';
+    readonly filterParams?: MtFilterParams;
+    readonly display?: 'inline' | 'subMenu' | 'accordion';
+    readonly title?: string;
+}
+interface MtFiltersToolPanelInstance {
+    expandFilters(colIds?: readonly string[]): void;
+    collapseFilters(colIds?: readonly string[]): void;
+    syncLayoutWithGrid(): void;
+}
+interface MtFiltersToolPanelDef {
+    readonly suppressExpandAll?: boolean;
+    readonly suppressFilterSearch?: boolean;
+    readonly suppressSyncLayoutWithGrid?: boolean;
+}
+type MtColumnFilterModel = MtSimpleFilterModel | MtCombinedFilterModel | MtSetFilterModel | MtMultiFilterModel;
+/** `getFilterModel()`: the active column filters by column id (the quick filter is not part of it). */
+type MtFilterModel = Readonly<Record<string, MtColumnFilterModel>>;
+/** One option of a remote set filter: the key the model keeps and the text the list shows. */
+interface MtSetFilterOption {
+    readonly value: string;
+    readonly label: string;
+}
+/** An observable-like search result (an RxJS `Observable` fits); a stale search is unsubscribed. */
+interface MtSetFilterSubscribable<V> {
+    subscribe(observer: {
+        next: (value: V) => void;
+        error: (error: unknown) => void;
+        complete: () => void;
+    }): {
+        unsubscribe(): void;
+    };
+}
+type MtSetFilterSearchResult = PromiseLike<readonly MtSetFilterOption[]> | MtSetFilterSubscribable<readonly MtSetFilterOption[]>;
+/**
+ * A set filter whose options come from a search (usually a server) instead of the column's
+ * values. The popup searches as the user types, lists the matches in the order returned and
+ * keeps the chosen option values in the model; choosing nothing is no filter. Chosen values
+ * stay listed (with their remembered labels) when a later search does not return them.
+ */
+interface MtSetFilterRemoteSearch {
+    /** The options matching the trimmed search text (`''` when the popup opens). */
+    readonly search: (text: string) => MtSetFilterSearchResult;
+    /** One value at a time, for a server that filters by one key (default false). */
+    readonly single?: boolean;
+    /** Delay between typing and searching (default 300ms). */
+    readonly debounceMs?: number;
+    /** Shorter texts do not search; the popup asks the user to type (default 0). */
+    readonly minLength?: number;
+}
+interface MtFilterParams {
+    /** Delay between typing and applying the filter (observed default 500ms for text, number and date). */
+    readonly debounceMs?: number;
+    /** Conditions the popup offers (default 2). */
+    readonly maxNumConditions?: number;
+    /** The operator selected for a new condition (default `contains` / `equals`). */
+    readonly defaultOption?: string;
+    readonly defaultJoinOperator?: 'AND' | 'OR';
+    /** Text filter: compare case-sensitively (default false). */
+    readonly caseSensitive?: boolean;
+    /** Number and date filters: `inRange` includes its bounds (default false). */
+    readonly inRangeInclusive?: boolean;
+    /** Popup buttons; with `apply` the filter applies on the button or Enter instead of while typing. */
+    readonly buttons?: readonly ('apply' | 'clear' | 'reset' | 'cancel')[];
+    /** Set filter: the values offered instead of the column's distinct values. */
+    readonly values?: readonly unknown[] | ((params: {
+        success: (values: readonly unknown[]) => void;
+    }) => void);
+    readonly filters?: readonly MtMultiFilterDef[];
+    readonly filterOptions?: readonly (string | MtFilterOption)[];
+    readonly numAlwaysVisibleConditions?: number;
+    readonly closeOnApply?: boolean;
+    readonly readOnly?: boolean;
+    readonly trimInput?: boolean;
+    readonly textFormatter?: (value: string) => string;
+    readonly textMatcher?: (params: {
+        filterOption: string;
+        value: string;
+        filterText: string;
+    }) => boolean;
+    readonly allowedCharPattern?: string;
+    readonly numberParser?: (text: string) => number | null;
+    readonly numberFormatter?: (value: number | null) => string | null;
+    readonly comparator?: (a: any, b: any) => number;
+    readonly browserDatePicker?: boolean;
+    readonly minValidYear?: number;
+    readonly maxValidYear?: number;
+    readonly minValidDate?: string | Date;
+    readonly maxValidDate?: string | Date;
+    readonly includeBlanksInEquals?: boolean;
+    readonly includeBlanksInNotEqual?: boolean;
+    readonly includeBlanksInLessThan?: boolean;
+    readonly includeBlanksInGreaterThan?: boolean;
+    readonly includeBlanksInRange?: boolean;
+    readonly filterPlaceholder?: string | ((params: {
+        filterOption: string;
+        placeholder: string;
+    }) => string);
+    readonly applyMiniFilterWhileTyping?: boolean;
+    readonly excelMode?: 'windows' | 'mac';
+    readonly valueFormatter?: (params: {
+        value: any;
+    }) => string;
+    readonly suppressSorting?: boolean;
+    readonly defaultToNothingSelected?: boolean;
+    readonly newRowsAction?: 'keep' | 'reset';
+    readonly showTooltips?: boolean;
+    readonly refreshValuesOnOpen?: boolean;
+    readonly keyCreator?: (params: {
+        value: any;
+    }) => string;
+    readonly treeList?: boolean;
+    readonly treeListPathGetter?: (value: any) => readonly string[] | null;
+    readonly treeListFormatter?: (pathKey: string | null, level: number, parentPathKeys: readonly string[]) => string;
+    /** Set filter: hides the "Search..." mini filter. */
+    readonly suppressMiniFilter?: boolean;
+    /** Set filter: hides the "(Select All)" row. */
+    readonly suppressSelectAll?: boolean;
+    /** Set filter: search the options remotely as the user types (no "(Select All)"). */
+    readonly remoteSearch?: MtSetFilterRemoteSearch;
+}
+type MtFilterChangedSource = 'api' | 'quickFilter' | 'columnFilter';
+interface MtFilterChangedEvent {
+    readonly source: MtFilterChangedSource;
+    /** Columns whose filter changed; empty for the quick filter, external filter and `onFilterChanged()`. */
+    readonly columns: readonly string[];
+    /** Set when a floating-filter input made the change. */
+    readonly afterFloatingFilter?: boolean;
+}
+/** A filter input changed before its debounce applied it. */
+interface MtFilterModifiedEvent {
+    readonly colId: string;
+}
+interface MtFilterOpenedEvent {
+    readonly colId: string;
+    readonly source: 'COLUMN_MENU';
+}
+/** The selection column's id in column state, like the reference's (selection-2 observations). */
+declare const SELECTION_COLUMN_ID = "ag-Grid-SelectionColumn";
+/** The row-numbers column's id in column state (live-selection observations). */
+declare const ROW_NUMBERS_COLUMN_ID = "ag-Grid-RowNumbersColumn";
+/** The auto group column's id (the reference's), shown while rows are grouped. */
+declare const AUTO_GROUP_COLUMN_ID = "ag-Grid-AutoColumn";
+type MtRowSelectionMode = 'singleRow' | 'multiRow';
+/** Rows the header checkbox, `selectAll()` and Ctrl+A act on. */
+type MtSelectAllMode = 'all' | 'filtered';
+interface MtRowSelectionOptions<T> {
+    readonly groupSelects?: 'self' | 'descendants' | 'filteredDescendants';
+    readonly mode: MtRowSelectionMode;
+    /** Checkbox cells in the selection column (default true). */
+    readonly checkboxes?: boolean;
+    /** The header select-all checkbox (default true; `multiRow` only). */
+    readonly headerCheckbox?: boolean;
+    /**
+     * Clicking a row's cells selects it: `true` selects and deselects (Ctrl+click),
+     * `'enableSelection'` only selects, `'enableDeselection'` only deselects. Default false:
+     * clicks focus the cell and report `rowClicked` without selecting.
+     */
+    readonly enableClickSelection?: boolean | 'enableSelection' | 'enableDeselection';
+    /** In `multiRow`, a plain click adds to the selection like Ctrl+click. */
+    readonly enableSelectionWithoutKeys?: boolean;
+    /** Default `'all'`: the header checkbox selects every row, filtered out or not. */
+    readonly selectAll?: MtSelectAllMode;
+    /** Rows returning false cannot be selected; their checkbox is disabled. */
+    readonly isRowSelectable?: (node: MtRowNode<T>) => boolean;
+    /** Hides the checkbox of rows that are not selectable instead of disabling it. */
+    readonly hideDisabledCheckboxes?: boolean;
+}
+/** Overrides for the selection column (width, pinned side, header text, resizing). */
+type MtSelectionColumnDef<T> = Partial<Pick<MtColumnDef<T>, 'headerName' | 'width' | 'minWidth' | 'maxWidth' | 'pinned' | 'resizable' | 'lockPinned'>>;
+interface MtRowNumbersOptions {
+    readonly width?: number;
+    readonly minWidth?: number;
+    readonly maxWidth?: number;
+    readonly resizable?: boolean;
+    readonly headerName?: string;
+}
+type MtSelectionSource = 'api' | 'apiSelectAll' | 'apiSelectAllFiltered' | 'checkboxSelected' | 'rowClicked' | 'spaceKey' | 'uiSelectAll' | 'uiSelectAllFiltered' | 'keyboardSelectAll' | 'rowDataChanged' | 'selectableChanged';
+interface MtRowSelectedEvent<T> {
+    readonly node: MtRowNode<T>;
+    readonly selected: boolean;
+    readonly source: MtSelectionSource;
+}
+interface MtSelectionChangedEvent<T> {
+    readonly source: MtSelectionSource;
+    /** In selection order. */
+    readonly selectedNodes: readonly MtRowNode<T>[];
+}
+interface MtRowClickedEvent<T> {
+    readonly node: MtRowNode<T>;
+    readonly rowIndex: number;
+    readonly event: MouseEvent;
+}
+interface MtSetNodesSelectedParams<T> {
+    readonly nodes: readonly MtRowNode<T>[];
+    readonly newValue: boolean;
+    readonly source?: MtSelectionSource;
+}
+interface MtRowDragEvent<T> {
+    /** The row whose handle is dragged. */
+    readonly node: MtRowNode<T>;
+    /** The dragged rows: the selected rows with `rowDragMultiRow`, otherwise `[node]`. */
+    readonly nodes: readonly MtRowNode<T>[];
+    /** Displayed index under the pointer. */
+    readonly overIndex: number;
+    readonly overNode: MtRowNode<T> | undefined;
+    /** Pointer offset from the top of the rows, scrolled rows included. */
+    readonly y: number;
+    readonly vDirection: 'up' | 'down' | null;
+    readonly event: PointerEvent;
+}
+interface MtCellSelectionOptions {
+    /**
+     * The handle on the only range's bottom-right cell (default true, a range handle);
+     * `{ mode: 'fill' }` makes it the fill handle (dragging writes the range's values on).
+     */
+    readonly handle?: boolean | {
+        readonly mode: 'range' | 'fill';
+    };
+    /** Ctrl+drag/Ctrl+click add ranges unless suppressed. */
+    readonly suppressMultiRanges?: boolean;
+    /** Highlights the headers of the ranged columns (default true); row numbers always highlight. */
+    readonly enableHeaderHighlight?: boolean;
+}
+/** A range in displayed coordinates; `startRow`/`startCol` is the anchor (the focused cell). */
+interface MtCellRange {
+    readonly startRow: number;
+    readonly endRow: number;
+    /** Column ids from the start column to the end column in displayed order. */
+    readonly columns: readonly string[];
+}
+interface MtCellSelectionChangedEvent {
+    /** True while a pointer drag defines the range. */
+    readonly started: boolean;
+    readonly finished: boolean;
+    readonly ranges: readonly MtCellRange[];
+}
+interface MtAddCellRangeParams {
+    readonly rowStartIndex: number;
+    readonly rowEndIndex: number;
+    /** Column ids, or a start/end pair of ids (displayed order between them). */
+    readonly columns?: readonly string[];
+    readonly columnStart?: string;
+    readonly columnEnd?: string;
+}
+type MtStatusBarPanel = 'totalAndFilteredRowCount' | 'totalRowCount' | 'filteredRowCount' | 'selectedRowCount' | 'aggregation';
+interface MtStatusBarOptions {
+    /** Panels in display order; the aggregation panel sits at the right (observed). */
+    readonly panels: readonly MtStatusBarPanel[];
+}
+/** Built-in context actions. Cut/Paste require editable targets; export suppression removes items. */
+type MtDefaultMenuItem = 'cut' | 'copy' | 'copyWithHeaders' | 'copyWithGroupHeaders' | 'paste' | 'separator' | 'export' | 'csvExport' | 'excelExport' | 'pdfExport' | 'expandAll' | 'contractAll' | 'chartRange' | 'autoSizeAll' | 'resetColumns';
+type MtDefaultMainMenuItem = 'sortAscending' | 'sortDescending' | 'sortUnSort' | 'separator' | 'pinSubMenu' | 'autoSizeThis' | 'autoSizeAll' | 'rowGroup' | 'rowUnGroup' | 'valueAgg' | 'pivot' | 'columnChooser' | 'resetColumns' | 'columnFilter' | 'expandAll' | 'contractAll';
+type MtMainMenuItem<T> = MtDefaultMainMenuItem | MtMenuItemDef<T>;
+interface MtGetMainMenuItemsParams<T> extends MtMenuActionParams<T> {
+    readonly defaultItems: readonly MtDefaultMainMenuItem[];
+}
+/** A custom context menu item. */
+interface MtMenuItemDef<T> {
+    readonly name: string;
+    readonly action?: (params: MtMenuActionParams<T>) => void;
+    readonly disabled?: boolean;
+    readonly shortcut?: string;
+    /** A grid icon name (asc, desc, pin, columns, copy, cut, paste, save, …). */
+    readonly icon?: GridIconName | string | HTMLElement;
+    readonly subMenu?: readonly (MtContextMenuItem<T> | MtDefaultMainMenuItem)[];
+    readonly checked?: boolean;
+    readonly tooltip?: string;
+    readonly cssClasses?: readonly string[];
+}
+type MtContextMenuItem<T> = MtDefaultMenuItem | MtMenuItemDef<T>;
+interface MtMenuActionParams<T> {
+    readonly api: MtGridApi<T>;
+    readonly node: MtRowNode<T> | null;
+    readonly column: MtColumnDef<T> | null;
+    readonly value: unknown;
+}
+interface MtGetContextMenuItemsParams<T> extends MtMenuActionParams<T> {
+    readonly defaultItems: readonly MtDefaultMenuItem[];
+}
+interface MtContextMenuVisibleChangedEvent {
+    readonly visible: boolean;
+    readonly source: 'ui' | 'api';
+    readonly rowIndex: number | null;
+    readonly colId: string | null;
+}
+interface MtShowContextMenuParams {
+    /** Displayed row index and column; defaults to the focused cell. */
+    readonly rowIndex?: number;
+    readonly colId?: string;
+    /** Viewport coordinates; default: the cell's centre. */
+    readonly x?: number;
+    readonly y?: number;
+}
+/** What copySelectedRangeToClipboard / copyToClipboard add above the values. */
+interface MtCopyParams {
+    readonly includeHeaders?: boolean;
+    readonly includeGroupHeaders?: boolean;
+    readonly copySelectedRows?: boolean;
+}
+interface MtClipboardCellParams<T> extends MtExportCellParams<T> {
+    readonly formatValue: (value?: unknown) => string;
+}
+interface MtClipboardHeaderParams<T> {
+    readonly column: MtColumnDef<T>;
+}
+interface MtClipboardGroupHeaderParams {
+    readonly groupId: string;
+    readonly headerName: string;
+}
+interface MtExportCell {
+    readonly data: {
+        readonly value: unknown;
+        readonly type?: string;
+    };
+    readonly styleId?: string;
+}
+interface MtExportRow {
+    readonly cells: readonly MtExportCell[];
+    readonly height?: number;
+}
+type MtExportContent = string | readonly (readonly unknown[] | MtExportRow)[];
+interface MtExcelStyle {
+    readonly id: string;
+    readonly font?: {
+        readonly bold?: boolean;
+        readonly italic?: boolean;
+        readonly color?: string;
+        readonly size?: number;
+        readonly fontName?: string;
+    };
+    readonly interior?: {
+        readonly color?: string;
+        readonly pattern?: string;
+    };
+    readonly alignment?: {
+        readonly horizontal?: string;
+        readonly vertical?: string;
+        readonly wrapText?: boolean;
+        readonly indent?: number;
+    };
+    readonly numberFormat?: {
+        readonly format: string;
+    };
+    readonly borders?: Readonly<Record<string, {
+        readonly color?: string;
+        readonly lineStyle?: string;
+        readonly weight?: number;
+    }>>;
+}
+interface MtExportCellParams<T> {
+    readonly value: unknown;
+    readonly node: MtRowNode<T>;
+    readonly column: MtColumnDef<T>;
+    readonly exportType?: 'csv' | 'excel' | 'pdf' | 'clipboard';
+    /** Format with the grid's column/group-key formatter without changing the raw callback value. */
+    readonly formatValue?: (value?: unknown) => string;
+}
+/** Options shared by the CSV and Excel exports (ag-grid archive 36.2.0 csv-export). */
+interface MtExportParams<T> {
+    /** File name; the extension is appended when missing (defaults export.csv / export.xlsx). */
+    readonly fileName?: string;
+    readonly skipColumnHeaders?: boolean;
+    readonly skipColumnGroupHeaders?: boolean;
+    /** Every column, hidden ones included (default: the displayed columns). */
+    readonly allColumns?: boolean;
+    /** Only these columns, in this order. */
+    readonly columnKeys?: readonly string[];
+    readonly onlySelected?: boolean;
+    readonly onlySelectedAllPages?: boolean;
+    readonly skipRowGroups?: boolean;
+    readonly skipPinnedTop?: boolean;
+    readonly skipPinnedBottom?: boolean;
+    readonly prependContent?: MtExportContent;
+    readonly appendContent?: MtExportContent;
+    readonly getCustomContentBelowRow?: (params: {
+        node: MtRowNode<T>;
+    }) => MtExportContent | undefined;
+    readonly processRowGroupCallback?: (params: {
+        node: MtRowNode<T>;
+    }) => string;
+    /** `filteredAndSorted` (default) or every row in source order. */
+    readonly exportedRows?: 'all' | 'filteredAndSorted';
+    readonly processCellCallback?: (params: MtExportCellParams<T>) => unknown;
+    readonly processHeaderCallback?: (params: {
+        column: MtColumnDef<T>;
+    }) => string;
+    readonly processGroupHeaderCallback?: (params: {
+        groupId: string;
+        headerName: string;
+    }) => string;
+    readonly shouldRowBeSkipped?: (params: {
+        node: MtRowNode<T>;
+    }) => boolean;
+}
+interface MtCsvExportParams<T> extends MtExportParams<T> {
+    /** Default ','. */
+    readonly columnSeparator?: string;
+    /** Writes bare values (default false: every value double-quoted, quotes doubled). */
+    readonly suppressQuotes?: boolean;
+}
+interface MtExcelExportParams<T> extends MtExportParams<T> {
+    /** Default 'mt-grid'. */
+    readonly sheetName?: string;
+    /** Workbook author property (default 'Masterteam Data Grid'). */
+    readonly author?: string;
+    /** Column width in px, one for all or per column (default: the rendered width). */
+    readonly columnWidth?: number | ((params: {
+        column: MtColumnDef<T>;
+    }) => number);
+    /** Header row height in px; none written unless given (Excel's default then). */
+    readonly headerRowHeight?: number;
+    /** Data row height in px; none written unless given (Excel's default then). */
+    readonly rowHeight?: number;
+    /** Default 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'. */
+    readonly mimeType?: string;
+}
+interface MtPdfExportParams<T> extends MtExportParams<T> {
+    readonly title?: string;
+    readonly sheetName?: string;
+    readonly orientation?: 'portrait' | 'landscape';
+    readonly pageSize?: 'A4' | 'Letter';
+}
+/** The built-in aggregation functions. */
+type MtAggFuncName = 'sum' | 'min' | 'max' | 'count' | 'avg' | 'first' | 'last';
+interface MtAggFuncParams<T> {
+    /** The leaf values of the group for the column (`undefined` entries included). */
+    readonly values: readonly unknown[];
+    readonly colId: string;
+    readonly rowNode: MtRowNode<T>;
+}
+type MtAggFunc<T> = (params: MtAggFuncParams<T>) => unknown;
+/** What `avg` returns (the reference's shape): the mean and the count it was taken over. */
+interface MtAvgResult {
+    readonly count: number;
+    readonly value: number | null;
+    /** The mean, so `Number(value)` in a formatter works (NaN when there was no number). */
+    valueOf(): number;
+    toString(): string;
+}
+/** When the row group panel above the header shows (default never). */
+type MtRowGroupPanelShow = 'never' | 'always' | 'onlyWhenGrouping';
+type MtGroupDisplayType = 'singleColumn' | 'multipleColumns' | 'groupRows' | 'custom';
+interface MtPivotMaxColumnsExceededEvent {
+    readonly maxColumns: number;
+    readonly generatedColumns: number;
+}
+interface MtDisplayedColumnsChangedEvent {
+    readonly source: MtColumnEventSource;
+}
+interface MtColumnsToolPanelInstance<T> {
+    expandColumnGroups(groupIds?: readonly string[]): void;
+    collapseColumnGroups(groupIds?: readonly string[]): void;
+    setColumnLayout(layout: readonly MtColDef<T>[]): void;
+    getColumnLayout(): readonly MtColDef<T>[];
+}
+/** The auto group column's definition overrides (header "Group", width 200 by default). */
+interface MtAutoGroupColumnDef<T> extends Partial<MtColumnDef<T>> {
+    readonly cellRendererParams?: {
+        /** Hides the child count after the group key. */
+        readonly suppressCount?: boolean;
+    };
+}
+interface MtRowGroupOpenedEvent<T> {
+    readonly node: MtRowNode<T>;
+    readonly expanded: boolean;
+}
+interface MtColumnRowGroupChangedEvent {
+    /** The grouped column ids in group order. */
+    readonly columns: readonly string[];
+    readonly source: MtColumnEventSource;
+}
+interface MtExpandOrCollapseAllEvent {
+    readonly source: 'expandAll' | 'collapseAll';
+}
+type MtToolPanelKind = 'columns' | 'filters';
+/** Options of the Columns tool panel. */
+interface MtColumnsToolPanelParams {
+    readonly [key: string]: unknown;
+    readonly suppressRowGroups?: boolean;
+    readonly suppressValues?: boolean;
+    readonly suppressPivots?: boolean;
+    readonly suppressPivotMode?: boolean;
+    /** Hides the search box. */
+    readonly suppressColumnFilter?: boolean;
+    readonly suppressColumnSelectAll?: boolean;
+    readonly suppressColumnExpandAll?: boolean;
+    /** Starts the column list with every group collapsed. */
+    readonly contractColumnSelection?: boolean;
+}
+interface MtToolPanelDef {
+    /** The key `openToolPanel` and the events use. */
+    readonly id: string;
+    readonly labelDefault: string;
+    readonly iconKey?: 'columns' | 'filter';
+    readonly toolPanel: MtToolPanelKind | 'agColumnsToolPanel' | 'agFiltersToolPanel' | Type<unknown>;
+    readonly toolPanelParams?: MtColumnsToolPanelParams;
+    /** Panel width in px (the reference's 250). */
+    readonly width?: number;
+    readonly minWidth?: number;
+    readonly maxWidth?: number;
+}
+interface MtSideBarDef {
+    readonly toolPanels: readonly (MtToolPanelKind | MtToolPanelDef)[];
+    /** The panel open at start; without it the side bar shows its buttons only. */
+    readonly defaultToolPanel?: string;
+    readonly hiddenByDefault?: boolean;
+    readonly position?: 'left' | 'right';
+}
+/** `true` = Columns and Filters; a kind or a list of kinds; or the full definition. */
+type MtSideBar = boolean | MtToolPanelKind | readonly MtToolPanelKind[] | MtSideBarDef;
+type MtToolPanelVisibleSource = 'sideBarButtonClicked' | 'sideBarInitializing' | 'api';
+interface MtToolPanelVisibleChangedEvent {
+    readonly key: string;
+    readonly visible: boolean;
+    /** True when another panel opens or closes in the same click. */
+    readonly switchingToolPanel: boolean;
+    readonly source: MtToolPanelVisibleSource;
+}
+interface MtToolPanelSizeChangedEvent {
+    readonly key: string;
+    readonly width: number;
+    readonly started: boolean;
+    readonly ended: boolean;
+}
+interface MtColumnValueChangedEvent {
+    /** The value (aggregated) column ids. */
+    readonly columns: readonly string[];
+    readonly source: MtColumnEventSource;
+}
+interface MtColumnPivotChangedEvent {
+    readonly columns: readonly string[];
+    readonly source: MtColumnEventSource;
+}
+interface MtColumnPivotModeChangedEvent {
+    readonly pivotMode: boolean;
+}
+type MtChartType = 'groupedColumn' | 'stackedColumn' | 'normalizedColumn' | 'groupedBar' | 'stackedBar' | 'normalizedBar' | 'pie' | 'donut' | 'line' | 'stackedLine' | 'normalizedLine' | 'area' | 'stackedArea' | 'normalizedArea' | 'scatter' | 'bubble' | 'radarLine' | 'radarArea' | 'nightingale' | 'radialColumn' | 'radialBar' | 'boxPlot' | 'histogram' | 'rangeBar' | 'rangeArea' | 'treemap' | 'sunburst' | 'heatmap' | 'waterfall' | 'funnel' | 'coneFunnel' | 'pyramid' | 'columnLineCombo' | 'areaColumnCombo' | 'customCombo';
+type MtChartDataType = 'category' | 'series' | 'time' | 'excluded';
+type MtChartToolbarItem = 'chartMenu' | 'chartLink' | 'chartUnlink' | 'chartDownload';
+/** Inclusive indexes into displayed rows, before pagination. */
+interface MtChartCellRange {
+    readonly rowStartIndex?: number | null;
+    readonly rowEndIndex?: number | null;
+    readonly columns: readonly string[];
+    /** Optional stable selection. null follows all matching rows; [] selects none.
+     * When supplied, identities take precedence over positional bounds.
+     */
+    readonly rowIds?: readonly string[] | null;
+}
+interface MtSeriesChartType {
+    readonly colId: string;
+    readonly chartType: MtChartType;
+    readonly secondaryAxis?: boolean;
+}
+/** Owned theme schema; see CHARTS.md for the common and per-series override keys. */
+type MtChartThemeOverrides = Readonly<Record<string, unknown>>;
+interface MtChartTheme {
+    readonly palette: {
+        readonly fills: readonly string[];
+        readonly strokes?: readonly string[];
+    };
+    readonly overrides?: MtChartThemeOverrides;
+}
+type MtChartToolPanel = 'settings' | 'data' | 'format';
+interface MtChartToolPanelsDef {
+    readonly panels?: readonly MtChartToolPanel[];
+    readonly defaultToolPanel?: MtChartToolPanel;
+    readonly settingsPanel?: {
+        readonly chartGroupsDef?: Readonly<Record<string, readonly MtChartType[] | boolean>>;
+    };
+    readonly dataPanel?: {
+        readonly groups?: readonly ('categories' | 'series' | 'switchCategorySeries' | 'aggregation' | 'range')[];
+    };
+    readonly formatPanel?: {
+        readonly groups?: readonly ('chart' | 'legend' | 'axes' | 'series' | 'tooltip' | 'navigator')[];
+    };
+}
+interface MtCreateRangeChartParams {
+    readonly cellRange: MtChartCellRange;
+    /** Additional disjoint ranges, read after cellRange. */
+    readonly cellRanges?: readonly MtChartCellRange[];
+    readonly chartType?: MtChartType;
+    readonly title?: string;
+    readonly chartThemeName?: string;
+    /** Human-readable source path, such as level / record / module. Separate from the authored title. */
+    readonly chartContext?: string;
+    readonly chartContainer?: HTMLElement;
+    readonly suppressChartRanges?: boolean;
+    readonly unlinkChart?: boolean;
+    readonly aggFunc?: MtAggFuncName;
+    readonly seriesChartTypes?: readonly MtSeriesChartType[];
+    readonly switchCategorySeries?: boolean;
+    readonly chartThemeOverrides?: Readonly<Record<string, unknown>>;
+    readonly categoryId?: string;
+    /** Checked series in display order; an empty list deliberately charts no series. */
+    readonly seriesIds?: readonly string[];
+}
+interface MtChartModel {
+    readonly chartId: string;
+    readonly chartType: MtChartType;
+    readonly cellRange: MtChartCellRange;
+    readonly cellRanges: readonly MtChartCellRange[];
+    readonly chart: {
+        readonly title: string;
+    };
+    readonly chartContext?: string;
+    readonly chartThemeName: string;
+    readonly chartThemeOverrides: MtChartThemeOverrides;
+    readonly categoryId: string;
+    readonly seriesIds: readonly string[];
+    readonly unlinked: boolean;
+    readonly aggFunc?: MtAggFuncName;
+    readonly switchCategorySeries: boolean;
+    readonly seriesChartTypes: readonly MtSeriesChartType[];
+    /** Current derived data, also available for chart integrations without reading canvas pixels. */
+    readonly data: {
+        readonly category: {
+            readonly id: string;
+            readonly name: string;
+            readonly labels: readonly string[];
+            /** Category identities behind the labels; present for identity-grouped charts. */
+            readonly ids?: readonly string[];
+            /** Resolved category colours (authored or stable palette); present for identity-grouped charts. */
+            readonly colors?: readonly (string | null)[];
+        };
+        readonly series: readonly {
+            readonly id: string;
+            readonly name: string;
+            readonly values: readonly (number | null)[];
+            /** A count measure (`records`, `nonEmpty`, `distinct`) rather than a numeric column. */
+            readonly measure?: MtChartMeasureKind;
+            /** The one unit every charted record shares (`chartUnit`); absent when none or mixed. */
+            readonly unit?: string;
+        }[];
+    };
+}
+/** Count measures offered beside numeric series: distinct records, records with a value, distinct values. */
+type MtChartMeasureKind = 'records' | 'nonEmpty' | 'distinct';
+interface MtChartImageParams {
+    readonly fileName?: string;
+    readonly dimensions?: {
+        readonly width: number;
+        readonly height: number;
+    };
+}
+interface MtChartRef {
+    readonly chartId: string;
+    readonly chartElement: HTMLElement;
+    destroyChart(): void;
+    focusChart(): void;
+    getChartImageDataURL(params?: MtChartImageParams): string | undefined;
+    downloadChart(params?: MtChartImageParams): void;
+}
+interface MtRangeChartUpdateParams {
+    readonly type: 'rangeChartUpdate';
+    readonly chartId: string;
+    readonly chartType?: MtChartType;
+    readonly cellRange?: MtChartCellRange;
+    readonly cellRanges?: readonly MtChartCellRange[];
+    readonly aggFunc?: MtAggFuncName;
+    readonly seriesChartTypes?: readonly MtSeriesChartType[];
+    readonly switchCategorySeries?: boolean;
+    readonly chartThemeName?: string;
+    readonly chartThemeOverrides?: MtChartThemeOverrides;
+    readonly categoryId?: string;
+    readonly seriesIds?: readonly string[];
+}
+interface MtCreatePivotChartParams {
+    readonly chartType: MtChartType;
+    readonly chartContainer?: HTMLElement;
+    readonly unlinkChart?: boolean;
+}
+interface MtChartCreatedEvent {
+    readonly chartId: string;
+}
+interface MtChartDestroyedEvent {
+    readonly chartId: string;
+}
+interface MtChartRangeSelectionChangedEvent {
+    readonly chartId: string;
+    readonly cellRange: MtChartCellRange;
+}
+interface MtChartOptionsChangedEvent {
+    readonly chartId: string;
+    readonly chartType: MtChartType;
+    readonly chartThemeName: string;
+    readonly chartOptions: MtChartThemeOverrides;
+}
+interface MtGridApi<T> {
+    getDisplayedRowCount(): number;
+    /** The displayed row (group rows included) at the index, or undefined. */
+    getDisplayedRowAtIndex(index: number): MtRowNode<T> | undefined;
+    /** The grouped column ids in group order. */
+    getRowGroupColumns(): readonly string[];
+    /** Replaces the grouped columns (API source: columns stay visible). */
+    setRowGroupColumns(colIds: readonly string[]): void;
+    addRowGroupColumns(colIds: readonly string[]): void;
+    removeRowGroupColumns(colIds: readonly string[]): void;
+    expandAll(): void;
+    collapseAll(): void;
+    setRowNodeExpanded(node: MtRowNode<T>, expanded: boolean, expandParents?: boolean): void;
+    /** The side bar definition in use, or null without one. */
+    getSideBar(): MtSideBarDef | null;
+    setSideBarVisible(show: boolean): void;
+    isSideBarVisible(): boolean;
+    setSideBarPosition(position: 'left' | 'right'): void;
+    /** Opens the panel with the key (`columns` / `filters` by default); unknown keys do nothing. */
+    openToolPanel(key: string): void;
+    closeToolPanel(): void;
+    getOpenedToolPanel(): string | null;
+    isToolPanelShowing(): boolean;
+    refreshToolPanel(): void;
+    getToolPanelInstance<TPanel = MtColumnsToolPanelInstance<T>>(id: string): TPanel | undefined;
+    /** The aggregated (value) column ids in definition order. */
+    getValueColumns(): readonly string[];
+    /** Named aggregations can be persisted; anonymous functions are excluded. */
+    getValueColumnState(): readonly {
+        readonly colId: string;
+        readonly aggFunc: string;
+    }[];
+    /** Replaces the value columns; new ones take their `defaultAggFunc` (or `sum`). */
+    setValueColumns(colIds: readonly string[]): void;
+    addValueColumns(colIds: readonly string[]): void;
+    removeValueColumns(colIds: readonly string[]): void;
+    /** Sets or clears (`null`) the aggregation of one column. */
+    setColumnAggFunc(colId: string, aggFunc: MtAggFuncName | string | null): void;
+    /** Creates a linked chart (requires enableCharts). */
+    createRangeChart(params: MtCreateRangeChartParams): MtChartRef | undefined;
+    createPivotChart(params: MtCreatePivotChartParams): MtChartRef | undefined;
+    getChartRef(chartId: string): MtChartRef | undefined;
+    updateChart(params: MtRangeChartUpdateParams): void;
+    downloadChart(params: MtChartImageParams & {
+        readonly chartId: string;
+    }): void;
+    getChartImageDataURL(params: MtChartImageParams & {
+        readonly chartId: string;
+    }): string | undefined;
+    getChartModels(): readonly MtChartModel[];
+    /** Closes a chart dialog (its range highlight clears). */
+    destroyChart(chartId: string): void;
+    isPivotMode(): boolean;
+    setPivotMode(enabled: boolean): void;
+    /** The pivot result column ids (`pivot_<field>_<key>_<valueColId>`) while pivoting. */
+    getPivotResultColumns(): readonly string[];
+    getPivotColumns(): readonly string[];
+    setPivotColumns(colIds: readonly string[]): void;
+    addPivotColumns(colIds: readonly string[]): void;
+    removePivotColumns(colIds: readonly string[]): void;
+    startEditingCell(params: MtStartEditingCellParams): void;
+    /** Commits (or cancels) the open editor. */
+    stopEditing(cancel?: boolean): void;
+    getEditingCells(): readonly MtEditingCell[];
+    undoCellEditing(): void;
+    redoCellEditing(): void;
+    getCurrentUndoSize(): number;
+    getCurrentRedoSize(): number;
+    /** Pastes the clipboard's text at the focused cell / range (needs clipboard permission). */
+    pasteFromClipboard(): Promise<void>;
+    cutToClipboard(params?: MtCopyParams): Promise<void>;
+    paginationGoToPage(page: number): void;
+    paginationGetCurrentPage(): number;
+    paginationGetTotalPages(): number;
+    paginationGetPageSize(): number;
+    paginationSetPageSize(size: number): void;
+    paginationGoToNextPage(): void;
+    paginationGoToPreviousPage(): void;
+    paginationGoToFirstPage(): void;
+    paginationGoToLastPage(): void;
+    /** Every displayed row across the pages. */
+    paginationGetRowCount(): number;
+    getCellRanges(): readonly MtCellRange[];
+    /** Adds a range (Ctrl+drag semantics); ranges need `cellSelection`. */
+    addCellRange(params: MtAddCellRangeParams): void;
+    clearCellSelection(): void;
+    /** Copies the ranges (or the focused cell) as tab-separated text with CRLF rows. */
+    copySelectedRangeToClipboard(params?: MtCopyParams): Promise<void>;
+    /** Copies the selected rows' displayed columns as tab-separated text. */
+    copySelectedRowsToClipboard(params?: MtCopyParams): Promise<void>;
+    copySelectedRangeDown(): void;
+    getRowNode(id: string): MtRowNode<T> | undefined;
+    /** Every row in grid order (after managed row drags), filtered out or not. */
+    forEachNode(callback: (node: MtRowNode<T>, index: number) => void): void;
+    forEachNodeAfterFilterAndSort(callback: (node: MtRowNode<T>, index: number) => void): void;
+    /** Selected rows' data in selection order. */
+    getSelectedRows(): readonly T[];
+    getSelectedNodes(): readonly MtRowNode<T>[];
+    isRowSelected(rowId: string): boolean;
+    /**
+     * Selects or deselects the listed rows; one `rowSelected` per changed row (source
+     * `api`) then one `selectionChanged`. In `singleRow` more than one node is ignored.
+     */
+    setNodesSelected(params: MtSetNodesSelectedParams<T>): void;
+    /** Selects every selectable row (`multiRow` only); source `apiSelectAll`. */
+    selectAll(): void;
+    /** Deselects every row; the reference reports source `apiSelectAll` here too. */
+    deselectAll(): void;
+    /** Selects the rows that pass the filters; source `apiSelectAllFiltered`. */
+    selectAllFiltered(): void;
+    deselectAllFiltered(): void;
+    getDisplayedRowAtIndex(index: number): MtRowNode<T> | undefined;
+    getSortModel(): readonly MtSortModel[];
+    setSortModel(model: readonly MtSortModel[]): void;
+    ensureIndexVisible(index: number): void;
+    setFocusedCell(rowIndex: number, colId: string): void;
+    getColumnWidths(): readonly MtColumnWidth[];
+    setColumnWidths(widths: readonly MtColumnWidth[], finished?: boolean): void;
+    getColumnState(): readonly MtColumnState[];
+    /** Returns false when any listed column is unknown; the known entries are still applied. */
+    applyColumnState(params: MtApplyColumnStateParams): boolean;
+    resetColumnState(): void;
+    moveColumns(colIds: readonly string[], toIndex: number): void;
+    setColumnsPinned(colIds: readonly string[], pinned: MtColumnPinned): void;
+    setColumnsVisible(colIds: readonly string[], visible: boolean): void;
+    /**
+     * Sizes columns to their rendered content: the widest rendered cell and (unless
+     * `skipHeader`) the header, plus `autoSizePadding`. Only rendered (not hidden or
+     * virtualised-out) columns change; one finished `columnResized` reports them.
+     */
+    autoSizeColumns(colIds: readonly string[], skipHeader?: boolean): void;
+    autoSizeAllColumns(skipHeader?: boolean): void;
+    /** Fit displayed columns to the viewport, respecting min/max and suppressSizeToFit. */
+    sizeColumnsToFit(): void;
+    /**
+     * Opens or closes a column group by its groupId. Unknown ids, and the generated
+     * groups around ungrouped columns, are ignored; a change emits `columnGroupOpened`.
+     */
+    setColumnGroupOpened(groupId: string, open: boolean): void;
+    /**
+     * Every group in definition order, children before their group, including the
+     * generated groups that pad ungrouped columns to the tree depth (always closed).
+     */
+    getColumnGroupState(): readonly MtColumnGroupState[];
+    /** Applies the listed open states; unknown ids are ignored. One event reports every change. */
+    setColumnGroupState(state: readonly Pick<MtColumnGroupState, 'groupId' | 'open'>[]): void;
+    /** Returns every group to its `openByDefault`. */
+    resetColumnGroupState(): void;
+    /** Opens the header menu of a displayed column, anchored to its header. */
+    showColumnMenu(colId: string): void;
+    hidePopupMenu(): void;
+    /** Opens the cell context menu (default: at the focused cell's centre). */
+    showContextMenu(params?: MtShowContextMenuParams): void;
+    /** Copies the ranges (or the focused cell) with optional header lines (Copy with Headers / Group Headers). */
+    copyToClipboard(params?: MtCopyParams): Promise<void>;
+    /** The CSV text (with its BOM) for the displayed columns and rows. */
+    getDataAsCsv(params?: MtCsvExportParams<T>): string;
+    /** Downloads the CSV (default export.csv). */
+    exportDataAsCsv(params?: MtCsvExportParams<T>): void;
+    /** The workbook as a Blob; the xlsx writer loads on first use. */
+    getDataAsExcel(params?: MtExcelExportParams<T>): Promise<Blob>;
+    /** Downloads the workbook (default export.xlsx). */
+    exportDataAsExcel(params?: MtExcelExportParams<T>): Promise<void>;
+    getDataAsPdf(params?: MtPdfExportParams<T>): Blob;
+    exportDataAsPdf(params?: MtPdfExportParams<T>): void;
+    /**
+     * Replaces every column filter; `null` clears them. Columns without a filter and unknown
+     * ids are ignored. One `filterChanged` (source `api`) lists the columns whose model
+     * changed; nothing is emitted when none did.
+     */
+    setFilterModel(model: MtFilterModel | null): void;
+    getFilterModel(): MtFilterModel;
+    getColumnFilterModel(colId: string): MtColumnFilterModel | null;
+    setColumnFilterModel(colId: string, model: MtColumnFilterModel | null): void;
+    /** Column filters, the quick filter or an external filter present. */
+    isAnyFilterPresent(): boolean;
+    isColumnFilterPresent(): boolean;
+    isQuickFilterPresent(): boolean;
+    /** Re-runs the filters (after an external filter changed); emits `filterChanged` (source `api`, no columns). */
+    onFilterChanged(): void;
+    /** Clears one column's filter like `setColumnFilterModel(colId, null)`. */
+    destroyFilter(colId: string): void;
+    /** Opens the filter popup of a displayed column, anchored to its header. */
+    showColumnFilter(colId: string): void;
+    getQuickFilter(): string | undefined;
+    /** Clears the quick filter (`quickFilterText`). */
+    resetQuickFilter(): void;
+}
+interface MtGridReadyEvent<T> {
+    readonly api: MtGridApi<T>;
+}
+/** A detail row's id: this prefix and its master's id. */
+declare const DETAIL_ROW_ID_PREFIX = "detail_";
+
+/** Application defaults for built-in Columns panels; explicit panel params win. */
+declare const MT_GRID_COLUMNS_TOOL_PANEL_DEFAULTS: InjectionToken<MtColumnsToolPanelParams>;
+/** One side bar button and the panel it opens. */
+interface SideBarButton {
+    readonly key: string;
+    readonly label: string;
+    readonly icon: GridIconName;
+}
+interface SideBarResize {
+    readonly width: number;
+    readonly started: boolean;
+    readonly ended: boolean;
+}
+/** A tool panel after normalisation. */
+interface SideBarPanelDef {
+    readonly key: string;
+    readonly label: string;
+    readonly icon: GridIconName;
+    readonly kind: MtToolPanelKind | 'custom';
+    readonly component?: Type<unknown>;
+    readonly params: MtColumnsToolPanelParams;
+    readonly width?: number;
+    readonly minWidth?: number;
+    readonly maxWidth?: number;
+}
+interface NormalizedSideBar {
+    readonly panels: readonly SideBarPanelDef[];
+    readonly position: 'left' | 'right';
+    readonly defaultToolPanel?: string;
+    readonly hiddenByDefault: boolean;
+}
+
+interface ColumnGeometry<T> {
+    readonly id: string;
+    readonly definition: MtColumnDef<T>;
+    /** Logical displayed index: left-pinned, centre, then right-pinned columns. */
+    readonly index: number;
+    /**
+     * Offset inside the column's own section: from the physical left in the left-pinned
+     * section (it flows left to right in RTL too, observed), from the inline start elsewhere.
+     */
+    readonly start: number;
+    readonly width: number;
+    readonly pinned: MtColumnPinned;
+}
+
+/** The grid's own selection and row-numbers columns (never user definitions). */
+declare function isSyntheticColumn(id: string | undefined): boolean;
+interface DisplayedColumns<T> {
+    readonly left: readonly ColumnGeometry<T>[];
+    readonly center: readonly ColumnGeometry<T>[];
+    readonly right: readonly ColumnGeometry<T>[];
+    /** Logical order: left-pinned, centre, right-pinned (aria-colindex order). */
+    readonly all: readonly ColumnGeometry<T>[];
+    readonly leftWidth: number;
+    readonly centerWidth: number;
+    readonly rightWidth: number;
+}
+
+/** Classes of one cell across the ranges (edge classes per range; the count suffix). */
+interface CellRangeClasses {
+    /** Number of ranges covering the cell (0 = none). */
+    readonly count: number;
+    readonly top: boolean;
+    readonly bottom: boolean;
+    readonly left: boolean;
+    readonly right: boolean;
+    /** The only cell of the only range. */
+    readonly single: boolean;
+    /** The bottom-right cell of the only range (the fill handle sits here). */
+    readonly handle: boolean;
+}
+interface RangeAggregates {
+    /** Every cell in every range (overlaps counted once per range, like the observation). */
+    readonly count: number;
+    readonly sum: number | null;
+    readonly min: number | null;
+    readonly max: number | null;
+    readonly avg: number | null;
+}
+
+/**
+ * Vertical layout of the displayed rows: a uniform height, or per-row heights (detail rows)
+ * with prefix offsets. Every query is O(1) on a uniform layout and O(log n) otherwise.
+ */
+interface RowLayout {
+    readonly count: number;
+    /** The shared row height when every row has it, else null. */
+    readonly uniform: number | null;
+    readonly total: number;
+    top(index: number): number;
+    height(index: number): number;
+    /** The row at a vertical offset (clamped into the rows). */
+    indexAt(y: number): number;
+}
+/**
+ * Lays `count` rows out at `rowHeight`, with `override(index)` giving another height for
+ * some rows (a detail row's). Without an override the layout stays uniform.
+ */
+declare function buildRowLayout(count: number, rowHeight: number, override?: (index: number) => number | undefined): RowLayout;
+/** The half-open row window covering the viewport, with `buffer` rows either side. */
+declare function rowWindowFor(layout: RowLayout, scroll: number, viewport: number, buffer?: number): {
+    start: number;
+    end: number;
+};
+
+/** A plotted value of a line / area sparkline. */
+interface SparklinePoint {
+    readonly index: number;
+    readonly value: number;
+    readonly x: number;
+    readonly y: number;
+}
+/** A bar of a column / bar sparkline (`x`, `y`, `w`, `h` in SVG units). */
+interface SparklineBar {
+    readonly index: number;
+    readonly value: number;
+    readonly x: number;
+    readonly y: number;
+    readonly w: number;
+    readonly h: number;
+}
+interface SparklineGeometry {
+    readonly type: MtSparklineType;
+    readonly points: readonly SparklinePoint[];
+    /** The line through the points (`M … L …`), broken at non-finite values. */
+    readonly path: string;
+    /** The line closed down to the baseline (area sparklines). */
+    readonly area: string;
+    readonly bars: readonly SparklineBar[];
+    /** The zero line (or the domain's edge when zero is outside it), in SVG units. */
+    readonly baseline: number;
+    readonly min: number;
+    readonly max: number;
+}
+/**
+ * Lays the values out in a `width` x `height` box: the finite values span the vertical
+ * domain (`options.min` / `options.max` widen it; columns and bars always include zero),
+ * equal x steps for a line / area, equal slots for columns (vertical) and bars (horizontal),
+ * and a baseline at zero when zero is inside the domain, else at its nearer edge.
+ */
+declare function sparklineGeometry(values: readonly number[], width: number, height: number, options?: MtSparklineOptions): SparklineGeometry;
+/** Turns a sparkline value into numbers: `number[]`, or `[x, y]` tuples (the y). */
+declare function sparklineValues(value: unknown): readonly number[];
+interface SparklineTooltipState {
+    /** Offsets inside the grid host, at the highlighted point's top. */
+    readonly left: number;
+    readonly top: number;
+    readonly text: string;
+}
+/**
+ * The one tooltip the grid shows for its sparklines (a cell clips its own overflow, so the
+ * tooltip lives at the grid root). Provided per grid.
+ */
+declare class SparklineTooltip {
+    private host;
+    readonly state: _angular_core.WritableSignal<SparklineTooltipState | null>;
+    attach(host: HTMLElement): this;
+    show(anchor: DOMRect, x: number, y: number, text: string): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparklineTooltip, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SparklineTooltip>;
+}
+
+type HeaderCheckboxState = 'checked' | 'indeterminate' | 'unchecked';
+
+/** A column group as the grid identifies it (groupId, or a generated pre-order number). */
+interface ColumnGroupInfo {
+    readonly id: string;
+    readonly label: string;
+}
+/** A group's direct children, for open/close (`columnGroupShow`). */
+interface ColumnGroupNode {
+    readonly id: string;
+    readonly openByDefault: boolean;
+    /** Its columns stay together: moves that would split them are skipped or refused. */
+    readonly marryChildren: boolean;
+    /** Direct children in definition order: columns by column id, groups by group id. */
+    readonly children: readonly {
+        readonly kind: 'column' | 'group';
+        readonly id: string;
+        readonly show?: MtColumnGroupShow;
+    }[];
+    /** Every column under the group. */
+    readonly leaves: readonly string[];
+}
+/** Leaf definitions in definition order with the groups above each leaf, outermost first. */
+interface ColumnGroupTree<T> {
+    readonly leaves: readonly MtColumnDef<T>[];
+    readonly paths: ReadonlyMap<string, readonly ColumnGroupInfo[]>;
+    /** Number of group header rows (the deepest path). */
+    readonly depth: number;
+    readonly groups: ReadonlyMap<string, ColumnGroupNode>;
+    /**
+     * Group state order (group-open-close-2-observations.json state-order-*): definition
+     * order with children before their group, including the generated padding groups that
+     * bring every column to the tree depth. A group whose children are all columns gets one
+     * padding chain shared by them; elsewhere (the root, a group that also holds groups)
+     * each column gets its own (group-ids-observations.json pad-*, group-ids-2 shallow-*).
+     * Padding groups are numbered after the unnamed real groups, in definition order, the
+     * one nearest the columns first.
+     */
+    readonly stateOrder: readonly string[];
+    /** Padding id of each column padded by a single generated group (kept across updates). */
+    readonly padding: ReadonlyMap<string, string>;
+}
+/**
+ * One rendered group header cell: a contiguous run of the group's non-hidden children in
+ * one section, rendered when at least one of them is displayed (children closed away by
+ * a group's open state count in the run but take no width).
+ */
+interface GroupCell {
+    /** `<groupId>_<instance>`, instances counted per group in section order (observed). */
+    readonly key: string;
+    readonly groupId: string;
+    readonly label: string;
+    /** Offset inside the section, same convention as ColumnGeometry.start. */
+    readonly start: number;
+    /** Sum of the displayed children's widths. */
+    readonly width: number;
+    /** Logical displayed index of the first displayed child. */
+    readonly index: number;
+    /** First child of the run, displayed or closed away (its aria-colindex is the cell's). */
+    readonly firstId: string;
+    /** Number of children in the run, closed-away ones included (aria-colspan). */
+    readonly span: number;
+    /** Displayed children, in order. */
+    readonly shownIds: readonly string[];
+    /** Every child in the run, displayed or closed away. */
+    readonly runIds: readonly string[];
+}
+
+/** Source messages are stable keys; interpolation parameters never contain markup. */
+type MtGridLocaleText = Readonly<Record<string, string>>;
+type MtGridLocaleParams = Readonly<Record<string, string | number>>;
+type MtGridLocaleTextResolver = (key: string, defaultValue: string, params: MtGridLocaleParams) => string | undefined;
+/** Each grid owns a locale scope, inherited by its panels and external chart dock. */
+declare class MtGridLocalizer {
+    readonly dictionary: _angular_core.WritableSignal<Readonly<Record<string, string>>>;
+    readonly resolver: _angular_core.WritableSignal<MtGridLocaleTextResolver | undefined>;
+    text(message: string, params?: MtGridLocaleParams): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MtGridLocalizer, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MtGridLocalizer>;
+}
+
+interface MenuItem {
+    readonly id: string;
+    readonly label: string;
+    readonly icon?: GridIconName | string | HTMLElement;
+    readonly shortcut?: string;
+    readonly disabled?: boolean;
+    readonly role?: 'menuitem' | 'menuitemcheckbox';
+    readonly checked?: boolean;
+    readonly separatorBefore?: boolean;
+    readonly children?: readonly MenuItem[];
+    readonly tooltip?: string;
+    readonly cssClasses?: readonly string[];
+}
+/** Viewport (position: fixed) coordinates; exactly one of left/right is set. */
+interface MenuPosition {
+    readonly top: number;
+    readonly left?: number;
+    readonly right?: number;
+}
+/** The box a menu stays inside (the grid's root, observed: the popup parent). */
+interface MenuBounds {
+    readonly top: number;
+    readonly left: number;
+    readonly right: number;
+    readonly bottom: number;
+}
+
+interface ChooserColumn {
+    readonly id: string;
+    readonly label: string;
+    readonly visible: boolean;
+    /** lockVisible: shown with a disabled checkbox and never toggled from the dialog. */
+    readonly locked: boolean;
+}
+
+type FilterKind = 'text' | 'number' | 'date' | 'set' | 'multi';
+
+/** One row of the set filter list. */
+interface SetFilterValue {
+    readonly key: string | null;
+    readonly text: string;
+    readonly raw?: unknown;
+    readonly path?: readonly string[];
+}
+
+type Side = 'left' | 'center' | 'right';
+interface Section<T> {
+    readonly kind: Side;
+    readonly columns: readonly ColumnGeometry<T>[];
+    readonly width: number;
+}
+/**
+ * Observed ghost icons: pin over a pin target, a physical arrow while auto-scrolling,
+ * hide outside the grid, blocked when lockPinned refuses a pin target.
+ */
+type DragIcon = 'pin' | 'move' | 'left' | 'right' | 'hide' | 'blocked' | 'arrows' | 'group' | 'aggregation' | 'pivot';
+/** The header-drag ghost that follows the pointer. */
+interface DragGhost {
+    readonly ids: readonly string[];
+    readonly label: string;
+    readonly x: number;
+    readonly y: number;
+    readonly icon: DragIcon;
+    /** A row drag: the ghost spaces its icon and label like the reference's row ghost. */
+    readonly row?: boolean;
+}
+
+/** One row of the column list: a column or a column group, in grid order. */
+interface ColumnPanelItem {
+    readonly id: string;
+    readonly label: string;
+    readonly level: number;
+    readonly kind: 'column' | 'group';
+    /** A group reads `'some'` while only part of its columns show. */
+    readonly visible: boolean | 'some';
+    /** No toggleable column (lockVisible): the checkbox is disabled. */
+    readonly locked: boolean;
+    readonly groupable: boolean;
+    readonly aggregatable: boolean;
+    readonly pivotable: boolean;
+    /** The toggleable column ids under the row (the column itself unless locked). */
+    readonly leaves: readonly string[];
+}
+/** A chip in a drop zone. */
+interface ColumnPanelChip {
+    readonly preview?: boolean;
+    readonly id: string;
+    readonly label: string;
+    /** Values zone: the aggregation shown as `func(label)`. */
+    readonly func?: string;
+    readonly allowedAggFuncs?: readonly string[];
+}
+type ColumnPanelZone = 'rowGroups' | 'values' | 'pivots';
+/** A list-item drag in flight, rendered by the grid's ghost. */
+interface ColumnPanelGhost {
+    readonly id: string;
+    readonly label: string;
+    readonly x: number;
+    readonly y: number;
+    readonly icon: DragIcon;
+}
+
+/** A filterable column offered by the Filters tool panel. */
+interface FilterPanelColumn {
+    readonly id: string;
+    readonly label: string;
+    readonly kind: FilterKind;
+    readonly params: MtFilterParams;
+    /** Set filter values. */
+    readonly values?: readonly SetFilterValue[];
+    readonly formatValue?: (value: unknown) => string;
+}
+
+interface ChartCategoryPosition {
+    readonly signature: string;
+    readonly start: number;
+}
+interface ChartCategoryViewport extends ChartCategoryPosition {
+    readonly key: string;
+    readonly axis: 'x' | 'y';
+    readonly index: number;
+    readonly total: number;
+    readonly visible: number;
+    readonly zoomIndex: number;
+    readonly rect: ChartRect;
+    readonly unit: number;
+}
+
+/** Pixel layout shared by every renderer. All coordinates are inside the chart canvas. */
+type Option = Record<string, any>;
+interface ChartRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface LegendItem {
+    name: string;
+    label: string;
+    width: number;
+    color: string;
+}
+interface ChartLayout {
+    plot: ChartRect;
+    legend: ChartRect;
+    pages: readonly (readonly (readonly LegendItem[])[])[];
+    titleHeight: number;
+    categoryViewports: readonly ChartCategoryViewport[];
+    option: Option;
+}
+
+/** The record-count measure: distinct records per category. */
+declare const CHART_RECORD_COUNT_ID = "__count__";
+/** Group of records whose category value is missing. */
+declare const CHART_MISSING_CATEGORY_ID = "__missing__";
+declare function chartNonEmptyMeasureId(columnId: string): string;
+declare function chartDistinctMeasureId(columnId: string): string;
+/** Decode a measure id; null for numeric columns. */
+declare function chartMeasure(id: string): {
+    readonly kind: MtChartMeasureKind;
+    readonly columnId?: string;
+} | null;
+interface ChartPoint {
+    readonly rowIndex: number;
+    readonly rowId: string;
+    readonly category: string;
+    readonly categories: readonly string[];
+    readonly values: Readonly<Record<string, number | null>>;
+    /** Category identities per category column id (empty when the value is missing). */
+    readonly identities: Readonly<Record<string, readonly MtChartCategoryValue[]>>;
+    /** After identity grouping: the group's identity, resolved colour and distinct records. */
+    readonly categoryId?: string;
+    readonly color?: string | null;
+    readonly recordCount?: number;
+}
+interface ChartCategoryChoice {
+    readonly id: string;
+    readonly name: string;
+    readonly labels: readonly string[];
+    readonly numeric?: boolean;
+    readonly time?: boolean;
+    /** The column supplies identity/label/colour semantics (`chartCategory`). */
+    readonly semantic?: boolean;
+    readonly multiValue?: boolean;
+    /** Distinct identities and records without a value among the charted rows. */
+    readonly cardinality?: number;
+    readonly missing?: number;
+}
+interface ChartSeriesEntry {
+    readonly id: string;
+    readonly name: string;
+    readonly values: readonly (number | null)[];
+    readonly formatValue?: (value: number) => string;
+    /** A count measure; absent for numeric columns. */
+    readonly measure?: MtChartMeasureKind;
+    /** The column a non-empty/distinct measure counts. */
+    readonly columnId?: string;
+    readonly integer?: boolean;
+    /** The one unit every charted record shares (`chartUnit`), already part of `name`. */
+    readonly unit?: string;
+    /** Records disagree on the unit: values still aggregate, the name stays bare. */
+    readonly mixedUnits?: boolean;
+}
+interface DerivedChartData {
+    readonly categories?: readonly ChartCategoryChoice[];
+    readonly availableSeries?: readonly ChartSeriesEntry[];
+    readonly category: {
+        readonly id: string;
+        readonly name: string;
+        readonly labels: readonly string[];
+        readonly ids?: readonly string[];
+        readonly colors?: readonly (string | null)[];
+        readonly semantic?: boolean;
+        readonly multiValue?: boolean;
+    };
+    readonly categoryColumns: readonly {
+        id: string;
+        name: string;
+    }[];
+    readonly series: readonly ChartSeriesEntry[];
+    readonly points: readonly ChartPoint[];
+    /** Distinct records behind the points, before any grouping. */
+    readonly recordCount?: number;
+    /** Points were merged per category identity (count measures or an aggregation). */
+    readonly grouped?: boolean;
+}
+
+interface ChartPanelSeries {
+    readonly id: string;
+    readonly name: string;
+    /** A count measure (records, non-empty values or distinct values of a column). */
+    readonly measure?: MtChartMeasureKind;
+    readonly columnId?: string;
+}
+interface ChartPanelState {
+    readonly type: MtChartType;
+    readonly theme: string;
+    readonly title: string;
+    readonly themes: Readonly<Record<string, MtChartTheme>>;
+    readonly categories: readonly ChartCategoryChoice[];
+    readonly categoryId: string;
+    readonly series: readonly ChartPanelSeries[];
+    readonly seriesIds: readonly string[];
+    readonly seriesChartTypes: readonly MtSeriesChartType[];
+    readonly switchCategorySeries: boolean;
+    readonly aggFunc?: MtAggFuncName;
+    readonly ranges: readonly MtChartCellRange[];
+    readonly overrides: MtChartThemeOverrides;
+    readonly definition?: MtChartToolPanelsDef;
+    readonly navigator: boolean;
+    /** Chart types suited to the current category/measure, and unsuitable ones with a reason key. */
+    readonly recommended?: readonly MtChartType[];
+    readonly unavailable?: Readonly<Partial<Record<MtChartType, string>>>;
+    /** The chosen category can hold several values per record. */
+    readonly multiValue?: boolean;
+    /** Distinct records behind the chart's source rows. */
+    readonly recordCount?: number;
+    /** Points are merged per category identity. */
+    readonly grouped?: boolean;
+}
+type ChartPanelChange = Omit<MtRangeChartUpdateParams, 'type' | 'chartId'>;
+
+/** Dialog geometry in its current coordinate space (grid or page viewport), in px. */
+interface ChartBox {
+    readonly left: number;
+    readonly top: number;
+    readonly width: number;
+    readonly height: number;
+}
+interface ChartBounds {
+    readonly width: number;
+    readonly height: number;
+}
+type Edge = 'n' | 's' | 'e' | 'w' | 'ne' | 'nw' | 'se' | 'sw';
+/**
+ * Lazy-rendered chart with measured plot reservations, an accessible legend and a
+ * docked editor. Unlinked dialogs float in the page viewport; embedded charts
+ * share the renderer and menu without the movable dialog chrome.
+ */
+declare class ChartDialog {
+    protected readonly locale: MtGridLocalizer;
+    readonly chartId: _angular_core.InputSignal<string>;
+    /** External containers need the grid's tokens even though they are outside its DOM tree. */
+    readonly themeSource: _angular_core.InputSignal<HTMLElement | undefined>;
+    readonly embedded: _angular_core.InputSignal<boolean>;
+    readonly unlinked: _angular_core.InputSignal<boolean>;
+    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
+    readonly sourceAvailable: _angular_core.InputSignal<boolean>;
+    readonly toolbarItems: _angular_core.InputSignal<readonly MtChartToolbarItem[]>;
+    readonly linkChange: _angular_core.OutputEmitterRef<void>;
+    readonly panelState: _angular_core.InputSignal<ChartPanelState | undefined>;
+    readonly panelChange: _angular_core.OutputEmitterRef<ChartPanelChange>;
+    readonly selectRange: _angular_core.OutputEmitterRef<void>;
+    protected readonly panel: _angular_core.WritableSignal<"Chart" | "Data" | "Format" | null>;
+    protected readonly panelWidth: _angular_core.WritableSignal<number>;
+    private readonly lastTab;
+    protected readonly activeTab: _angular_core.Signal<MtChartToolPanel>;
+    protected readonly showLink: _angular_core.Signal<boolean>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly context: _angular_core.InputSignal<string>;
+    protected readonly dialogTitle: _angular_core.Signal<string>;
+    readonly box: _angular_core.InputSignal<ChartBox>;
+    readonly bounds: _angular_core.InputSignal<ChartBounds>;
+    readonly chartType: _angular_core.InputSignal<MtChartType>;
+    /** The echarts option to draw (plain data; the component loads echarts on first use). */
+    readonly option: _angular_core.InputSignal<Record<string, unknown>>;
+    readonly boxChange: _angular_core.OutputEmitterRef<ChartBox>;
+    readonly typeChange: _angular_core.OutputEmitterRef<MtChartType>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    private readonly host;
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly canvas;
+    protected readonly maximized: _angular_core.WritableSignal<boolean>;
+    protected readonly menu: _angular_core.WritableSignal<{
+        position: MenuPosition;
+        key: number;
+    } | null>;
+    private menuKey;
+    protected readonly floatingBox: _angular_core.WritableSignal<ChartBox | null>;
+    private readonly viewportBounds;
+    private readonly dialogBox;
+    private readonly dialogBounds;
+    private popupParent;
+    protected readonly shownBox: _angular_core.Signal<ChartBox>;
+    protected readonly menuItems: _angular_core.Signal<readonly MenuItem[]>;
+    protected readonly layout: _angular_core.WritableSignal<ChartLayout | null>;
+    protected readonly legendPage: _angular_core.WritableSignal<number>;
+    protected readonly legendRows: _angular_core.Signal<readonly (readonly LegendItem[])[]>;
+    protected readonly selectedLegend: _angular_core.WritableSignal<ReadonlySet<string>>;
+    protected readonly empty: _angular_core.Signal<boolean>;
+    protected changeLegendPage(delta: number): void;
+    protected toggleLegend(name: string): void;
+    protected hoverLegend(name: string, on: boolean): void;
+    private chart;
+    private optionRevision;
+    private renderedSize;
+    private readonly categoryPositions;
+    private disposed;
+    private observer?;
+    private themeObserver?;
+    constructor();
+    /** Release the source grid's DOM; a scoped popup remains a native chart. */
+    detachSource(): void;
+    private observeTheme;
+    /** Move the existing view, preserving its chart, editor and focused control. */
+    private placeDialog;
+    private changeBox;
+    protected toggleMaximize(): void;
+    protected close(): void;
+    protected onKey(event: KeyboardEvent): void;
+    /** Linked dialogs stay inside the grid; unlinked dialogs move across the viewport. */
+    protected onTitlePointerDown(event: PointerEvent): void;
+    protected onResizePointerDown(event: PointerEvent, edge: Edge): void;
+    private track;
+    protected toggleMenu(event: MouseEvent): void;
+    private removeOutside?;
+    protected closeMenu(): void;
+    protected onMenuItem(id: string): void;
+    protected togglePanel(): void;
+    setChartPanel(options: {
+        open?: boolean;
+        tab?: MtChartToolPanel;
+    }): void;
+    protected panelResize(event: PointerEvent): void;
+    protected panelResizeKey(event: KeyboardEvent): void;
+    protected scrollCategory(event: Event, viewport: ChartCategoryViewport): void;
+    protected categoryKey(event: KeyboardEvent, viewport: ChartCategoryViewport): void;
+    protected categoryWheel(event: WheelEvent): void;
+    private draw;
+    private withHostFont;
+    focusChart(): void;
+    getChartImageDataURL(params?: MtChartImageParams): string | undefined;
+    downloadChart(params?: MtChartImageParams): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChartDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChartDialog, "mt-data-grid-chart-dialog", never, { "chartId": { "alias": "chartId"; "required": true; "isSignal": true; }; "themeSource": { "alias": "themeSource"; "required": false; "isSignal": true; }; "embedded": { "alias": "embedded"; "required": false; "isSignal": true; }; "unlinked": { "alias": "unlinked"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "sourceAvailable": { "alias": "sourceAvailable"; "required": false; "isSignal": true; }; "toolbarItems": { "alias": "toolbarItems"; "required": false; "isSignal": true; }; "panelState": { "alias": "panelState"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "context": { "alias": "context"; "required": false; "isSignal": true; }; "box": { "alias": "box"; "required": true; "isSignal": true; }; "bounds": { "alias": "bounds"; "required": true; "isSignal": true; }; "chartType": { "alias": "chartType"; "required": true; "isSignal": true; }; "option": { "alias": "option"; "required": true; "isSignal": true; }; }, { "linkChange": "linkChange"; "panelChange": "panelChange"; "selectRange": "selectRange"; "boxChange": "boxChange"; "typeChange": "typeChange"; "closed": "closed"; }, never, never, true, never>;
+}
+
+/** The open inline editor. */
+interface EditingState {
+    readonly rowId: string;
+    readonly colId: string;
+    readonly rowIndex: number;
+    readonly kind: MtCellEditorKind;
+    readonly initial: unknown;
+    readonly key: string | null;
+    readonly keepValue: boolean;
+}
+declare class MtDataGridComponent<T extends object> {
+    readonly rowData: _angular_core.InputSignal<readonly T[]>;
+    /** The host owns the complete query. Sort/filter controls emit state without processing this page. */
+    readonly dataProcessing: _angular_core.InputSignal<"external" | "client">;
+    /** Columns and column groups (MtColumnGroupDef with children, nestable). */
+    readonly columnDefs: _angular_core.InputSignal<readonly MtColDef<T>[]>;
+    readonly getRowId: _angular_core.InputSignal<((data: T) => string) | undefined>;
+    readonly height: _angular_core.InputSignal<number>;
+    /**
+     * Size the grid by its content instead of `height`: the header band, the chrome
+     * and every row. Open detail rows always count in full; `autoHeightMaxRows`
+     * caps the plain rows (the viewport then scrolls them), `autoHeightMinRows`
+     * keeps room for the loading and no-rows states.
+     */
+    readonly autoHeight: _angular_core.InputSignal<boolean>;
+    readonly autoHeightMaxRows: _angular_core.InputSignal<number | undefined>;
+    readonly autoHeightMinRows: _angular_core.InputSignal<number>;
+    readonly rowHeight: _angular_core.InputSignal<number | undefined>;
+    /** Fade newly rendered rows; reduced-motion hosts suppress it. */
+    readonly animateRows: _angular_core.InputSignal<boolean>;
+    readonly headerHeight: _angular_core.InputSignal<number | undefined>;
+    /** Height of each column-group header row; the reference defaults it to headerHeight. */
+    readonly groupHeaderHeight: _angular_core.InputSignal<number | undefined>;
+    readonly direction: _angular_core.InputSignal<"ltr" | "rtl">;
+    readonly localeText: _angular_core.InputSignal<Readonly<Record<string, string>>>;
+    readonly localeTextResolver: _angular_core.InputSignal<MtGridLocaleTextResolver | undefined>;
+    protected readonly locale: MtGridLocalizer;
+    private readonly columnsToolPanelDefaults;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly noRowsText: _angular_core.InputSignal<string>;
+    readonly loadingText: _angular_core.InputSignal<string>;
+    readonly noRowsTemplate: _angular_core.InputSignal<TemplateRef<unknown> | undefined>;
+    protected readonly emptyOverlay: _angular_core.Type<{
+        readonly params: unknown;
+    }> | null;
+    protected readonly emptyOverlayInputs: Signal<{
+        params: {
+            message: string;
+            filtered: boolean;
+            clearFilters: () => void;
+        };
+    }>;
+    /** Opt in to fitting on mount, viewport resize and visible-column changes; manual sizing survives other actions. */
+    readonly autoSizeStrategy: _angular_core.InputSignal<{
+        readonly type: "fitGridWidth";
+    } | undefined>;
+    /** Header column menu (the reference's Enterprise column menu). False matches a Community grid. */
+    readonly columnMenu: _angular_core.InputSignal<boolean>;
+    readonly mainMenuItems: _angular_core.InputSignal<readonly MtMainMenuItem<T>[] | ((params: MtGetMainMenuItemsParams<T>) => readonly MtMainMenuItem<T>[]) | undefined>;
+    /** Pixels added after autosize measurement (reference default 20; negative values apply as given). */
+    readonly autoSizePadding: _angular_core.InputSignal<number>;
+    /** Quick filter text: every word must appear in a displayed column's value (case-insensitive). */
+    readonly quickFilterText: _angular_core.InputSignal<string>;
+    /** Render the owned quick-filter box in the panel row. */
+    readonly showQuickFilter: _angular_core.InputSignal<boolean>;
+    readonly includeHiddenColumnsInQuickFilter: _angular_core.InputSignal<boolean>;
+    readonly quickFilterParser: _angular_core.InputSignal<((text: string) => readonly string[]) | undefined>;
+    readonly quickFilterMatcher: _angular_core.InputSignal<((parts: readonly string[], text: string) => boolean) | undefined>;
+    readonly cacheQuickFilter: _angular_core.InputSignal<boolean>;
+    readonly applyQuickFilterBeforePivotOrAgg: _angular_core.InputSignal<boolean>;
+    readonly filtersToolPanelDef: _angular_core.InputSignal<MtFiltersToolPanelDef>;
+    private readonly quickColumns;
+    private readonly quickCache;
+    private quickParts;
+    /** External filter: while it reports present, rows must pass `doesExternalFilterPass`. */
+    readonly isExternalFilterPresent: _angular_core.InputSignal<(() => boolean) | undefined>;
+    readonly doesExternalFilterPass: _angular_core.InputSignal<((node: MtRowNode<T>) => boolean) | undefined>;
+    /** Floating-filter height; defaults to the Classic 40px token (fixture reference: 48px). */
+    readonly floatingFiltersHeight: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Row selection. `{ mode: 'multiRow' }` alone adds the selection column (checkbox
+     * cells and a header select-all) as the first column; clicks on other cells select only
+     * with `enableClickSelection` (selection-observations.json).
+     */
+    readonly rowSelection: _angular_core.InputSignal<MtRowSelectionOptions<T> | undefined>;
+    /** Overrides for the selection column (width, pinned side, header text). */
+    readonly selectionColumnDef: _angular_core.InputSignal<Partial<Pick<MtColumnDef<T>, "width" | "pinned" | "headerName" | "minWidth" | "maxWidth" | "resizable" | "lockPinned">> | undefined>;
+    /** A pinned row-numbers column before every other column (live-selection observations). */
+    readonly rowNumbers: _angular_core.InputSignal<boolean | MtRowNumbersOptions>;
+    /** The grid reorders its rows while a row is dragged (inert while sorted or filtered). */
+    readonly rowDragManaged: _angular_core.InputSignal<boolean>;
+    /** Any cell of a row starts the drag, not only the handle. */
+    readonly rowDragEntireRow: _angular_core.InputSignal<boolean>;
+    /** Dragging a selected row drags every selected row (`multiRow` selection). */
+    readonly rowDragMultiRow: _angular_core.InputSignal<boolean>;
+    /** Managed reorder happens on release instead of while dragging. */
+    readonly suppressMoveWhenRowDragging: _angular_core.InputSignal<boolean>;
+    /**
+     * Cell range selection (live-range observations): a click makes a single-cell range on
+     * the focused cell, a drag, Shift+click or Shift+arrows a rectangle, Ctrl adds ranges,
+     * Ctrl+A covers every cell; Ctrl+C copies the ranges as tab-separated text.
+     */
+    readonly cellSelection: _angular_core.InputSignal<boolean | MtCellSelectionOptions>;
+    /** The status bar under the rows: row counts, the selected count, range aggregates. */
+    readonly statusBar: _angular_core.InputSignal<MtStatusBarOptions | undefined>;
+    /** No cell context menu (the browser's own shows). */
+    readonly suppressContextMenu: _angular_core.InputSignal<boolean>;
+    /** Keeps the grid's menu while Ctrl is held (default: Ctrl+right-click leaves the browser's menu, observed). */
+    readonly allowContextMenuWithControlKey: _angular_core.InputSignal<boolean>;
+    /** Suppresses the browser's menu even where the grid shows none. */
+    readonly preventDefaultOnContextMenu: _angular_core.InputSignal<boolean>;
+    /** The items for a cell's context menu; receives the default item names. */
+    readonly getContextMenuItems: _angular_core.InputSignal<((params: MtGetContextMenuItemsParams<T>) => readonly MtContextMenuItem<T>[]) | undefined>;
+    readonly suppressCsvExport: _angular_core.InputSignal<boolean>;
+    readonly suppressExcelExport: _angular_core.InputSignal<boolean>;
+    readonly suppressPdfExport: _angular_core.InputSignal<boolean>;
+    readonly defaultPdfExportParams: _angular_core.InputSignal<MtPdfExportParams<T> | undefined>;
+    readonly excelStyles: _angular_core.InputSignal<readonly MtExcelStyle[]>;
+    readonly processCellForClipboard: _angular_core.InputSignal<((params: MtClipboardCellParams<T>) => unknown) | undefined>;
+    readonly processHeaderForClipboard: _angular_core.InputSignal<((params: MtClipboardHeaderParams<T>) => string) | undefined>;
+    readonly processGroupHeaderForClipboard: _angular_core.InputSignal<((params: MtClipboardGroupHeaderParams) => string) | undefined>;
+    readonly copySelectedRows: _angular_core.InputSignal<boolean>;
+    readonly copyHeadersToClipboard: _angular_core.InputSignal<boolean>;
+    readonly copyGroupHeadersToClipboard: _angular_core.InputSignal<boolean>;
+    readonly clipboardDelimiter: _angular_core.InputSignal<string>;
+    readonly suppressCopyRowsToClipboard: _angular_core.InputSignal<boolean>;
+    readonly suppressCopySingleCellRanges: _angular_core.InputSignal<boolean>;
+    readonly suppressCutToClipboard: _angular_core.InputSignal<boolean>;
+    protected readonly copiedCells: _angular_core.WritableSignal<ReadonlySet<string>>;
+    private copyFlashTimer?;
+    readonly defaultCsvExportParams: _angular_core.InputSignal<MtCsvExportParams<T> | undefined>;
+    readonly defaultExcelExportParams: _angular_core.InputSignal<MtExcelExportParams<T> | undefined>;
+    /** The row group panel above the header: never (default), always, onlyWhenGrouping. */
+    readonly groupDisplayType: _angular_core.InputSignal<MtGroupDisplayType>;
+    readonly groupRowRenderer: _angular_core.InputSignal<MtCellRenderer<T> | undefined>;
+    readonly groupRowRendererParams: _angular_core.InputSignal<Readonly<Record<string, unknown>>>;
+    readonly suppressGroupRowsSticky: _angular_core.InputSignal<boolean>;
+    readonly groupHideOpenParents: _angular_core.InputSignal<boolean>;
+    readonly groupHideParentOfSingleChild: _angular_core.InputSignal<boolean>;
+    readonly groupRemoveSingleChildren: _angular_core.InputSignal<boolean>;
+    readonly groupRemoveLowestSingleChildren: _angular_core.InputSignal<boolean>;
+    readonly showOpenedGroup: _angular_core.InputSignal<boolean>;
+    readonly groupAggFiltering: _angular_core.InputSignal<boolean>;
+    readonly suppressAggFilteredOnly: _angular_core.InputSignal<boolean>;
+    readonly aggregateOnlyChangedColumns: _angular_core.InputSignal<boolean>;
+    readonly suppressColumnMoveAnimation: _angular_core.InputSignal<boolean>;
+    readonly pivotRowTotals: _angular_core.InputSignal<"before" | "after" | undefined>;
+    readonly pivotColumnGroupTotals: _angular_core.InputSignal<"before" | "after" | undefined>;
+    readonly pivotMaxGeneratedColumns: _angular_core.InputSignal<number | undefined>;
+    readonly pivotDefaultExpanded: _angular_core.InputSignal<number>;
+    readonly pivotSuppressAutoColumn: _angular_core.InputSignal<boolean>;
+    readonly suppressExpandablePivotGroups: _angular_core.InputSignal<boolean>;
+    readonly processPivotResultColDef: _angular_core.InputSignal<((def: { -readonly [K in keyof MtColumnDef<T>]: MtColumnDef<T>[K]; }) => void) | undefined>;
+    readonly processPivotResultColGroupDef: _angular_core.InputSignal<((def: { -readonly [K in keyof MtColumnGroupDef<T>]: MtColumnGroupDef<T>[K]; }) => void) | undefined>;
+    readonly processUnpinnedColumns: _angular_core.InputSignal<((params: {
+        columns: readonly string[];
+        viewportWidth: number;
+    }) => readonly string[]) | undefined>;
+    readonly displayedColumnsChanged: _angular_core.OutputEmitterRef<MtDisplayedColumnsChangedEvent>;
+    readonly columnEverythingChanged: _angular_core.OutputEmitterRef<MtDisplayedColumnsChangedEvent>;
+    readonly pivotMaxColumnsExceeded: _angular_core.OutputEmitterRef<MtPivotMaxColumnsExceededEvent>;
+    readonly rowGroupPanelShow: _angular_core.InputSignal<MtRowGroupPanelShow>;
+    /** Column Labels zone, independent of the Row Groups zone. */
+    readonly pivotPanelShow: _angular_core.InputSignal<"never" | "always" | "onlyWhenPivoting">;
+    readonly pivotPanelHint: _angular_core.InputSignal<string>;
+    /** -1 opens every group, n the groups above level n, 0 (default) none. */
+    readonly groupDefaultExpanded: _angular_core.InputSignal<number>;
+    readonly autoGroupColumnDef: _angular_core.InputSignal<MtAutoGroupColumnDef<T> | undefined>;
+    readonly groupTotalRow: _angular_core.InputSignal<"bottom" | "top" | undefined>;
+    readonly grandTotalRow: _angular_core.InputSignal<"bottom" | "top" | undefined>;
+    /** Custom aggregation functions by name, for `aggFunc`. */
+    readonly aggFuncs: _angular_core.InputSignal<Readonly<Record<string, MtAggFunc<T>>> | undefined>;
+    /** Grouping from the UI hides the grouped column unless suppressed (observed). */
+    readonly suppressRowGroupHidesColumns: _angular_core.InputSignal<boolean>;
+    readonly suppressMakeColumnVisibleAfterUnGroup: _angular_core.InputSignal<boolean>;
+    /**
+     * The side bar (live-sidebar observations): `true` for the Columns and Filters tool
+     * panels, one kind, a list of kinds, or a definition with `defaultToolPanel`,
+     * `hiddenByDefault` and `position`. Without `defaultToolPanel` the bar opens closed.
+     */
+    readonly sideBar: _angular_core.InputSignal<MtSideBar>;
+    /** Pivot mode (the Columns tool panel's switch); pivoting itself arrives with the pivot batch. */
+    readonly pivotMode: _angular_core.InputSignal<boolean>;
+    /** Headers of aggregated columns read `func(Name)` while grouped unless suppressed (observed). */
+    readonly suppressAggFuncInHeader: _angular_core.InputSignal<boolean>;
+    /** Range charts: the context menu's "Chart Range" and `createRangeChart` (live-charts observations). */
+    readonly enableCharts: _angular_core.InputSignal<boolean>;
+    readonly chartThemes: _angular_core.InputSignal<readonly string[] | undefined>;
+    readonly customChartThemes: _angular_core.InputSignal<Readonly<Record<string, MtChartTheme>> | undefined>;
+    readonly chartToolPanelsDef: _angular_core.InputSignal<MtChartToolPanelsDef | undefined>;
+    readonly chartThemeOverrides: _angular_core.InputSignal<Readonly<Record<string, unknown>> | undefined>;
+    /** Optional source path displayed with native chart titles and retained by detached charts. */
+    readonly chartContext: _angular_core.InputSignal<string>;
+    /** Name of the records this grid shows ("Tasks"): the record-count measure and its titles. */
+    readonly chartRecordsLabel: _angular_core.InputSignal<string | undefined>;
+    readonly getChartToolbarItems: _angular_core.InputSignal<(() => readonly MtChartToolbarItem[]) | undefined>;
+    /** Keeps groups in order of first appearance instead of sorting them by key. */
+    readonly groupMaintainOrder: _angular_core.InputSignal<boolean>;
+    /**
+     * Tree data: `getDataPath` places every row in a hierarchy (HR demo observations). A row
+     * with children is a group row at its own level, a row without is a plain row, a missing
+     * ancestor is a filler group; the auto group column shows the keys.
+     */
+    readonly treeData: _angular_core.InputSignal<boolean>;
+    readonly getDataPath: _angular_core.InputSignal<((data: T) => readonly string[]) | undefined>;
+    /**
+     * Master / detail: every data row (or those `isRowMaster` accepts) opens a detail row
+     * below it — the nested grid of `detailCellRendererParams.detailGridOptions` fed by
+     * `getDetailRowData`, or `detailCellRenderer`. A column with `cellRenderer: 'group'`
+     * shows the toggle (Inventory demo observations).
+     */
+    readonly masterDetail: _angular_core.InputSignal<boolean>;
+    readonly isRowMaster: _angular_core.InputSignal<((data: T) => boolean) | undefined>;
+    readonly detailCellRenderer: _angular_core.InputSignal<MtCellRenderer<T> | undefined>;
+    readonly detailCellRendererParams: _angular_core.InputSignal<MtDetailCellRendererParams<T, any> | undefined>;
+    /** The detail row's height (default 300) unless `detailRowAutoHeight` sizes it by its content. */
+    readonly detailRowHeight: _angular_core.InputSignal<number>;
+    readonly detailRowAutoHeight: _angular_core.InputSignal<boolean>;
+    /** A single click starts editing (double-click by default). */
+    readonly singleClickEdit: _angular_core.InputSignal<boolean>;
+    /** Clicks never start editing (keys and the API still do). */
+    readonly suppressClickEdit: _angular_core.InputSignal<boolean>;
+    /** Commits the open editor when focus leaves the grid (by default it stays open). */
+    readonly stopEditingWhenCellsLoseFocus: _angular_core.InputSignal<boolean>;
+    /** Ctrl+Z / Ctrl+Y (or Ctrl+Shift+Z) undo and redo committed edits, up to the limit. */
+    readonly undoRedoCellEditing: _angular_core.InputSignal<boolean>;
+    readonly undoRedoCellEditingLimit: _angular_core.InputSignal<number>;
+    readonly pagination: _angular_core.InputSignal<boolean>;
+    readonly paginationPanelShow: _angular_core.InputSignal<"always" | "whenNeeded">;
+    readonly paginationPageSize: _angular_core.InputSignal<number>;
+    /** Known total for an externally loaded page; the supplied rows are already paged. */
+    readonly paginationTotalRows: _angular_core.InputSignal<number | undefined>;
+    /** Zero-based external page. Omit it for the grid's ordinary client pagination. */
+    readonly paginationCurrentPage: _angular_core.InputSignal<number | undefined>;
+    /** The page sizes the paging panel offers (false for no picker). */
+    readonly paginationPageSizeSelector: _angular_core.InputSignal<false | readonly number[]>;
+    /** A click on a panel chip sorts the grouped column unless suppressed. */
+    readonly rowGroupPanelSuppressSort: _angular_core.InputSignal<boolean>;
+    private readonly checkedAutoSizePadding;
+    readonly gridReady: _angular_core.OutputEmitterRef<MtGridReadyEvent<T>>;
+    readonly sortChanged: _angular_core.OutputEmitterRef<readonly MtSortModel[]>;
+    readonly cellFocused: _angular_core.OutputEmitterRef<MtCellFocusedEvent>;
+    readonly columnResized: _angular_core.OutputEmitterRef<MtColumnResizedEvent>;
+    readonly columnMoved: _angular_core.OutputEmitterRef<MtColumnMovedEvent>;
+    readonly columnPinned: _angular_core.OutputEmitterRef<MtColumnPinnedEvent>;
+    readonly columnVisible: _angular_core.OutputEmitterRef<MtColumnVisibleEvent>;
+    readonly columnGroupOpened: _angular_core.OutputEmitterRef<MtColumnGroupOpenedEvent>;
+    readonly filterChanged: _angular_core.OutputEmitterRef<MtFilterChangedEvent>;
+    readonly filterModified: _angular_core.OutputEmitterRef<MtFilterModifiedEvent>;
+    readonly filterOpened: _angular_core.OutputEmitterRef<MtFilterOpenedEvent>;
+    /** One per row whose selection changed, before `selectionChanged`. */
+    readonly rowSelected: _angular_core.OutputEmitterRef<MtRowSelectedEvent<T>>;
+    readonly selectionChanged: _angular_core.OutputEmitterRef<MtSelectionChangedEvent<T>>;
+    /** A click on a body cell (not on a checkbox or drag handle). */
+    readonly rowClicked: _angular_core.OutputEmitterRef<MtRowClickedEvent<T>>;
+    readonly rowDragEnter: _angular_core.OutputEmitterRef<MtRowDragEvent<T>>;
+    readonly rowDragMove: _angular_core.OutputEmitterRef<MtRowDragEvent<T>>;
+    readonly rowDragLeave: _angular_core.OutputEmitterRef<MtRowDragEvent<T>>;
+    readonly rowDragEnd: _angular_core.OutputEmitterRef<MtRowDragEvent<T>>;
+    /** Ranges changed: `started` while a pointer drag defines one, `finished` at the end. */
+    readonly cellSelectionChanged: _angular_core.OutputEmitterRef<MtCellSelectionChangedEvent>;
+    readonly contextMenuVisibleChanged: _angular_core.OutputEmitterRef<MtContextMenuVisibleChangedEvent>;
+    readonly rowGroupOpened: _angular_core.OutputEmitterRef<MtRowGroupOpenedEvent<T>>;
+    readonly columnRowGroupChanged: _angular_core.OutputEmitterRef<MtColumnRowGroupChangedEvent>;
+    readonly expandOrCollapseAll: _angular_core.OutputEmitterRef<MtExpandOrCollapseAllEvent>;
+    readonly cellEditingStarted: _angular_core.OutputEmitterRef<MtCellEditingStartedEvent<T>>;
+    readonly cellEditingStopped: _angular_core.OutputEmitterRef<MtCellEditingStoppedEvent<T>>;
+    readonly cellValueChanged: _angular_core.OutputEmitterRef<MtCellValueChangedEvent<T>>;
+    readonly pasteStart: _angular_core.OutputEmitterRef<MtPasteEvent>;
+    readonly pasteEnd: _angular_core.OutputEmitterRef<MtPasteEvent>;
+    readonly fillStart: _angular_core.OutputEmitterRef<MtFillEvent>;
+    readonly fillEnd: _angular_core.OutputEmitterRef<MtFillEvent>;
+    readonly paginationChanged: _angular_core.OutputEmitterRef<MtPaginationChangedEvent>;
+    readonly toolPanelVisibleChanged: _angular_core.OutputEmitterRef<MtToolPanelVisibleChangedEvent>;
+    readonly toolPanelSizeChanged: _angular_core.OutputEmitterRef<MtToolPanelSizeChangedEvent>;
+    readonly columnValueChanged: _angular_core.OutputEmitterRef<MtColumnValueChangedEvent>;
+    readonly columnPivotChanged: _angular_core.OutputEmitterRef<MtColumnPivotChangedEvent>;
+    readonly columnPivotModeChanged: _angular_core.OutputEmitterRef<MtColumnPivotModeChangedEvent>;
+    readonly chartCreated: _angular_core.OutputEmitterRef<MtChartCreatedEvent>;
+    readonly chartDestroyed: _angular_core.OutputEmitterRef<MtChartDestroyedEvent>;
+    readonly chartRangeSelectionChanged: _angular_core.OutputEmitterRef<MtChartRangeSelectionChangedEvent>;
+    readonly chartOptionsChanged: _angular_core.OutputEmitterRef<MtChartOptionsChangedEvent>;
+    protected readonly viewport: Signal<ElementRef<HTMLElement> | undefined>;
+    private readonly host;
+    /** The one sparkline tooltip of this grid, shown at the grid root (a cell clips its overflow). */
+    protected readonly sparklineTooltip: SparklineTooltip;
+    private readonly destroyRef;
+    private readonly injector;
+    /** Leaf columns and the group path above each (column-groups-observations.json). */
+    /** Keeps the previous tree so generated ids can carry over an update (depth 1). */
+    /**
+     * The selection column definition, or null when neither checkboxes nor a header
+     * checkbox show. Only the options that shape the column take part, and an equal
+     * definition keeps its identity, so other option changes are not definition updates
+     * (review P1-2). Defaults are initial values: column state applied later holds.
+     */
+    private readonly selectionColumn;
+    private readonly rowNumbersColumn;
+    /** The host's groups and leaves; the grid's own columns stay outside the tree (review P2-2). */
+    protected readonly groupTree: _angular_core.WritableSignal<ColumnGroupTree<T>>;
+    /**
+     * Row numbers, then the selection column, then the host's leaves. A host leaf without
+     * colId or field keeps the positional id it has without the grid's columns.
+     */
+    /**
+     * The displayed column tree: the host's tree, or in pivot mode the pivot result tree
+     * (groups per key, the value columns as leaves) — with no column label, the host's
+     * tree narrowed to the value columns (live-pivot-setfilter observations).
+     */
+    protected readonly displayTree: Signal<ColumnGroupTree<T>>;
+    private readonly pivotTree;
+    private readonly pivotColDefs;
+    /** The host's data columns with the grid's own columns first, whatever pivot mode shows. */
+    private readonly primaryDefinitions;
+    protected readonly definitions: Signal<readonly MtColumnDef<T>[]>;
+    private composeDefinitions;
+    protected readonly depth: Signal<number>;
+    protected readonly scrollY: _angular_core.WritableSignal<number>;
+    protected readonly scrollX: _angular_core.WritableSignal<number>;
+    protected readonly viewportWidth: _angular_core.WritableSignal<number>;
+    protected readonly viewportHeight: _angular_core.WritableSignal<number>;
+    protected readonly sort: _angular_core.WritableSignal<readonly MtSortModel[]>;
+    /** Reported sortIndex overrides from applied column state (see SortIndices). */
+    private readonly sortIndices;
+    /** Active column filters by column id (`getFilterModel()`); only complete models are stored. */
+    protected readonly filterModel: _angular_core.WritableSignal<Readonly<Record<string, MtColumnFilterModel>>>;
+    /** The quick filter text; the input feeds it and `resetQuickFilter()` clears it. */
+    protected readonly quickText: _angular_core.WritableSignal<string>;
+    /** Bumped by `onFilterChanged()` so an external filter is re-evaluated. */
+    private readonly filterVersion;
+    /** Columns with a filter, by id, with their matching options. */
+    private readonly filterable;
+    private readonly externalFilter;
+    protected readonly focus: _angular_core.WritableSignal<{
+        rowId: string;
+        colId: string;
+        /** Displayed row index when focused; a filter change keeps the index, not the row. */
+        rowIndex: number;
+    } | null>;
+    /** Selected row ids in selection order (`getSelectedRows()` order). */
+    private readonly selection;
+    private readonly selectedSet;
+    /** Displayed index of the last row clicked or toggled with Space (Shift ranges). */
+    private anchorIndex;
+    /** The mode the current selection was made in. */
+    private selectionMode;
+    private lastRowData?;
+    protected readonly synthetic: typeof isSyntheticColumn;
+    protected readonly SELECTION_COLUMN_ID = "ag-Grid-SelectionColumn";
+    protected readonly ROW_NUMBERS_COLUMN_ID = "ag-Grid-RowNumbersColumn";
+    protected readonly showCellCheckbox: Signal<boolean>;
+    protected readonly showHeaderCheckbox: Signal<boolean>;
+    private readonly selectAllMode;
+    protected readonly headerCheckbox: Signal<HeaderCheckboxState>;
+    /** Rows being dragged (rendered half transparent). */
+    protected readonly dragging: _angular_core.WritableSignal<ReadonlySet<string>>;
+    /** Ranges in displayed coordinates; the last one is the active (extending) range. */
+    private readonly ranges;
+    /** Ends a range drag whose release was never delivered (destroy, a new press). */
+    private stopRangeDrag?;
+    /** Ranges clamped to the displayed rows and columns, anchors kept (review P3-7). */
+    private readonly clampedRanges;
+    protected readonly cellSelectionOn: Signal<boolean>;
+    private readonly cellSelectionOptions;
+    /** Columns a range can cover, in displayed order: every column but the row numbers. */
+    private readonly rangeColumns;
+    private readonly pinnedSideById;
+    private readonly rangeColumnIndex;
+    private readonly normalisedRanges;
+    protected readonly rangeHandleOn: Signal<boolean>;
+    protected readonly rangeHeaderHighlight: Signal<boolean>;
+    /** Column ids inside any range (header highlight). */
+    protected readonly rangedColumns: Signal<Set<string>>;
+    /** The status-bar aggregation over the ranges (text-range-status observation). */
+    protected readonly rangeAggregates: Signal<RangeAggregates>;
+    protected readonly statusBarHeight: Signal<0 | 47>;
+    /** The viewport box under the status bar, never negative (recheck N6). */
+    protected readonly viewportBoxHeight: Signal<number>;
+    protected readonly skeletonRows: Signal<number[]>;
+    protected readonly statusPanels: Signal<{
+        key: string;
+        label: string;
+        value: string;
+        hidden: boolean;
+        side: "left" | "right";
+    }[]>;
+    protected readonly statusLeft: Signal<{
+        key: string;
+        label: string;
+        value: string;
+        hidden: boolean;
+        side: "left" | "right";
+    }[]>;
+    protected readonly statusRight: Signal<{
+        key: string;
+        label: string;
+        value: string;
+        hidden: boolean;
+        side: "left" | "right";
+    }[]>;
+    private readonly layout;
+    private hostLayout?;
+    private hostSort;
+    private pivotSort;
+    private pivotOrder;
+    private pivotTotalsOrderKey;
+    private readonly pivotDefaultWidths;
+    private readonly pivotLayoutCache;
+    private rememberPivotLayout;
+    private readonly everythingEvent;
+    private definitionChange?;
+    /**
+     * Open state per group id: a known group keeps it across definition updates, a new
+     * one starts at openByDefault (group-open-close-observations.json definitions-update).
+     */
+    private readonly groupOpen;
+    /** Hover state never changes the public layout or emits column/role events. */
+    protected readonly rolePreview: _angular_core.WritableSignal<{
+        zone: ColumnPanelZone;
+        ids: readonly string[];
+        index: number;
+    } | null>;
+    protected previewChip(id: string, zone: ColumnPanelZone): boolean;
+    private roleIds;
+    protected previewRoleIds(zone: ColumnPanelZone): readonly string[];
+    private readonly previewLayout;
+    /** Groups that can open and close, and the columns their state closes away. */
+    protected readonly groupView: Signal<{
+        expandable: ReadonlySet<string>;
+        closedAway: ReadonlySet<string>;
+    }>;
+    protected readonly displayed: Signal<DisplayedColumns<T>>;
+    protected readonly totalWidth: Signal<number>;
+    private readonly fitRequest;
+    /** Width of the scrolling (centre) region between the pinned sections. */
+    private readonly centerViewport;
+    /** The reference renders 200px of columns beyond each edge of the centre region. */
+    protected readonly visibleCenter: Signal<readonly ColumnGeometry<T>[]>;
+    /**
+     * Column-group header rows (column-groups-observations.json): per level, one cell per
+     * contiguous run of displayed children in each section; the centre renders the cells
+     * that overlap its 200px-buffered window, each at its full width.
+     */
+    protected readonly groupLevels: Signal<{
+        level: number;
+        sections: {
+            kind: Side;
+            width: number;
+            cells: readonly GroupCell[];
+        }[];
+    }[]>;
+    /**
+     * aria-colindex counts hidden columns too: every column in displayed order (left,
+     * centre, right), hidden ones in place; aria-colcount is the column count
+     * (column-groups-observations.json hidden-ltr: 20 columns, Extra 2 at 5).
+     */
+    private readonly ariaIndexes;
+    protected ariaIndex(id: string): number | null;
+    /** A header cell below a group: it draws the 1px separator above itself (observed). */
+    protected underGroup(id: string): boolean;
+    /** Leaf headers stretch up through levels where they have no group (observed). */
+    protected leafSpan(id: string): {
+        top: number;
+        height: number;
+    } | null;
+    protected readonly sections: Signal<readonly Section<T>[]>;
+    /**
+     * Rows also keep the focused cell's centre column rendered when it leaves the window,
+     * so DOM focus survives width changes that push it out; the reference keeps the
+     * focused cell while its header leaves (independent review P2-6, columns-check
+     * focus-kept-after-autosize).
+     */
+    protected readonly rowSections: Signal<readonly Section<T>[]>;
+    /** Arrow state and multi-sort position (1-based, only when several columns sort). */
+    protected sortMark(colId: string): {
+        sort: 'asc' | 'desc';
+        order: number | null;
+    } | null;
+    /**
+     * Arrow-key order follows the physical order on screen. In RTL the right-pinned
+     * section and the centre flow right to left, while the left-pinned section keeps a
+     * left-to-right flow (observed), so only that section is walked in reverse.
+     */
+    private readonly navigation;
+    private readonly sourceRows;
+    /**
+     * Row order after managed row drags (null = source order). A rowData update keeps the
+     * dragged order for the ids it still has and places new rows at their source index.
+     */
+    private readonly managedOrder;
+    /** Source rows in grid order (managed drags applied). */
+    private readonly orderedSourceRows;
+    /** Keyed on the source rows: a managed reorder does not rebuild it (review P3-15). */
+    private readonly nodesById;
+    /** Rows after the column filters, the quick filter and the external filter, in source order. */
+    private readonly filteredRows;
+    /** The leaf rows after the filters and the sort (the displayed rows when nothing is grouped). */
+    protected readonly leafRows: Signal<readonly MtRowNode<T>[]>;
+    /**
+     * Grouped column ids in group order: `rowGroup`/`rowGroupIndex` on the definitions,
+     * then the UI and API changes (stateful like width: an undefined `rowGroup` keeps the
+     * state on a definitions update, true/false applies).
+     */
+    readonly rowGroupColumns: _angular_core.WritableSignal<readonly string[]>;
+    /** Explicit expand/collapse toggles by group id; expandAll/collapseAll reset them. */
+    private readonly groupExpansion;
+    private readonly expandAllMode;
+    /** Tree data is on: `treeData` with a `getDataPath`. */
+    protected readonly treeOn: Signal<boolean>;
+    protected readonly grouping: Signal<boolean>;
+    private readonly groupColumns;
+    /** The auto group column ("Group", 200px) while rows are grouped. */
+    private readonly autoGroupColumn;
+    /** Columns with an aggFunc: a built-in, a registered name, or a function. */
+    private readonly aggregations;
+    private readonly grouped;
+    /**
+     * The displayed rows: the leaves, or the group tree flattened by its expansion; in
+     * pivot mode the group rows alone (their pivot aggregates merged in), or one root row
+     * aggregating every leaf when nothing is grouped (observed ROOT_NODE_ID, level -1).
+     */
+    private readonly baseRows;
+    /** Ids of the master rows whose detail is open. */
+    private readonly detailOpen;
+    /** Detail rows per master id, from `getDetailRowData`. */
+    private readonly detailData;
+    /** Measured heights of auto-height detail rows, by detail row id. */
+    private readonly detailHeights;
+    /** A data row that can open a detail (`masterDetail`, `isRowMaster`). */
+    protected isMaster(row: MtRowNode<T>): boolean;
+    /** Every displayed row, with a detail row under each open master (`detail_<id>`, level 1). */
+    protected readonly displayedAll: Signal<readonly MtRowNode<T>[]>;
+    private readonly pageIndex;
+    protected readonly pagingRowCount: Signal<number>;
+    private readonly pageSizeOverride;
+    protected readonly pageSize: Signal<number>;
+    protected readonly pageCount: Signal<number>;
+    protected readonly currentPage: Signal<number>;
+    private readonly hostChartColors;
+    private readonly skinPagerHeight;
+    private readonly skinFloatingHeight;
+    private readonly skinRowHeight;
+    private readonly skinHeaderHeight;
+    protected readonly pagerHeight: Signal<number>;
+    protected readonly showPager: Signal<boolean>;
+    /** The rows on screen: every displayed row, or the current page of them. */
+    protected readonly rows: Signal<readonly MtRowNode<T>[]>;
+    private paginationEvent;
+    protected goToPage(page: number): void;
+    protected setPageSize(size: number): void;
+    /** The synthetic column a custom detail renderer's params refer to. */
+    protected readonly detailColumn: Signal<MtColumnDef<T>>;
+    /** Opens or closes a master's detail (its rows are fetched on the first opening); reports rowGroupOpened. */
+    private setDetailExpanded;
+    protected detailRows(row: MtRowNode<T>): readonly object[];
+    /** An auto-height detail row reports its content height. */
+    protected onDetailSized(row: MtRowNode<T>, height: number): void;
+    /** The nested grid's height: its header band plus its rows (auto height), else the detail row less its padding. */
+    protected detailGridHeight(row: MtRowNode<T>): number;
+    /** Header-only sizing at result creation; subsequent user widths live in the result cache. */
+    private pivotHeaderWidth;
+    /** The pivot result columns and aggregates (null outside pivot mode). */
+    private readonly pivotData;
+    private readonly pivotLimitEvent;
+    protected readonly showRowGroupPanel: Signal<boolean>;
+    protected readonly showPivotPanel: Signal<boolean>;
+    protected readonly showPanelRow: Signal<boolean>;
+    protected onQuickFilterInput(event: Event): void;
+    protected readonly rowGroupPanelHeight: Signal<0 | 48>;
+    /** The floating-filter row exists when any column asks for one. */
+    protected readonly hasFloatingFilters: Signal<boolean>;
+    protected readonly checkedFloatingHeight: Signal<number>;
+    protected readonly checkedHeight: Signal<number>;
+    /** The viewport's horizontal scrollbar, when its content is wider than its box. */
+    private readonly horizontalScrollbar;
+    /**
+     * Auto height: the plain rows exceed their cap, so the viewport scrolls them.
+     * Otherwise the content fits by construction and the viewport never scrolls
+     * vertically, which keeps its width (and so its columns and horizontal
+     * scrollbar) from oscillating with a classic scrollbar.
+     */
+    protected readonly autoHeightScrolls: Signal<boolean>;
+    /** The chart scope's page-level host size, when it hosts this grid's chart popups. */
+    private readonly chartHostSize;
+    /** Chart popups are bounded by the scope's host when it has one, else by this grid. */
+    private readonly chartBounds;
+    /** Auto height: chrome + the capped plain rows + every open detail + the viewport border. */
+    private readonly autoHeightValue;
+    protected readonly checkedRowHeight: Signal<number>;
+    protected readonly checkedHeaderHeight: Signal<number>;
+    protected readonly checkedGroupHeight: Signal<number>;
+    /** Group rows, the column header row and its bottom border. */
+    protected readonly headerBandHeight: Signal<number>;
+    /** Header rows above the body: group rows, the header row and the floating-filter row. */
+    protected readonly headerRows: Signal<number>;
+    /** Row tops and heights: uniform, or with the detail rows' own heights. */
+    protected readonly rowLayout: Signal<RowLayout>;
+    protected readonly range: Signal<{
+        start: number;
+        end: number;
+    }>;
+    protected readonly visibleRows: Signal<MtRowNode<T>[]>;
+    private readonly tabStop;
+    protected readonly drag: _angular_core.WritableSignal<DragGhost | null>;
+    protected readonly menu: _angular_core.WritableSignal<{
+        colId: string;
+        position: MenuPosition;
+        /** The grid box when the menu was placed: the menu follows it through page scrolling. */
+        box: MenuBounds;
+        /** Every open renders a fresh menu, so no item state leaks between columns. */
+        key: number;
+    } | null>;
+    private menuKey;
+    /** The open cell context menu: its items, the cell it opened on, the box it stays in. */
+    protected readonly contextMenu: _angular_core.WritableSignal<{
+        rowIndex: number | null;
+        colId: string | null;
+        items: readonly MenuItem[];
+        position: MenuPosition;
+        bounds: MenuBounds;
+        key: number;
+    } | null>;
+    private contextMenuKey;
+    /** Custom item actions by generated item id. */
+    private contextMenuActions;
+    private mainMenuActions;
+    /** The open column filter popup. */
+    protected readonly filterPopup: _angular_core.WritableSignal<{
+        colId: string;
+        kind: FilterKind;
+        params: MtFilterParams;
+        position: MenuPosition;
+        anchorTop?: number;
+        key: number;
+    } | null>;
+    private filterKey;
+    /** Floating-filter texts typed but not applied yet (debounce), by column id. */
+    private readonly floatingDrafts;
+    private readonly floatingTimers;
+    protected readonly chooser: _angular_core.WritableSignal<{
+        colId: string;
+        position: {
+            top: number;
+            left: number;
+        };
+    } | null>;
+    protected readonly menuItems: Signal<readonly MenuItem[]>;
+    protected readonly chooserColumns: Signal<readonly ChooserColumn[]>;
+    private resizeObserver?;
+    private focusRender?;
+    private emittedSort;
+    private stopResize?;
+    private resizeDefinitions?;
+    private resizeDirection?;
+    /** A header drag's release must not also sort the column it started on. */
+    private suppressClick;
+    private menuRestore;
+    private quickInputSeen;
+    /** Set while the grid re-focuses a cell itself (no cellFocused event). */
+    private silentFocus;
+    /** Words of the quick filter last applied (a same-words change emits nothing). */
+    private quickApplied;
+    private externalSeen;
+    private removeOutsideListener?;
+    private removeReposition?;
+    /** The header-drag session, driven through the grid's own state and private methods. */
+    private readonly dragger;
+    /** Content autosize, driven the same way. */
+    private readonly autosizer;
+    readonly api: MtGridApi<T>;
+    constructor();
+    /** A column's definition: the host's columns first, then (pivoting) the pivot result leaves. */
+    private definition;
+    /**
+     * The reference skips unknown column IDs in move/pin/visibility/autosize calls and
+     * applies the known ones; an all-unknown call does nothing (columns-check
+     * api-unknown-ids, autosize-unknown-and-repeat).
+     */
+    private keepsLocks;
+    private knownIds;
+    /**
+     * Commits a layout and emits the reference's event families in its observed order:
+     * resized, pinned, visible, sort, moved (columns-observations.json state-apply/reset).
+     */
+    private commit;
+    private emitLayoutChanges;
+    private lastDisplayedSignature;
+    private displayedSignature;
+    private notifyDisplayedColumns;
+    /** Includes generated/group-closed-away columns and synthetic columns added by grouping. */
+    private readonly displayedColumnEvent;
+    private readonly pinHistory;
+    private fitPinnedWidth;
+    private readonly pinnedViewportGuard;
+    private applyColumnState;
+    private resetColumnState;
+    /**
+     * Reference rule (columns-check api-move-unknown-index): `toIndex` is checked against
+     * every listed ID, unknown ones included — beyond `columns - listed` nothing happens;
+     * otherwise the known IDs move, and with none known a `columnMoved` with no columns
+     * is still emitted. Negative or fractional indices stay owned errors.
+     */
+    protected onChooserMove(event: {
+        id: string;
+        toIndex: number;
+    }): void;
+    private moveColumns;
+    private setPinned;
+    private setVisible;
+    /** Moving a node in the DOM blurs it; column changes re-focus the same logical target. */
+    private captureFocus;
+    private findTarget;
+    private restoreFocus;
+    private sizeColumnsToFit;
+    protected groupFieldText(row: MtRowNode<T>): string;
+    private emitColumnWidths;
+    private setColumnWidths;
+    /** Pinned columns resize from the edge that faces the centre (observed in LTR). */
+    protected handleAtStart(column: ColumnGeometry<T>): boolean;
+    private neighbor;
+    private focusFloating;
+    protected onFloatingKey(event: KeyboardEvent, colId: string): void;
+    protected onHeaderKey(event: KeyboardEvent, column: ColumnGeometry<T>): void;
+    private resizeBy;
+    protected startResize(event: PointerEvent, column: ColumnGeometry<T>): void;
+    /** Displayed columns of a layout, without the columns closed away by group state. */
+    private shownColumns;
+    protected isGroupOpen(groupId: string): boolean;
+    /**
+     * Applies open states in order and reports them in one columnGroupOpened: one entry per
+     * entry that changed the state at its turn (a group listed twice can appear twice), each
+     * with the final state; `columnGroup` only when there is one entry
+     * (group-open-close-observations.json api-ltr; open/close review R6). Unknown and padding
+     * group ids are ignored; nothing changed emits nothing.
+     */
+    private setGroupsOpen;
+    /** The expand icon and Enter on an expandable group cell toggle it (observed; Space does not). */
+    protected toggleGroup(groupId: string): void;
+    protected groupResizable(cell: GroupCell): boolean;
+    protected autoSizeGroup(cell: GroupCell): void;
+    private resizeGroup;
+    protected startGroupResize(event: PointerEvent, cell: GroupCell, side: Side): void;
+    protected onGroupKey(event: KeyboardEvent, groupId: string): void;
+    protected autoSizeFromHandle(column: ColumnGeometry<T>): void;
+    protected startHeaderDrag(event: PointerEvent, column: ColumnGeometry<T>): void;
+    /**
+     * Dragging a group header moves all the group's columns as one block, hidden and
+     * closed-away ones included, with the ghost showing the group label; pin, hide,
+     * auto-scroll and events work as for a column. A group with a lockPosition or
+     * suppressMovable column does not drag (group-drag-observations.json).
+     */
+    protected startGroupDrag(event: PointerEvent, cell: GroupCell, side: Side): void;
+    /** Columns of every marryChildren group. */
+    private marriedLeaves;
+    private anchorFor;
+    protected toggleMenu(column: ColumnGeometry<T>, event: MouseEvent): void;
+    protected openContextMenu(event: MouseEvent, column: ColumnGeometry<T>): void;
+    private showColumnMenu;
+    private openMenu;
+    /** Pointer presses outside an open menu close it without moving focus (observed). */
+    private listenOutside;
+    /** Keeps the outside listener while any popup is open. */
+    private releaseOutsideListener;
+    protected closePopups(restore: boolean, source?: 'ui' | 'api'): void;
+    private readonly columnsPanel;
+    private readonly filtersPanel;
+    protected readonly panelColumnLayout: _angular_core.WritableSignal<readonly MtColDef<T>[] | null>;
+    protected readonly panelLayout: Signal<readonly MtColDef<T>[]>;
+    protected onPanelLayout(layout: readonly MtColDef<T>[]): void;
+    protected readonly dropIndicator: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+        height: number;
+    } | null>;
+    protected showPivotHint(event: Event): void;
+    protected hidePivotHint(event: Event): void;
+    protected readonly panelDragging: _angular_core.WritableSignal<string | null>;
+    protected readonly panelInsertion: _angular_core.WritableSignal<{
+        id: string;
+        after: boolean;
+    } | null>;
+    private stopPanelDrag?;
+    protected onGroupChipPointer(event: PointerEvent, id: string): void;
+    protected onPanelDragStart(spec: {
+        event: PointerEvent;
+        id: string;
+        label: string;
+        from?: ColumnPanelZone;
+        group?: boolean;
+    }): void;
+    private readonly customPanel;
+    protected readonly customPanelInputs: Signal<{
+        params: {
+            api: MtGridApi<T>;
+            suppressRowGroups?: boolean;
+            suppressValues?: boolean;
+            suppressPivots?: boolean;
+            suppressPivotMode?: boolean;
+            suppressColumnFilter?: boolean;
+            suppressColumnSelectAll?: boolean;
+            suppressColumnExpandAll?: boolean;
+            contractColumnSelection?: boolean;
+        };
+    }>;
+    private readonly toolPanelRefresh;
+    private refreshToolPanel;
+    private getToolPanelInstance;
+    private readonly toolPanelInitializing;
+    protected readonly sideBarDef: Signal<NormalizedSideBar | null>;
+    protected readonly sideBarVisible: _angular_core.WritableSignal<boolean>;
+    protected readonly sideBarPosition: _angular_core.WritableSignal<"left" | "right">;
+    /** The open panel's key; `defaultToolPanel` opens one at start, otherwise none (observed). */
+    protected readonly openedToolPanel: _angular_core.WritableSignal<string | null>;
+    protected readonly openedPanelDef: Signal<SideBarPanelDef | null>;
+    protected readonly filterPanelOptions: Signal<MtFiltersToolPanelDef>;
+    protected readonly openedPanelParams: Signal<{
+        [key: string]: unknown;
+        suppressRowGroups?: boolean;
+        suppressValues?: boolean;
+        suppressPivots?: boolean;
+        suppressPivotMode?: boolean;
+        suppressColumnFilter?: boolean;
+        suppressColumnSelectAll?: boolean;
+        suppressColumnExpandAll?: boolean;
+        contractColumnSelection?: boolean;
+    }>;
+    protected readonly toolPanelWidth: _angular_core.WritableSignal<number>;
+    protected readonly sideBarButtons: Signal<readonly SideBarButton[]>;
+    protected readonly pivotModeOn: _angular_core.WritableSignal<boolean>;
+    /** Column label ids in pivot order: `pivot`/`pivotIndex` on the definitions, then the UI and API changes (stateful). */
+    readonly pivotColumns: _angular_core.WritableSignal<readonly string[]>;
+    /** Aggregation overrides from the Values zone or the API, by column id (`null` = none). */
+    private readonly aggFuncState;
+    private effectiveAggFunc;
+    private readonly valueOrder;
+    /** Definition order initially; explicit Values drops/API order is retained afterwards. */
+    protected readonly valueColumns: Signal<readonly string[]>;
+    private aggFuncName;
+    /** The header text: `func(Name)` on an aggregated column while rows are grouped (observed). */
+    protected headerText(column: ColumnGeometry<T>): string;
+    /** `func(text)` for an aggregated column (the pivot result headers too), else the text. */
+    private aggLabel;
+    private setValueColumns;
+    private setColumnAggFunc;
+    private setPivotColumns;
+    /** The `pivotMode` input follows the same path as the switch, so changes report the event. */
+    private readonly pivotModeInput;
+    private setPivotMode;
+    /** A side button: the open panel closes, another panel replaces it (observed). */
+    protected onToolPanelToggle(key: string, source?: MtToolPanelVisibleSource): void;
+    private openToolPanel;
+    private closeToolPanel;
+    protected onToolPanelResize(event: SideBarResize): void;
+    /**
+     * The Columns tool panel list in grid order: a named group row opens before its first
+     * column of a run (a group split by moves lists twice), columns at the group's depth.
+     */
+    protected readonly columnPanelItems: Signal<readonly ColumnPanelItem[]>;
+    protected readonly rowGroupChips: Signal<readonly ColumnPanelChip[]>;
+    protected readonly valueChips: Signal<readonly ColumnPanelChip[]>;
+    protected readonly pivotChips: Signal<readonly ColumnPanelChip[]>;
+    protected readonly filterPanelColumns: Signal<readonly FilterPanelColumn[]>;
+    protected onPanelGhost(ghost: ColumnPanelGhost | null): void;
+    protected onPanelVisibility(event: {
+        ids: readonly string[];
+        visible: boolean;
+    }): void;
+    protected onPanelRowGroupAdd(id: string): void;
+    protected onPanelRowGroupRemove(id: string): void;
+    protected onPanelValueAdd(id: string): void;
+    protected onPanelValueRemove(id: string): void;
+    protected onPanelAggFunc(event: {
+        id: string;
+        func: string;
+    }): void;
+    protected onPanelPivotAdd(id: string): void;
+    protected onPanelPivotRemove(id: string): void;
+    protected onPanelPivotMode(on: boolean): void;
+    protected onFilterPanelModel(event: {
+        id: string;
+        model: MtColumnFilterModel | null;
+    }): void;
+    private readonly chartApp;
+    private readonly chartEnvironment;
+    private readonly chartRefs;
+    protected readonly charts: _angular_core.WritableSignal<readonly {
+        id: string;
+        params: MtCreateRangeChartParams;
+        ranges: readonly MtChartCellRange[];
+        box: ChartBox;
+        snapshot?: DerivedChartData;
+    }[]>;
+    private readonly chartScope;
+    private chartSequence;
+    private chartViewSettings;
+    private selectingChartRange?;
+    protected readonly hostSize: _angular_core.WritableSignal<{
+        width: number;
+        height: number;
+    }>;
+    /** Identity charts follow the filtered data, independently of group expansion. */
+    private readonly identityChartRows;
+    private chartDataColumns;
+    /** Live chart source for ranges: displayed rows, or the filtered identity rows for identity ranges. */
+    private chartRawData;
+    private readonly chartViews;
+    protected readonly chartModels: Signal<readonly MtChartModel[]>;
+    private chartCellRange;
+    protected chartClasses(rowIndex: number, colId: string): {
+        chart: boolean;
+        category: boolean;
+    };
+    private chartSelectedRange;
+    private chartRange;
+    private createRangeChart;
+    private createPivotChart;
+    private updateChart;
+    private toggleChartLink;
+    protected destroyChart(chartId: string): void;
+    protected onChartBox(chartId: string, box: ChartBox): void;
+    protected readonly AUTO_GROUP_COLUMN_ID = "ag-Grid-AutoColumn";
+    protected readonly GROUP_INDENT = 28;
+    /** Groups sort by key ascending unless the grouped (or auto) column carries a sort. */
+    private groupSortFor;
+    private setRowGroups;
+    protected toggleRowGroup(node: MtRowNode<T>, event?: Event): void;
+    private setGroupExpanded;
+    private expandOrCollapseAllGroups;
+    /** The auto column's key text: the group key, or the total row's label. */
+    protected groupKeyText(row: MtRowNode<T>): string;
+    protected groupValueColumn(row: MtRowNode<T>): MtColumnDef<T> | undefined;
+    /** "(17)" after the key (observed), unless suppressed. */
+    protected groupCountText(row: MtRowNode<T>): string | null;
+    /** A leaf's text in the auto column: its value for the auto column's field, if any. */
+    protected groupLeafText(row: MtRowNode<T>, column?: MtColumnDef<T>): string;
+    /** 28px per level (observed); leaves sit one level deeper than the last group. */
+    protected groupIndent(row: MtRowNode<T>): number;
+    protected onFullGroupKey(event: KeyboardEvent, row: MtRowNode<T>): void;
+    protected isGroupColumn(id: string | undefined): boolean;
+    protected groupCellNode(row: MtRowNode<T>, id: string): MtRowNode<T> | null;
+    protected readonly stickyRows: Signal<{
+        top: number;
+        translate: number;
+        row: MtRowNode<T>;
+        index: number;
+    }[]>;
+    protected groupChipLabel(id: string): string;
+    protected groupChipSort(id: string): 'asc' | 'desc' | null;
+    /** Observed: a chip click sorts the grouped column ascending, then descending, then not. */
+    protected onGroupChipClick(id: string): void;
+    protected removeRowGroup(id: string): void;
+    private previewRoleDrop;
+    private finishRoleDrop;
+    private rowGroupDropZone;
+    private canRowGroup;
+    private dropOnRowGroupPanel;
+    /** The grid's box is the popup parent: menus stay inside it (observed). */
+    private popupBounds;
+    protected onCellContextMenu(event: MouseEvent, rowIndex: number, column: ColumnGeometry<T>): void;
+    private showContextMenu;
+    /** The default item names; cut and paste wait for editing and show disabled. */
+    private defaultContextMenuItems;
+    private openContextMenuAt;
+    private buildMenuItems;
+    private builtInMenuItem;
+    private mainMenuItem;
+    private customMenuItem;
+    protected onContextMenuItem(id: string): void;
+    protected onContextMenuEscape(): void;
+    protected closeContextMenu(restore: boolean, source?: 'ui' | 'api'): void;
+    private copyText;
+    private copyRowsText;
+    private transferableColumn;
+    private transferValue;
+    private transferText;
+    private clipboardValue;
+    protected isCopied(rowId: string, colId: string): boolean;
+    private flashCopied;
+    private exportColumn;
+    /** Full traversal: exports never inherit the UI's collapsed groups or current page. */
+    private exportNodes;
+    /** The displayed (or chosen) host columns and the displayed (or every) rows as plain values. */
+    private exportTable;
+    private csvText;
+    private exportCsv;
+    /** The workbook as a Blob; the xlsx writer loads on first use. */
+    private excelBlob;
+    private exportExcel;
+    private pdfBlob;
+    private exportPdf;
+    private columnFilterParams;
+    private floatingParamsOf;
+    protected floatingReadOnly(colId: string): boolean;
+    protected floatingInputType(colId: string, kind: FilterKind): string;
+    protected filterKindOf(colId: string): FilterKind | null;
+    protected isFiltered(colId: string): boolean;
+    protected filterModelOf(colId: string): MtColumnFilterModel | null;
+    /** "<Header> Filter Input"; a date column's read-only summary reads "Date Filter Input" (observed). */
+    protected floatingLabel(column: MtColumnDef<T>, summary?: boolean): string;
+    /** Toggles the filter popup from its header or floating-row button. */
+    protected toggleFilter(column: ColumnGeometry<T>, event: MouseEvent): void;
+    /**
+     * Opens the filter popup 2px below its trigger, aligned to its start edge,
+     * clamped to the viewport; emits `filterOpened`.
+     */
+    private openFilter;
+    /** Popup position: 2px below the trigger, start-aligned and clamped to the viewport. */
+    private filterPosition;
+    /** Closes the filter popup; Escape and the trigger return focus to the header cell. */
+    protected closeFilterPopup(restore: boolean): void;
+    /**
+     * The popup follows its trigger through page and grid scrolling and column moves
+     * (review P1-4): the position is recomputed from the trigger's current box.
+     */
+    private listenReposition;
+    /**
+     * The header and context menus are fixed-positioned inside the grid's box (the popup
+     * parent); when the page scrolls or the grid moves they shift with the box, like the
+     * reference's popups that live inside its root element.
+     */
+    private repositionMenus;
+    private repositionFilter;
+    protected onFilterPopupModel(colId: string, model: MtColumnFilterModel | null): void;
+    /**
+     * What a floating-filter cell shows: the typed draft, the applied simple value, or a
+     * read-only summary for models the input cannot hold (ranges, blank, two conditions).
+     */
+    /** Distinct set-filter values of a column over every row (or `filterParams.values`), blanks first. */
+    protected setFilterValues(colId: string): readonly SetFilterValue[];
+    private readonly filterValueFormatters;
+    protected filterValueFormatter(colId: string): ((value: unknown) => string) | undefined;
+    protected readonly resolvedSetValues: _angular_core.WritableSignal<ReadonlyMap<string, ReadonlyMap<MtFilterParams, readonly SetFilterValue[]>>>;
+    protected onSetValues(colId: string, event: {
+        params: MtFilterParams;
+        values: readonly SetFilterValue[];
+    }): void;
+    private readonly setFilterValueMap;
+    protected floatingState(colId: string): {
+        kind: FilterKind;
+        value: string;
+        summary: string | null;
+    } | null;
+    private conditionText;
+    /**
+     * Typing in a floating input: the model applies after the debounce; the reference
+     * reports one `filterModified` then (not per keystroke, unlike the popup).
+     */
+    protected onFloatingInput(colId: string, event: Event): void;
+    protected clearFloating(colId: string): void;
+    private scheduleFloating;
+    /** The model a floating text amounts to: the applied operator (or the default) with that value. */
+    private floatingModel;
+    protected onMenuItem(id: string): void;
+    protected onChooserToggle(change: {
+        id: string;
+        visible: boolean;
+    }): void;
+    protected onChooserToggleAll(visible: boolean): void;
+    protected readonly editing: _angular_core.WritableSignal<EditingState | null>;
+    private readonly editorRef;
+    /** Bumped after every committed value, so the cells re-read their (mutated) row data. */
+    private readonly dataVersion;
+    private readonly undoStack;
+    private readonly redoStack;
+    /** The cells a fill drag will write (normalised, displayed coordinates). */
+    private readonly fillPreview;
+    private stopFillDrag;
+    /** `cellSelection.handle: { mode: 'fill' }`: the range handle fills instead of extending. */
+    protected readonly fillHandleOn: Signal<boolean>;
+    /** The ranged column ids in displayed order. */
+    private rangeColumnIds;
+    protected isEditable(row: MtRowNode<T>, column: MtColumnDef<T>): boolean;
+    protected isEditing(row: MtRowNode<T>, colId: string): boolean;
+    protected editorOptions(column: MtColumnDef<T>): readonly unknown[];
+    protected editorParams(column: MtColumnDef<T>): MtCellEditorParams;
+    protected inFillPreview(rowIndex: number, colId: string): boolean;
+    /**
+     * Opens the inline editor on an editable cell (observed: Enter / double-click select the
+     * value, a typed key replaces it, F2 keeps it with the caret at the end). A checkbox
+     * cell toggles instead of opening an editor.
+     */
+    startEditing(rowIndex: number, colId: string, key?: string | null, keepValue?: boolean): boolean;
+    private editingTarget;
+    /**
+     * Focus left the editor: a click on another cell commits (that cell keeps the focus);
+     * focus leaving the grid commits only with stopEditingWhenCellsLoseFocus, else the
+     * editor stays open.
+     */
+    protected commitOnBlur(event: {
+        value: unknown;
+        target: Element | null;
+    }): void;
+    /** Commits what the editor holds, re-focuses the cell (observed: Enter keeps focus there). */
+    protected commitEditing(raw: unknown, refocus?: boolean): void;
+    private commitCurrentEditor;
+    /** Escape: the value stays, focus returns to the cell. */
+    protected cancelEditing(): void;
+    /** Tab / Shift+Tab after the commit: the next editable cell of the row (then the next row) edits. */
+    protected tabEditing(direction: number): void;
+    /**
+     * Writes a value through `valueSetter` or into `data[field]`, bumps the data version so
+     * the cells re-read, reports cellValueChanged and records the undo step.
+     */
+    private writeCell;
+    private applyEdit;
+    private undoEdit;
+    private redoEdit;
+    protected onCellDoubleClick(event: MouseEvent, rowIndex: number, row: MtRowNode<T>, column: ColumnGeometry<T>): void;
+    /** The keys that edit (observed: Enter, F2, a printable key; Delete / Backspace; Ctrl+X / Z / Y). */
+    private handleEditingKey;
+    /** The editable cells of the ranges, or of the focused cell when no range is drawn: rows x column ids. */
+    private selectedCells;
+    protected editableCellsInSelection(): boolean;
+    private clearCells;
+    /** Cut: the copy, then the editable cells of the range cleared. */
+    private cutCells;
+    private copyRangeDown;
+    protected onPaste(event: ClipboardEvent): void;
+    private pasteFromClipboard;
+    /**
+     * Pastes a grid of text at the first range's top-left (or the focused cell): a single
+     * value fills the whole range, a block writes cell by cell into editable cells (columns
+     * with `suppressPaste` skipped).
+     */
+    private pasteText;
+    /**
+     * The fill handle (observed on the reference as the range's bottom-right square): dragging
+     * it down / up / right / left previews the cells the range's values will be written on,
+     * continuing a numeric sequence or repeating the pattern (`editing.ts`).
+     */
+    protected onFillPointerDown(event: PointerEvent): void;
+    private applyFill;
+    /** Per-node renderer params, reused while the value and its text are unchanged. */
+    private readonly cellParamsCache;
+    protected cellParams(row: MtRowNode<T>, column: MtColumnDef<T>): MtCellRendererParams<T>;
+    protected hasType(column: MtColumnDef<T>, type: MtColumnType): boolean;
+    /** `rightAligned` and `numericColumn` columns align their cells and header to the end. */
+    protected rightAligned(column: MtColumnDef<T>): boolean;
+    /** The column's `cellClass` plus the `cellClassRules` that hold, or null. */
+    protected cellClassList(row: MtRowNode<T>, column: MtColumnDef<T>): readonly string[] | null;
+    protected cellStyleOf(row: MtRowNode<T>, column: MtColumnDef<T>): Readonly<Record<string, string>> | null;
+    protected text(row: MtRowNode<T>, column: MtColumnDef<T>): string;
+    protected label(column: MtColumnDef<T>): string;
+    protected tabIndex(row: MtRowNode<T>, column: ColumnGeometry<T>): number;
+    protected ariaSort(id: string): 'ascending' | 'descending' | 'none';
+    protected onScroll(event: Event): void;
+    /**
+     * Replaces the column filters. Columns without a filter, unknown ids and inactive models
+     * are dropped; one `filterChanged` lists the columns whose model changed, in current
+     * then new order, and nothing is emitted when none did (filter-basics observations
+     * two-columns-and-clear, unknown column).
+     */
+    private setFilterModel;
+    private setColumnFilter;
+    /** Sets the quick filter text; a change emits `filterChanged` (source `quickFilter`). */
+    private setQuickFilter;
+    /**
+     * Applies a filter change and emits `filterChanged`. The focused cell keeps its row
+     * index like the reference (filter-with-sort-and-focus): the cell at that index is
+     * focused afterwards, without a `cellFocused` event.
+     */
+    private commitFilters;
+    /** Opens the filter popup of a displayed column (API `showColumnFilter`). */
+    private showColumnFilter;
+    private setSortModel;
+    private emitSortModel;
+    protected toggleSort(column: ColumnGeometry<T>, event: MouseEvent): void;
+    protected onCellFocus(index: number, row: MtRowNode<T>, column: ColumnGeometry<T>): void;
+    private ensureIndexVisible;
+    /**
+     * `domFocus: false` moves the grid's focus without taking DOM focus (a menu is about to).
+     * `immediate` (keyboard navigation) focuses a rendered target synchronously, like the
+     * reference: a key pressed right after an arrow must land on the new cell. A target that
+     * has to render first (a far PageDown) still waits for the render pass below.
+     */
+    private setFocusedCell;
+    /** Pinned columns are always in view; centre columns scroll within the centre region. */
+    private ensureColumnVisible;
+    protected isSelected(rowId: string): boolean;
+    protected selectable(row: MtRowNode<T>): boolean;
+    private groupSelectionLeaves;
+    protected rowCheckboxState(row: MtRowNode<T>): 'checked' | 'indeterminate' | 'unchecked';
+    protected checkboxLabel(row: MtRowNode<T>): string;
+    /**
+     * Applies a selection change: the rows to select (reported first, in the given order)
+     * and to deselect, one `rowSelected` per changed row, then one `selectionChanged`.
+     * Rows that are not selectable, unknown ids and no-op changes report nothing.
+     */
+    private applySelection;
+    private selectionScope;
+    /** Select-all over the configured scope; deselecting reports in selection order. */
+    private selectAllRows;
+    private setNodesSelected;
+    protected onHeaderCheckbox(event: Event): void;
+    protected onRowCheckbox(event: MouseEvent, row: MtRowNode<T>, rowIndex: number): void;
+    /** Space toggles the focused row; Shift+Space adds the range from the anchor (multiRow). */
+    private toggleBySpace;
+    protected onCellClick(event: MouseEvent, rowIndex: number, row: MtRowNode<T>, column?: ColumnGeometry<T>): void;
+    private readonly rowDragger;
+    /** The column whose cells carry the drag handle (the first with `rowDrag`). */
+    private readonly rowDragColumn;
+    protected dragHandle(row: MtRowNode<T>, column: MtColumnDef<T>): boolean;
+    private rowDragLabel;
+    protected startRowDrag(event: PointerEvent, row: MtRowNode<T>, rowIndex: number): void;
+    protected onCellPointerDown(event: PointerEvent, row: MtRowNode<T>, rowIndex: number, column: ColumnGeometry<T>): void;
+    /** Managed reorder: the block takes `toIndex` in the order without it (row-drag observations). */
+    private moveManagedRows;
+    /** Raw value of a ranged cell (the clipboard and aggregates use values, not text). */
+    private rangeValue;
+    protected rangeClasses(rowIndex: number, colId: string): CellRangeClasses;
+    /** Row-number cell state: the row touched by a range, or covered end to end. */
+    protected rowNumberRange(rowIndex: number): 'none' | 'highlight' | 'selected';
+    private toCellRange;
+    private setRanges;
+    /** A single-cell range on the cell (a click, an arrow move). */
+    private rangeAt;
+    /** Extends the active range's end (Shift+click, Shift+arrows, a drag). */
+    private extendRange;
+    private fullRowRange;
+    /**
+     * A press on a cell with cell selection: Shift extends the active range to the cell,
+     * Ctrl starts a new range beside the others, otherwise a single-cell range replaces
+     * them; a press on a row number ranges the whole row. The drag that may follow
+     * extends the new range to the cell under the pointer (live-range observations).
+     */
+    private beginRange;
+    /** Tab-separated text of the ranges, or of the focused cell alone (Ctrl+C observation). */
+    private clipboardText;
+    private clipboardHeaders;
+    protected onCopy(event: ClipboardEvent): void;
+    private selectedRowsText;
+    private addCellRange;
+    protected onKey(event: KeyboardEvent, rowIndex: number, colId: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MtDataGridComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MtDataGridComponent<any>, "mt-data-grid", never, { "rowData": { "alias": "rowData"; "required": false; "isSignal": true; }; "dataProcessing": { "alias": "dataProcessing"; "required": false; "isSignal": true; }; "columnDefs": { "alias": "columnDefs"; "required": false; "isSignal": true; }; "getRowId": { "alias": "getRowId"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "autoHeight": { "alias": "autoHeight"; "required": false; "isSignal": true; }; "autoHeightMaxRows": { "alias": "autoHeightMaxRows"; "required": false; "isSignal": true; }; "autoHeightMinRows": { "alias": "autoHeightMinRows"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "animateRows": { "alias": "animateRows"; "required": false; "isSignal": true; }; "headerHeight": { "alias": "headerHeight"; "required": false; "isSignal": true; }; "groupHeaderHeight": { "alias": "groupHeaderHeight"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "localeText": { "alias": "localeText"; "required": false; "isSignal": true; }; "localeTextResolver": { "alias": "localeTextResolver"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "noRowsText": { "alias": "noRowsText"; "required": false; "isSignal": true; }; "loadingText": { "alias": "loadingText"; "required": false; "isSignal": true; }; "noRowsTemplate": { "alias": "noRowsTemplate"; "required": false; "isSignal": true; }; "autoSizeStrategy": { "alias": "autoSizeStrategy"; "required": false; "isSignal": true; }; "columnMenu": { "alias": "columnMenu"; "required": false; "isSignal": true; }; "mainMenuItems": { "alias": "mainMenuItems"; "required": false; "isSignal": true; }; "autoSizePadding": { "alias": "autoSizePadding"; "required": false; "isSignal": true; }; "quickFilterText": { "alias": "quickFilterText"; "required": false; "isSignal": true; }; "showQuickFilter": { "alias": "showQuickFilter"; "required": false; "isSignal": true; }; "includeHiddenColumnsInQuickFilter": { "alias": "includeHiddenColumnsInQuickFilter"; "required": false; "isSignal": true; }; "quickFilterParser": { "alias": "quickFilterParser"; "required": false; "isSignal": true; }; "quickFilterMatcher": { "alias": "quickFilterMatcher"; "required": false; "isSignal": true; }; "cacheQuickFilter": { "alias": "cacheQuickFilter"; "required": false; "isSignal": true; }; "applyQuickFilterBeforePivotOrAgg": { "alias": "applyQuickFilterBeforePivotOrAgg"; "required": false; "isSignal": true; }; "filtersToolPanelDef": { "alias": "filtersToolPanelDef"; "required": false; "isSignal": true; }; "isExternalFilterPresent": { "alias": "isExternalFilterPresent"; "required": false; "isSignal": true; }; "doesExternalFilterPass": { "alias": "doesExternalFilterPass"; "required": false; "isSignal": true; }; "floatingFiltersHeight": { "alias": "floatingFiltersHeight"; "required": false; "isSignal": true; }; "rowSelection": { "alias": "rowSelection"; "required": false; "isSignal": true; }; "selectionColumnDef": { "alias": "selectionColumnDef"; "required": false; "isSignal": true; }; "rowNumbers": { "alias": "rowNumbers"; "required": false; "isSignal": true; }; "rowDragManaged": { "alias": "rowDragManaged"; "required": false; "isSignal": true; }; "rowDragEntireRow": { "alias": "rowDragEntireRow"; "required": false; "isSignal": true; }; "rowDragMultiRow": { "alias": "rowDragMultiRow"; "required": false; "isSignal": true; }; "suppressMoveWhenRowDragging": { "alias": "suppressMoveWhenRowDragging"; "required": false; "isSignal": true; }; "cellSelection": { "alias": "cellSelection"; "required": false; "isSignal": true; }; "statusBar": { "alias": "statusBar"; "required": false; "isSignal": true; }; "suppressContextMenu": { "alias": "suppressContextMenu"; "required": false; "isSignal": true; }; "allowContextMenuWithControlKey": { "alias": "allowContextMenuWithControlKey"; "required": false; "isSignal": true; }; "preventDefaultOnContextMenu": { "alias": "preventDefaultOnContextMenu"; "required": false; "isSignal": true; }; "getContextMenuItems": { "alias": "getContextMenuItems"; "required": false; "isSignal": true; }; "suppressCsvExport": { "alias": "suppressCsvExport"; "required": false; "isSignal": true; }; "suppressExcelExport": { "alias": "suppressExcelExport"; "required": false; "isSignal": true; }; "suppressPdfExport": { "alias": "suppressPdfExport"; "required": false; "isSignal": true; }; "defaultPdfExportParams": { "alias": "defaultPdfExportParams"; "required": false; "isSignal": true; }; "excelStyles": { "alias": "excelStyles"; "required": false; "isSignal": true; }; "processCellForClipboard": { "alias": "processCellForClipboard"; "required": false; "isSignal": true; }; "processHeaderForClipboard": { "alias": "processHeaderForClipboard"; "required": false; "isSignal": true; }; "processGroupHeaderForClipboard": { "alias": "processGroupHeaderForClipboard"; "required": false; "isSignal": true; }; "copySelectedRows": { "alias": "copySelectedRows"; "required": false; "isSignal": true; }; "copyHeadersToClipboard": { "alias": "copyHeadersToClipboard"; "required": false; "isSignal": true; }; "copyGroupHeadersToClipboard": { "alias": "copyGroupHeadersToClipboard"; "required": false; "isSignal": true; }; "clipboardDelimiter": { "alias": "clipboardDelimiter"; "required": false; "isSignal": true; }; "suppressCopyRowsToClipboard": { "alias": "suppressCopyRowsToClipboard"; "required": false; "isSignal": true; }; "suppressCopySingleCellRanges": { "alias": "suppressCopySingleCellRanges"; "required": false; "isSignal": true; }; "suppressCutToClipboard": { "alias": "suppressCutToClipboard"; "required": false; "isSignal": true; }; "defaultCsvExportParams": { "alias": "defaultCsvExportParams"; "required": false; "isSignal": true; }; "defaultExcelExportParams": { "alias": "defaultExcelExportParams"; "required": false; "isSignal": true; }; "groupDisplayType": { "alias": "groupDisplayType"; "required": false; "isSignal": true; }; "groupRowRenderer": { "alias": "groupRowRenderer"; "required": false; "isSignal": true; }; "groupRowRendererParams": { "alias": "groupRowRendererParams"; "required": false; "isSignal": true; }; "suppressGroupRowsSticky": { "alias": "suppressGroupRowsSticky"; "required": false; "isSignal": true; }; "groupHideOpenParents": { "alias": "groupHideOpenParents"; "required": false; "isSignal": true; }; "groupHideParentOfSingleChild": { "alias": "groupHideParentOfSingleChild"; "required": false; "isSignal": true; }; "groupRemoveSingleChildren": { "alias": "groupRemoveSingleChildren"; "required": false; "isSignal": true; }; "groupRemoveLowestSingleChildren": { "alias": "groupRemoveLowestSingleChildren"; "required": false; "isSignal": true; }; "showOpenedGroup": { "alias": "showOpenedGroup"; "required": false; "isSignal": true; }; "groupAggFiltering": { "alias": "groupAggFiltering"; "required": false; "isSignal": true; }; "suppressAggFilteredOnly": { "alias": "suppressAggFilteredOnly"; "required": false; "isSignal": true; }; "aggregateOnlyChangedColumns": { "alias": "aggregateOnlyChangedColumns"; "required": false; "isSignal": true; }; "suppressColumnMoveAnimation": { "alias": "suppressColumnMoveAnimation"; "required": false; "isSignal": true; }; "pivotRowTotals": { "alias": "pivotRowTotals"; "required": false; "isSignal": true; }; "pivotColumnGroupTotals": { "alias": "pivotColumnGroupTotals"; "required": false; "isSignal": true; }; "pivotMaxGeneratedColumns": { "alias": "pivotMaxGeneratedColumns"; "required": false; "isSignal": true; }; "pivotDefaultExpanded": { "alias": "pivotDefaultExpanded"; "required": false; "isSignal": true; }; "pivotSuppressAutoColumn": { "alias": "pivotSuppressAutoColumn"; "required": false; "isSignal": true; }; "suppressExpandablePivotGroups": { "alias": "suppressExpandablePivotGroups"; "required": false; "isSignal": true; }; "processPivotResultColDef": { "alias": "processPivotResultColDef"; "required": false; "isSignal": true; }; "processPivotResultColGroupDef": { "alias": "processPivotResultColGroupDef"; "required": false; "isSignal": true; }; "processUnpinnedColumns": { "alias": "processUnpinnedColumns"; "required": false; "isSignal": true; }; "rowGroupPanelShow": { "alias": "rowGroupPanelShow"; "required": false; "isSignal": true; }; "pivotPanelShow": { "alias": "pivotPanelShow"; "required": false; "isSignal": true; }; "pivotPanelHint": { "alias": "pivotPanelHint"; "required": false; "isSignal": true; }; "groupDefaultExpanded": { "alias": "groupDefaultExpanded"; "required": false; "isSignal": true; }; "autoGroupColumnDef": { "alias": "autoGroupColumnDef"; "required": false; "isSignal": true; }; "groupTotalRow": { "alias": "groupTotalRow"; "required": false; "isSignal": true; }; "grandTotalRow": { "alias": "grandTotalRow"; "required": false; "isSignal": true; }; "aggFuncs": { "alias": "aggFuncs"; "required": false; "isSignal": true; }; "suppressRowGroupHidesColumns": { "alias": "suppressRowGroupHidesColumns"; "required": false; "isSignal": true; }; "suppressMakeColumnVisibleAfterUnGroup": { "alias": "suppressMakeColumnVisibleAfterUnGroup"; "required": false; "isSignal": true; }; "sideBar": { "alias": "sideBar"; "required": false; "isSignal": true; }; "pivotMode": { "alias": "pivotMode"; "required": false; "isSignal": true; }; "suppressAggFuncInHeader": { "alias": "suppressAggFuncInHeader"; "required": false; "isSignal": true; }; "enableCharts": { "alias": "enableCharts"; "required": false; "isSignal": true; }; "chartThemes": { "alias": "chartThemes"; "required": false; "isSignal": true; }; "customChartThemes": { "alias": "customChartThemes"; "required": false; "isSignal": true; }; "chartToolPanelsDef": { "alias": "chartToolPanelsDef"; "required": false; "isSignal": true; }; "chartThemeOverrides": { "alias": "chartThemeOverrides"; "required": false; "isSignal": true; }; "chartContext": { "alias": "chartContext"; "required": false; "isSignal": true; }; "chartRecordsLabel": { "alias": "chartRecordsLabel"; "required": false; "isSignal": true; }; "getChartToolbarItems": { "alias": "getChartToolbarItems"; "required": false; "isSignal": true; }; "groupMaintainOrder": { "alias": "groupMaintainOrder"; "required": false; "isSignal": true; }; "treeData": { "alias": "treeData"; "required": false; "isSignal": true; }; "getDataPath": { "alias": "getDataPath"; "required": false; "isSignal": true; }; "masterDetail": { "alias": "masterDetail"; "required": false; "isSignal": true; }; "isRowMaster": { "alias": "isRowMaster"; "required": false; "isSignal": true; }; "detailCellRenderer": { "alias": "detailCellRenderer"; "required": false; "isSignal": true; }; "detailCellRendererParams": { "alias": "detailCellRendererParams"; "required": false; "isSignal": true; }; "detailRowHeight": { "alias": "detailRowHeight"; "required": false; "isSignal": true; }; "detailRowAutoHeight": { "alias": "detailRowAutoHeight"; "required": false; "isSignal": true; }; "singleClickEdit": { "alias": "singleClickEdit"; "required": false; "isSignal": true; }; "suppressClickEdit": { "alias": "suppressClickEdit"; "required": false; "isSignal": true; }; "stopEditingWhenCellsLoseFocus": { "alias": "stopEditingWhenCellsLoseFocus"; "required": false; "isSignal": true; }; "undoRedoCellEditing": { "alias": "undoRedoCellEditing"; "required": false; "isSignal": true; }; "undoRedoCellEditingLimit": { "alias": "undoRedoCellEditingLimit"; "required": false; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": false; "isSignal": true; }; "paginationPanelShow": { "alias": "paginationPanelShow"; "required": false; "isSignal": true; }; "paginationPageSize": { "alias": "paginationPageSize"; "required": false; "isSignal": true; }; "paginationTotalRows": { "alias": "paginationTotalRows"; "required": false; "isSignal": true; }; "paginationCurrentPage": { "alias": "paginationCurrentPage"; "required": false; "isSignal": true; }; "paginationPageSizeSelector": { "alias": "paginationPageSizeSelector"; "required": false; "isSignal": true; }; "rowGroupPanelSuppressSort": { "alias": "rowGroupPanelSuppressSort"; "required": false; "isSignal": true; }; }, { "displayedColumnsChanged": "displayedColumnsChanged"; "columnEverythingChanged": "columnEverythingChanged"; "pivotMaxColumnsExceeded": "pivotMaxColumnsExceeded"; "gridReady": "gridReady"; "sortChanged": "sortChanged"; "cellFocused": "cellFocused"; "columnResized": "columnResized"; "columnMoved": "columnMoved"; "columnPinned": "columnPinned"; "columnVisible": "columnVisible"; "columnGroupOpened": "columnGroupOpened"; "filterChanged": "filterChanged"; "filterModified": "filterModified"; "filterOpened": "filterOpened"; "rowSelected": "rowSelected"; "selectionChanged": "selectionChanged"; "rowClicked": "rowClicked"; "rowDragEnter": "rowDragEnter"; "rowDragMove": "rowDragMove"; "rowDragLeave": "rowDragLeave"; "rowDragEnd": "rowDragEnd"; "cellSelectionChanged": "cellSelectionChanged"; "contextMenuVisibleChanged": "contextMenuVisibleChanged"; "rowGroupOpened": "rowGroupOpened"; "columnRowGroupChanged": "columnRowGroupChanged"; "expandOrCollapseAll": "expandOrCollapseAll"; "cellEditingStarted": "cellEditingStarted"; "cellEditingStopped": "cellEditingStopped"; "cellValueChanged": "cellValueChanged"; "pasteStart": "pasteStart"; "pasteEnd": "pasteEnd"; "fillStart": "fillStart"; "fillEnd": "fillEnd"; "paginationChanged": "paginationChanged"; "toolPanelVisibleChanged": "toolPanelVisibleChanged"; "toolPanelSizeChanged": "toolPanelSizeChanged"; "columnValueChanged": "columnValueChanged"; "columnPivotChanged": "columnPivotChanged"; "columnPivotModeChanged": "columnPivotModeChanged"; "chartCreated": "chartCreated"; "chartDestroyed": "chartDestroyed"; "chartRangeSelectionChanged": "chartRangeSelectionChanged"; "chartOptionsChanged": "chartOptionsChanged"; }, never, never, true, never>;
+}
+
+interface MtGridEmptyOverlayParams {
+    readonly message: string;
+    readonly filtered: boolean;
+    readonly clearFilters: () => void;
+}
+/** Optional host artwork; the independent engine has no design-system dependency. */
+declare const MT_GRID_EMPTY_OVERLAY: InjectionToken<Type<{
+    readonly params: unknown;
+}>>;
+
+/** Configuration only. Row data, row selection and expanded workspaces are intentionally excluded. */
+interface MtGridViewState {
+    readonly version: 1;
+    readonly columns: readonly MtColumnState[];
+    readonly sort: readonly MtSortModel[];
+    readonly filters: MtFilterModel;
+    readonly rowGroups: readonly string[];
+    readonly values: readonly {
+        readonly colId: string;
+        readonly aggFunc: string;
+    }[];
+    readonly pivot: {
+        readonly enabled: boolean;
+        readonly columns: readonly string[];
+    };
+}
+/** Untrusted storage is parsed at the boundary. Unknown members never survive into the saved document. */
+declare function parseGridViewState(value: unknown): MtGridViewState | null;
+declare function captureGridViewState<T>(api: MtGridApi<T>): MtGridViewState;
+/** Removed/unauthorised fields are discarded before any state is applied. */
+declare function applyGridViewState<T>(api: MtGridApi<T>, state: MtGridViewState): void;
+
+/** The editor a column uses: its `cellEditor`, else by the value's type (text by default). */
+declare function editorKindFor<T>(column: MtColumnDef<T>, value: unknown): MtCellEditorKind;
+/**
+ * The committed value of an editor: a number editor yields a number (an empty field null,
+ * other text is left as typed so a `valueParser` can decide), a checkbox a boolean, the
+ * rest the text.
+ */
+declare function parseEditedValue(kind: MtCellEditorKind, raw: unknown): unknown;
+/**
+ * Splits pasted text into rows and cells: lines by `\n` (a trailing `\r` dropped), cells by
+ * tabs; one trailing empty line (the clipboard's final newline) is ignored.
+ */
+declare function parseClipboardText(text: string): string[][];
+/**
+ * The values a fill drag writes into `count` cells after `source`: a numeric source of two
+ * or more values continues its linear sequence (the average step), a single number
+ * repeats, anything else repeats the source pattern.
+ */
+declare function fillValues(source: readonly unknown[], count: number): unknown[];
+
+interface ChartMenuGroup {
+    readonly id: string;
+    readonly label: string;
+    readonly items: readonly {
+        readonly type: MtChartType;
+        readonly label: string;
+    }[];
+}
+declare const CHART_MENU_GROUPS: readonly ChartMenuGroup[];
+declare const CHART_TYPES: readonly MtChartType[];
+declare function chartTypeLabel(type: MtChartType): string;
+
+/**
+ * Stable identity to palette colour mapping. Identities are sorted, hashed into a
+ * palette slot and probed to the next free slot, so filtering, sorting, locale or
+ * chart-type changes never reassign a category's colour; only a hash collision
+ * within one chart moves a category to its neighbouring slot.
+ */
+declare function stableCategoryColors(ids: readonly string[], fills?: readonly string[]): ReadonlyMap<string, string>;
+/** Runtime colours resolved by the host token bridge, before explicit theme overrides. */
+interface HostChartColors {
+    background: string;
+    foreground: string;
+    secondary: string;
+    border: string;
+    gridline?: string;
+    tooltipBackground: string;
+    tooltipColor: string;
+}
+
+interface MtClientQuery {
+    readonly filters?: MtFilterModel;
+    readonly sort?: readonly MtSortModel[];
+    readonly search?: string;
+    readonly quickFilterColumns?: readonly string[];
+}
+/** Apply the grid's own semantics to a verified complete client dataset (for analysis/export scopes). */
+declare function queryClientRows<T>(rows: readonly T[], columns: readonly MtColumnDef<T>[], query: MtClientQuery, getRowId: (row: T) => string): readonly T[];
+
+type MtExcelCellValue = string | number | boolean | Date | null;
+interface MtExcelWorkbookSheet {
+    readonly name: string;
+    readonly headers: readonly string[];
+    readonly rows: readonly (readonly MtExcelCellValue[])[];
+}
+/** Serialize already-authorized query results; data acquisition stays with the consuming application. */
+declare function createExcelWorkbook(sheets: readonly MtExcelWorkbookSheet[], rtl?: boolean): Promise<Blob>;
+
+interface ChartViewSettings {
+    readonly customThemes?: Readonly<Record<string, MtChartTheme>>;
+    readonly themeNames?: readonly string[];
+    readonly panels?: MtChartToolPanelsDef;
+    readonly colors: HostChartColors;
+    readonly text: MtGridLocalizer['text'];
+}
+
+/** Provide at a page/schema boundary to retain unlinked charts across source-grid destruction. */
+declare class MtGridChartScope {
+    private readonly dialogs;
+    private sequence;
+    /** Optional surviving grid/theme anchor, owned by the page rather than a module tab. */
+    themeSource?: HTMLElement;
+    /**
+     * Optional page-level host for linked chart popups: they are appended to it and
+     * sized by it instead of by the source grid, so a chart from a small nested grid
+     * still gets the whole page. It must be positioned (`position: relative`).
+     */
+    chartHost?: HTMLElement;
+    constructor();
+    /** Close every chart when the owning data/security scope changes. */
+    clear(): void;
+    /** @internal */
+    nextChartId(): string;
+    /** @internal */
+    add(dialog: ChartDialogHandle): void;
+    /** @internal */
+    remove(dialog: ChartDialogHandle): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MtGridChartScope, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MtGridChartScope>;
+}
+/** A movable chart's ownership; never retain a dead grid's component or subscriptions. */
+declare class ChartDialogHandle {
+    readonly component: ComponentRef<ChartDialog>;
+    private readonly app;
+    private readonly scope;
+    readonly api: MtChartRef;
+    readonly subscriptions: OutputRefSubscription[];
+    destroy: () => void;
+    private disposed;
+    constructor(chartId: string, component: ComponentRef<ChartDialog>, app: ApplicationRef, scope: MtGridChartScope | null);
+    retain(rawData: DerivedChartData, initial: MtCreateRangeChartParams, ranges: readonly MtChartCellRange[], settings: ChartViewSettings): void;
+    dispose(): void;
+    private unsubscribeSource;
+}
+
+export { AUTO_GROUP_COLUMN_ID, CHART_MENU_GROUPS, CHART_MISSING_CATEGORY_ID, CHART_RECORD_COUNT_ID, CHART_TYPES, DETAIL_ROW_ID_PREFIX, MT_GRID_COLUMNS_TOOL_PANEL_DEFAULTS, MT_GRID_EMPTY_OVERLAY, MT_GRID_ICONS, MtDataGridComponent, MtGridChartScope, ROW_NUMBERS_COLUMN_ID, SELECTION_COLUMN_ID, applyGridViewState, buildRowLayout, captureGridViewState, chartDistinctMeasureId, chartMeasure, chartNonEmptyMeasureId, chartTypeLabel, createExcelWorkbook, editorKindFor, fillValues, parseClipboardText, parseEditedValue, parseGridViewState, queryClientRows, rowWindowFor, sparklineGeometry, sparklineValues, stableCategoryColors };
+export type { GridIconName, MtAddCellRangeParams, MtAggFunc, MtAggFuncName, MtAggFuncParams, MtApplyColumnStateParams, MtAutoGroupColumnDef, MtAvgResult, MtBuiltInCellRenderer, MtCellClass, MtCellClassParams, MtCellClassRules, MtCellEditingStartedEvent, MtCellEditingStoppedEvent, MtCellEditorKind, MtCellEditorParams, MtCellFocusedEvent, MtCellRange, MtCellRenderer, MtCellRendererComponent, MtCellRendererFn, MtCellRendererParams, MtCellSelectionChangedEvent, MtCellSelectionOptions, MtCellStyle, MtCellValueChangedEvent, MtCellValueChangedSource, MtChartCategoryDef, MtChartCategoryParams, MtChartCategoryValue, MtChartCellRange, MtChartCreatedEvent, MtChartDataType, MtChartDestroyedEvent, MtChartImageParams, MtChartMeasureKind, MtChartModel, MtChartOptionsChangedEvent, MtChartRangeSelectionChangedEvent, MtChartRef, MtChartTheme, MtChartThemeOverrides, MtChartToolPanel, MtChartToolPanelsDef, MtChartToolbarItem, MtChartType, MtClientQuery, MtClipboardCellParams, MtClipboardGroupHeaderParams, MtClipboardHeaderParams, MtColDef, MtColumnDef, MtColumnEventSource, MtColumnFilter, MtColumnFilterModel, MtColumnGroupDef, MtColumnGroupOpenedEvent, MtColumnGroupRef, MtColumnGroupShow, MtColumnGroupState, MtColumnMovedEvent, MtColumnPinned, MtColumnPinnedEvent, MtColumnPivotChangedEvent, MtColumnPivotModeChangedEvent, MtColumnResizedEvent, MtColumnRowGroupChangedEvent, MtColumnState, MtColumnStateUpdate, MtColumnType, MtColumnValueChangedEvent, MtColumnVisibleEvent, MtColumnWidth, MtColumnsToolPanelInstance, MtColumnsToolPanelParams, MtCombinedFilterModel, MtContextMenuItem, MtContextMenuVisibleChangedEvent, MtCopyParams, MtCreatePivotChartParams, MtCreateRangeChartParams, MtCsvExportParams, MtDateFilterModel, MtDefaultMainMenuItem, MtDefaultMenuItem, MtDetailCellRendererParams, MtDetailGridOptions, MtDisplayedColumnsChangedEvent, MtEditingCell, MtExcelCellValue, MtExcelExportParams, MtExcelStyle, MtExcelWorkbookSheet, MtExpandOrCollapseAllEvent, MtExportCell, MtExportCellParams, MtExportContent, MtExportParams, MtExportRow, MtFillEvent, MtFilterChangedEvent, MtFilterChangedSource, MtFilterModel, MtFilterModifiedEvent, MtFilterOpenedEvent, MtFilterOption, MtFilterParams, MtFiltersToolPanelDef, MtFiltersToolPanelInstance, MtGetContextMenuItemsParams, MtGetDetailRowDataParams, MtGetMainMenuItemsParams, MtGridApi, MtGridEmptyOverlayParams, MtGridLocaleParams, MtGridLocaleText, MtGridLocaleTextResolver, MtGridReadyEvent, MtGridViewState, MtGroupDisplayType, MtHeaderRendererComponent, MtHeaderRendererParams, MtMainMenuItem, MtMenuActionParams, MtMenuItemDef, MtMultiFilterDef, MtMultiFilterModel, MtNumberFilterModel, MtPaginationChangedEvent, MtPasteEvent, MtPdfExportParams, MtPivotMaxColumnsExceededEvent, MtRangeChartUpdateParams, MtRowClickedEvent, MtRowDragEvent, MtRowGroupOpenedEvent, MtRowGroupPanelShow, MtRowNode, MtRowNumbersOptions, MtRowSelectedEvent, MtRowSelectionMode, MtRowSelectionOptions, MtScalarFilterType, MtSelectAllMode, MtSelectionChangedEvent, MtSelectionColumnDef, MtSelectionSource, MtSeriesChartType, MtSetFilterOption, MtSetFilterRemoteSearch, MtSetFilterSearchResult, MtSetFilterSubscribable, MtSetNodesSelectedParams, MtShowContextMenuParams, MtSideBar, MtSideBarDef, MtSimpleFilterModel, MtSortModel, MtSparklineOptions, MtSparklineType, MtStartEditingCellParams, MtStatusBarOptions, MtStatusBarPanel, MtTextFilterModel, MtTextFilterType, MtToolPanelDef, MtToolPanelKind, MtToolPanelSizeChangedEvent, MtToolPanelVisibleChangedEvent, MtToolPanelVisibleSource, MtValueParams, MtValueParserParams, MtValueSetterParams, RowLayout, SparklineBar, SparklineGeometry, SparklinePoint };