@thkl/agrid 0.1.10 → 0.1.12

package/types/thkl-agrid.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { Signal, WritableSignal, DestroyRef } from '@angular/core';
+import { Signal, WritableSignal, Type, DestroyRef, OnChanges, InjectionToken } from '@angular/core';
 import * as _thkl_agrid from '@thkl/agrid';
 
 /** Guarded access to browser-only APIs used by the grid. @internal */
@@ -34,6 +34,9 @@ declare class AgridBrowserAdapter {
     writeClipboard(text: string): Promise<boolean>;
     /** Downloads text through a temporary object URL and anchor element. */
     downloadText(filename: string, text: string, mimeType: string): boolean;
+    /** Downloads raw bytes (e.g. a generated `.xlsx`) through a temporary object URL. */
+    downloadBytes(filename: string, bytes: Uint8Array, mimeType: string): boolean;
+    private downloadBlob;
 }
 
 /**
@@ -80,6 +83,15 @@ interface ColumnFilter {
     /** Upper-bound operand used only when {@link operator} is `'between'`. */
     operand2?: string | null;
 }
+/** Transient row indication state produced by {@link AgridControl.indicate}. */
+interface AgridRowIndication {
+    /** CSS color shown while the row flash is active. */
+    color: string;
+    /** Fade duration in milliseconds. */
+    durationMs: number;
+    /** `true` while the row flash is present. */
+    active: boolean;
+}
 /** Serializable snapshot of the grid's UI state. Used with `toJSON` / `fromJSON`. */
 interface AgridControlState {
     /** Per-field column width overrides in pixels. */
@@ -147,8 +159,49 @@ declare class AgridControl {
     private readonly _totalRows;
     private readonly _aggregates;
     private readonly _sortOrder;
+    private readonly _loading;
+    private readonly _readonly;
+    private readonly _autoAddRows;
+    private readonly _rowIndications;
+    private readonly _changedCells;
+    private readonly rowIndicationTimers;
     /** @param state Optional initial state, e.g. deserialized from storage. */
     constructor(state?: Partial<AgridControlState>);
+    /** Whether the grid displays its loading overlay. This transient state is not serialized. */
+    readonly loading: Signal<boolean>;
+    /** Show or hide the grid loading overlay. */
+    setLoading(value: boolean): void;
+    /** Transient row flash indicators keyed by original datasource row index. */
+    readonly rowIndications: Signal<ReadonlyMap<number, AgridRowIndication>>;
+    /**
+     * Flash one datasource row with `color`, then fade back over `durationMs`.
+     * This is transient UI state and is not serialized.
+     */
+    indicate(rowIndex: number, color: string, durationMs?: number): void;
+    private clearRowIndicationTimers;
+    /** Changed-cell markers keyed by original datasource row index and field. */
+    readonly changedCells: Signal<ReadonlySet<string>>;
+    /** Mark one cell as changed. Used by the grid when `showChangedCellIndicator` is enabled. */
+    markChangedCell(rowIndex: number, field: string): void;
+    /**
+     * Clears changed-cell markers after persistence succeeds.
+     * Omit `rowIndex` to clear every marker; omit `fields` to clear the whole row.
+     */
+    clearChangedCells(rowIndex?: number, fields?: readonly string[]): void;
+    /** Returns whether one cell is currently marked as changed. */
+    isCellChanged(rowIndex: number, field: string): boolean;
+    /** Reconciles changed-cell markers after a datasource row is removed. */
+    reconcileChangedCellsAfterRemoval(removedIndex: number): void;
+    private changedCellKey;
+    private parseChangedCellKey;
+    /** Whether all grid editing and mutation UI is disabled. This transient state is not serialized. */
+    readonly readonly: Signal<boolean>;
+    /** Enable or disable readonly mode at runtime. */
+    setReadonly(value: boolean): void;
+    /** Whether navigation beyond the final row automatically inserts a row. Not serialized. */
+    readonly autoAddRows: Signal<boolean>;
+    /** Enable or disable automatic row insertion at runtime. */
+    setAutoAddRows(value: boolean): void;
     /**
      * When `true`, the control column shows a drag handle and rows can be
      * reordered by dragging. Requires `showControlColumn` to be enabled on the grid.
@@ -353,6 +406,12 @@ declare class AgridControl {
     hasActiveFilter(field: string): boolean;
     /** Return `true` when the quick filter or ANY column has an active filter or sort. */
     hasAnyActiveFilter(): boolean;
+    /**
+     * Replace the live serializable state from a plain object.
+     * Missing properties reset to their defaults, making a loaded snapshot deterministic.
+     * Transient loading, readonly, auto-add, selection, and edit-history state are preserved.
+     */
+    loadState(state: Partial<AgridControlState>): void;
     /** Serialize current state to a plain object suitable for JSON storage. */
     toJSON(): AgridControlState;
     /** Restore an `AgridControl` from a previously serialized state. */
@@ -446,7 +505,83 @@ declare class AgridDataSource<T extends object = any> {
     /** Current number of rows (non-reactive snapshot). */
     get length(): number;
     private updateRows;
-    private setRows;
+    /** Replace the backing row array without copying. Intended for specialized datasource models. */
+    protected setRows(rows: T[]): void;
+}
+
+/** Sort entry sent to a server-side row datasource. */
+interface AgridServerSideSort {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+/** Immutable request for one half-open row block (`startRow <= row < endRow`). */
+interface AgridServerSideRequest {
+    startRow: number;
+    endRow: number;
+    filters: Readonly<Record<string, ColumnFilter>>;
+    sort: readonly AgridServerSideSort[];
+    quickFilter: string;
+}
+/** Rows returned by a server-side datasource. Supply `rowCount` when the total is known. */
+interface AgridServerSideResult<T extends object> {
+    rows: T[];
+    rowCount?: number;
+}
+/** Fetches blocks for {@link AgridServerSideRowModel}. */
+interface AgridServerSideDatasource<T extends object> {
+    getRows(request: AgridServerSideRequest): Promise<AgridServerSideResult<T>>;
+}
+/** Configuration for the lazy, block-cached server-side row model. */
+interface AgridServerSideRowModelConfig<T extends object> {
+    datasource: AgridServerSideDatasource<T>;
+    /** Number of rows requested per block. @default 100 */
+    blockSize?: number;
+    /** Maximum loaded blocks retained in memory. @default 10 */
+    maxBlocksInCache?: number;
+    /** Known initial total. Omit when the server determines it from the first request. */
+    initialRowCount?: number;
+}
+/**
+ * Sparse datasource that lazy-loads row blocks while retaining global datasource indices.
+ * Attach it to an `AgridProvider` through `serverSideRowModel`.
+ */
+declare class AgridServerSideRowModel<T extends object = any> extends AgridDataSource<T> {
+    readonly blockSize: number;
+    readonly maxBlocksInCache: number;
+    private readonly remote;
+    private slots;
+    private readonly loadedBlocks;
+    private readonly loadingBlocks;
+    private query;
+    private queryKey;
+    private generation;
+    private accessSequence;
+    private knownRowCount;
+    private readonly _loading;
+    private readonly _error;
+    private readonly _rowCount;
+    /** Whether at least one block request is in flight. */
+    readonly loading: Signal<boolean>;
+    /** Most recent load error, cleared by the next successful request or refresh. */
+    readonly error: Signal<unknown | null>;
+    /** Current logical row count represented by the virtual scrollbar. */
+    readonly rowCount: Signal<number>;
+    constructor(config: AgridServerSideRowModelConfig<T>);
+    /** Update server query state. A changed query invalidates cached blocks and starts at row zero. */
+    setQuery(control: AgridControl | null, sortFields: readonly string[]): boolean;
+    /** Invalidate all cached blocks while preserving a known total row count. */
+    refresh(): void;
+    /** Ensure every block intersecting the requested half-open range is loaded. */
+    ensureRange(startRow: number, endRow: number): void;
+    /** Whether a logical datasource row has not been loaded yet. */
+    isPlaceholder(index: number): boolean;
+    private reset;
+    private loadBlock;
+    private applyBlock;
+    private evictBlocks;
+    private resize;
+    private replaceSlots;
+    private createPlaceholders;
 }
 
 /** Built-in locale identifiers supplied by the grid. */
@@ -458,6 +593,7 @@ interface AgridLocaleText {
     aggregate: string;
     aggregateAvg: string;
     aggregateCount: string;
+    aggregateCustom: string;
     aggregateMax: string;
     aggregateMin: string;
     aggregateSum: string;
@@ -469,6 +605,7 @@ interface AgridLocaleText {
     close: string;
     columnMenu: string;
     columns: string;
+    collapse: string;
     detail: string;
     toggleDetail: string;
     hiddenColumn: string;
@@ -508,9 +645,15 @@ interface AgridLocaleText {
     lastPage: string;
     loading: string;
     markRow: string;
+    moreInformation: string;
     next: string;
     noRows: string;
     pagination: string;
+    pivot: string;
+    pivotDescription: string;
+    pivotRows: string;
+    pivotColumns: string;
+    pivotValues: string;
     pinColumn: string;
     pinColumnRight: string;
     unpinColumnRight: string;
@@ -519,6 +662,7 @@ interface AgridLocaleText {
     unpinRow: string;
     previous: string;
     resizeColumn: string;
+    expand: string;
     rows: (count: number) => string;
     quickFilterPlaceholder: string;
     searchValuesPlaceholder: string;
@@ -529,26 +673,61 @@ interface AgridLocaleText {
     ungroup: string;
     unpinColumn: string;
     save: string;
+    saveConfig: string;
+    export: string;
+    exportCsv: string;
+    exportXlsx: string;
+    templates: string;
 }
 /** Partial locale text supplied to {@link AgridProvider.addLocalization}. */
 type AgridLocaleTextOverrides = Partial<AgridLocaleText>;
 /** Built-in English and German grid translations. */
 declare const AGRID_LOCALE_TEXT: Record<AgridLocaleKey, AgridLocaleText>;
 
+/** JSON-safe pivot subset used by persisted grid settings. */
+interface AgridPivotSettings {
+    rowField: string;
+    columnField: string;
+    valueField: string;
+    aggregate: 'sum' | 'avg' | 'min' | 'max' | 'count';
+}
+/**
+ * Versioned, JSON-safe snapshot that can be stored in local storage or a backend.
+ * Functions, datasource rows, selection, loading state, and edit history are intentionally absent.
+ */
+interface AgridSettings {
+    version: 1;
+    control: AgridControlState;
+    pivotConfig: AgridPivotSettings | null;
+}
 /** Configuration used to create an {@link AgridProvider}. */
 interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptions> {
     /** Row data source. A new empty data source is created when omitted. */
     datasource?: AgridDataSource<T>;
+    /**
+     * Lazy block-based server-side row model. When supplied it becomes the provider datasource and
+     * filtering, sorting, and quick filtering are included in block requests automatically.
+     */
+    serverSideRowModel?: AgridServerSideRowModel<T>;
     /** Stateful grid control. A default control is created when omitted. */
     control?: AgridControl;
     /** Initial column definitions in display order. */
     columns?: ColDef<T>[];
+    /**
+     * Derive a read-only client-side pivot table from the datasource.
+     * The first release supports one row field, one column field, and one value field.
+     * Enable `showSidebar` to let users change this configuration from the grid's Pivot tab.
+     */
+    pivotConfig?: AgridPivotConfig<T>;
     /** Labels used by columns with a matching `group` identifier. */
     headerGroups?: HeaderGroup[];
     /**
      * Render rows as a hierarchical tree. When set, rows are nested by the configured
      * parent/child accessors and an expand/collapse twisty is shown on `treeField`.
-     * Mutually exclusive with grouping and pagination.
+     *
+     * Set `aggregateTreeNodes` in this configuration to display each aggregate column's
+     * descendant-leaf rollup on expandable nodes. Tree mode is mutually exclusive with grouping
+     * and pagination.
      */
     treeConfig?: AgridTreeConfig<T>;
     /** Row height in pixels. Must be fixed for CDK virtual scroll. @default 32 */
@@ -565,13 +744,16 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     showControlColumn?: boolean;
     /** Show row-marking checkboxes in a 48 px control column for clipboard inclusion. @default false */
     enableRowMarking?: boolean;
+    /** Allow clicking column headers to mark complete columns. @default false */
+    enableColumnMarking?: boolean;
     /** Show the sidebar panel. */
     showSidebar?: boolean;
     /** Automatically open the detail panel when a row is selected. */
     autoOpenDetail?: boolean;
     /**
      * Emit filter and sort changes for server processing instead of applying them locally.
-     * The Excel-style value picker is hidden in this mode. @default false
+     * The distinct-value picker is hidden unless the column supplies an explicit `values` list.
+     * @default false
      */
     serverSideFiltering?: boolean;
     /** Delay before emitting server-side text filter changes. Set to `0` to disable. @default 300 */
@@ -618,6 +800,12 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     cellMenuItems?: (CellContextMenuItem<T> | null)[];
     /** Shade every other row slightly for easier reading. @default false */
     zebraStripes?: boolean;
+    /**
+     * Render only the scrollable columns near the horizontal viewport once the scrollable-column
+     * count exceeds this threshold. Lower it to virtualize sooner, or set a very large value
+     * (e.g. `Infinity`) to disable column virtualization entirely. @default 30
+     */
+    columnVirtualizationThreshold?: number;
     /** Show a color marker on cells changed through grid editing. @default false */
     showChangedCellIndicator?: boolean;
     /** Ask for confirmation before grid row-delete actions. @default false */
@@ -674,8 +862,18 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     detailRenderer?: (params: {
         row: T;
     }) => string;
+    /** Column displayed as a multiline editable field beneath the custom detail renderer. */
+    detailColumnField?: AgridField<T>;
+    /** Optional text-template buttons shown above the editable master/detail textarea. */
+    detailActions?: DetailAction<T>[];
     /** Fixed height in pixels of an expanded detail panel row. @default 200 */
     detailRowHeight?: number;
+    /** this is the id of the grid its stored in the provider the grid will read it as signal */
+    gridId?: string;
+    /** Hides the grids status bar if set to true. @default false */
+    hideGridStatusBar?: boolean;
+    /** Enable Menubuttons for csv and xsls export @default false */
+    enableExportButtons?: boolean;
 }
 /**
  * Bundles a grid's data source, control state, columns, and display options.
@@ -683,13 +881,31 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
  * Create one provider per independent grid instance. A provider may be selected
  * from an array when a component renders multiple grids.
  */
+/**
+ * Live export hooks installed by the rendered grid component so the provider can export the
+ * grid's current filtered/visible projection without the caller holding a component reference.
+ * @internal
+ */
+interface AgridExportBridge {
+    csv: (filename: string) => void;
+    xlsx: (filename: string) => void;
+}
 declare class AgridProvider<T extends object = any> {
     /** Mutable row data consumed by the grid. */
     datasource: AgridDataSource<T>;
+    /** Lazy server-side model, or `null` for the regular client-side datasource. */
+    serverSideRowModel: AgridServerSideRowModel<T> | null;
     /** Runtime UI state and imperative grid controls. */
     control: AgridControl;
     /** Reactive column definitions in display order. */
     readonly columns: WritableSignal<ColDef<T>[]>;
+    private readonly _pivotConfig;
+    /**
+     * Client-side pivot configuration, or `null` for the normal row view.
+     * Assigning a new configuration reactively rebuilds the derived pivot rows and columns.
+     */
+    get pivotConfig(): AgridPivotConfig<T> | null;
+    set pivotConfig(config: AgridPivotConfig<T> | null);
     /** Header-group labels referenced by column definitions. */
     headerGroups: HeaderGroup[];
     /** Tree configuration, or `null` when the grid is not in tree mode. */
@@ -697,6 +913,20 @@ declare class AgridProvider<T extends object = any> {
     /** Shared grid options such as locale. */
     options: AGridOptions;
     private readonly _localizations;
+    private exportBridge;
+    private readonly _visibleRows;
+    /**
+     * The grid's currently filtered and sorted rows, as published by the rendered grid component.
+     * Falls back to every datasource row when no grid is attached. Link a chart to this signal to
+     * keep it in sync with the grid's filters and sorting.
+     */
+    readonly visibleRows: Signal<readonly T[]>;
+    /**
+     * @internal Published by the rendered grid whenever its filtered/sorted projection changes.
+     * Pass `null` on teardown so {@link visibleRows} falls back to the raw datasource. The grid works
+     * in terms of record rows; the public {@link visibleRows} re-types them as `T`.
+     */
+    ɵsetVisibleRows(rows: readonly Record<string, unknown>[] | null): void;
     /** Read-only view of registered per-locale text overrides. Used by the grid to resolve locale text. */
     get localizations(): ReadonlyMap<string, AgridLocaleTextOverrides>;
     /**
@@ -720,6 +950,8 @@ declare class AgridProvider<T extends object = any> {
     showControlColumn: boolean;
     /** Whether rows can be marked for inclusion in clipboard copies. */
     enableRowMarking: boolean;
+    /** Whether complete columns can be marked from their headers. */
+    enableColumnMarking: boolean;
     /** Whether the sidebar is available. */
     showSidebar: boolean;
     /** Whether selecting a row automatically opens its detail panel. */
@@ -734,7 +966,7 @@ declare class AgridProvider<T extends object = any> {
     menuBarItems: AgridMenuBarItem<T>[];
     /** Enabled sorting mode. */
     sortOption: 'single' | 'multi' | 'none';
-    /** Toggle auto-add-rows without recreating the provider. @default signal(false) */
+    /** @deprecated Use `control.autoAddRows` and `control.setAutoAddRows()` instead. */
     readonly autoAddRows: WritableSignal<boolean>;
     /** Enabled row-selection mode. */
     rowSelection: 'single' | 'multi' | 'none';
@@ -748,6 +980,8 @@ declare class AgridProvider<T extends object = any> {
     cellMenuItems: (CellContextMenuItem<T> | null)[];
     /** Whether alternating data rows receive stripe styling. */
     zebraStripes: boolean;
+    /** Scrollable-column count above which column virtualization activates. */
+    columnVirtualizationThreshold: number;
     /** Whether committed cell changes receive a visual marker. */
     showChangedCellIndicator: boolean;
     /** Whether grid row-delete actions require in-row confirmation. */
@@ -769,20 +1003,84 @@ declare class AgridProvider<T extends object = any> {
     detailRenderer?: (params: {
         row: T;
     }) => string;
+    /** Column displayed as a multiline field inside expanded detail panels. */
+    detailColumnField?: AgridField<T>;
+    /** Text-template buttons shown above the editable master/detail textarea. */
+    detailActions: DetailAction<T>[];
     /** Fixed height in pixels of an expanded detail panel row. */
     detailRowHeight: number;
-    /** Toggle the loading overlay without recreating the provider. @default signal(false) */
+    /** its used to save the config  */
+    gridId?: string;
+    /** Hides the summary status bar */
+    hideGridStatusBar?: boolean;
+    /** Enables export Menu if true */
+    enableExportButtons?: boolean;
+    /** @deprecated Use `control.loading` and `control.setLoading()` instead. */
     readonly loading: WritableSignal<boolean>;
-    /** Toggle readonly mode without recreating the provider. @default signal(false) */
+    /** @deprecated Use `control.readonly` and `control.setReadonly()` instead. */
     readonly readonlyGrid: WritableSignal<boolean>;
     /** Creates a provider from the supplied data, state, columns, and display options. */
     constructor(config?: AgridProviderConfig<T>);
     /** Returns the current reactive row array. */
     getGridData(): T[];
+    /**
+     * Return a detached, JSON-safe snapshot of persistent grid and pivot settings.
+     * Custom pivot aggregate functions cannot be serialized and produce an explicit error.
+     */
+    saveSettings(): AgridSettings;
+    /**
+     * Apply a previously saved snapshot to this live provider.
+     * Existing component instances update immediately because both control and pivot state are
+     * signal-backed. Unknown versions and pivot fields fail early with actionable errors.
+     */
+    loadSettings(settings: AgridSettings): void;
+    /**
+     * Download the grid's current filtered, visible rows as a CSV file.
+     *
+     * Uses display values (value-list labels, formatters) and respects column visibility; group
+     * header rows are excluded. Requires a rendered `<agrid>` bound to this provider — when no grid
+     * is mounted (e.g. before first render) this is a no-op.
+     *
+     * @param filename  Output filename, defaults to `'export.csv'`.
+     */
+    exportCsv(filename?: string): void;
+    /**
+     * Download the grid's current filtered, visible rows as an `.xlsx` workbook.
+     *
+     * Numbers and dates are written as native, sortable/summable cells; value-list columns and
+     * custom formatters fall back to display text. Requires a rendered `<agrid>` bound to this
+     * provider — a no-op when no grid is mounted. Generated with zero third-party dependencies.
+     *
+     * @param filename  Output filename, defaults to `'export.xlsx'`.
+     */
+    exportXlsx(filename?: string): void;
+    /**
+     * @internal Installed by the rendered `<agrid>` so {@link exportCsv}/{@link exportXlsx} reach the
+     * live projection. Pass `null` on teardown.
+     */
+    ɵattachExport(bridge: AgridExportBridge | null): void;
 }
 
 /** String-valued property names available on a row type. */
 type AgridField<T extends object> = Extract<keyof T, string>;
+/** Aggregate functions shared by footers, groups, tree rollups, and pivot values. */
+type AgridAggregate = 'sum' | 'avg' | 'min' | 'max' | 'count' | ((values: unknown[]) => unknown);
+/**
+ * Client-side pivot-table configuration.
+ *
+ * The initial pivot implementation supports one row dimension, one column dimension, and one
+ * value field. The resulting table is derived from the datasource and is always read-only.
+ */
+interface AgridPivotConfig<T extends object = any> {
+    /** Source field whose distinct values become pivot rows. */
+    rowField: AgridField<T>;
+    /** Source field whose distinct values become generated pivot columns. */
+    columnField: AgridField<T>;
+    /** Source field aggregated at each row/column intersection. */
+    valueField: AgridField<T>;
+    /** Aggregate applied to each intersection. Defaults to `'sum'`. */
+    aggregate?: AgridAggregate;
+}
 /** Behavior after pressing Enter while an inline cell editor is active. */
 type AgridEnterEditAction = 'nothing' | 'nextColumn' | 'nextRow';
 /** Parameters passed to a row-aware cell readonly resolver. */
@@ -796,6 +1094,33 @@ interface CellReadonlyParams<T extends object = any, K extends AgridField<T> = A
     /** Zero-based index of the row in the datasource. */
     originalIndex: number;
 }
+/** Parameters passed to a row-aware cell formatting resolver. */
+type CellFormatParams<T extends object = any, K extends AgridField<T> = AgridField<T>> = CellReadonlyParams<T, K>;
+/** Parameters passed to a row-aware horizontal cell-span resolver. */
+type CellSpanParams<T extends object = any, K extends AgridField<T> = AgridField<T>> = CellReadonlyParams<T, K>;
+/** Supported visual overrides returned by {@link ColDefBase.cellFormat}. */
+interface CellFormat {
+    /** CSS background color, such as `'#fff4cc'` or `'var(--warning-bg)'`. */
+    backgroundColor?: string;
+    /** CSS border color. The cell's existing right and bottom borders use this color. */
+    borderColor?: string;
+    /** CSS text color. */
+    color?: string;
+    /** CSS `font` shorthand. Individual font properties below can override parts of it. */
+    font?: string;
+    /** CSS font family. */
+    fontFamily?: string;
+    /** CSS font size, including its unit (for example `'0.875rem'`). */
+    fontSize?: string;
+    /** CSS font style. */
+    fontStyle?: 'normal' | 'italic' | 'oblique' | string;
+    /** CSS font weight. */
+    fontWeight?: string | number;
+    /** CSS text decoration. */
+    textDecoration?: string;
+    /** CSS horizontal text alignment. */
+    textAlign?: 'left' | 'right' | 'center' | 'justify' | string;
+}
 /** Global options shared by grid providers. */
 interface AGridOptions {
     /**
@@ -855,6 +1180,8 @@ interface AgridMenuBarMenuItem<T extends object = any> {
     active?: AgridMenuBarState<T>;
     /** Whether the command is disabled. Defaults to `false`. */
     disabled?: AgridMenuBarState<T>;
+    /** Additional classes */
+    class?: string;
 }
 /** Top-level menu-bar button with optional additional dropdown commands. */
 interface AgridMenuBarItem<T extends object = any> extends AgridMenuBarMenuItem<T> {
@@ -888,6 +1215,21 @@ interface HeaderGroup {
     /** Text displayed in the grouped header row. */
     label: string;
 }
+/** Custom command appended to a column's header menu. */
+interface AgridColumnHeaderMenuItem {
+    /** Stable key emitted through `(columnHeaderAction)`. */
+    key: string;
+    /** Visible command label. */
+    label: string;
+    /** Optional compact icon or glyph shown before the label. */
+    icon?: string;
+    /** Disable the command without hiding it. */
+    disabled?: boolean;
+    /** Class a optional classes for the icon */
+    iconClasses?: string[];
+    /** Classes to apply on the complete button */
+    itemClasses?: string[];
+}
 /** Defines the behavior shared by every typed column. */
 interface ColDefBase<T extends object, K extends AgridField<T>> {
     /** Data field name — must match a key in the row object. */
@@ -896,6 +1238,8 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
     header: string;
     /** Optional header-group identifier configured through `AgridProvider.headerGroups`. */
     group?: string;
+    /** Custom commands appended to this column's header menu. */
+    headerMenuItems?: AgridColumnHeaderMenuItem[];
     /**
      * Default column width in pixels. Can be overridden at runtime via {@link AgridControl}.
      * Use `-1` (or omit) to make the column auto-scale and fill available space (`1fr`).
@@ -926,6 +1270,40 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * ```
      */
     cellReadonly?: (params: CellReadonlyParams<T, K>) => boolean;
+    /**
+     * Return visual overrides for this specific cell at runtime.
+     * Runs with the current row, value, column definition, and original datasource index.
+     * Return `null` or `undefined` to use the grid's normal styling.
+     *
+     * @example
+     * ```ts
+     * {
+     *   field: 'balance',
+     *   cellFormat: ({ value }) => value < 0
+     *     ? { backgroundColor: '#fee2e2', color: '#991b1b', fontWeight: 600 }
+     *     : undefined,
+     * }
+     * ```
+     */
+    cellFormat?: (params: CellFormatParams<T, K>) => CellFormat | null | undefined;
+    /**
+     * Default horizontal alignment for every cell in this column.
+     * A `textAlign` returned by {@link cellFormat} overrides this value for that cell.
+     */
+    textAlign?: 'left' | 'center' | 'right' | Signal<'left' | 'center' | 'right'>;
+    /**
+     * Number of adjacent visible columns occupied by this cell.
+     *
+     * Spans are clamped to the current left-pinned, scrollable, or right-pinned pane and never
+     * cross a pane boundary. Covered cells remain part of the data model but are not rendered.
+     * Return `1` (the default) to render a normal cell.
+     *
+     * @example
+     * ```ts
+     * { field: 'name', colSpan: ({ row }) => row.isSummary ? 3 : 1 }
+     * ```
+     */
+    colSpan?: number | ((params: CellSpanParams<T, K>) => number);
     /**
      * Fixed list of allowed values shown in a `<select>` dropdown when editing.
      *
@@ -996,7 +1374,7 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * { field: 'score',  aggregate: values => values.filter(v => Number(v) > 90).length }
      * ```
      */
-    aggregate?: 'sum' | 'avg' | 'min' | 'max' | 'count' | ((values: unknown[]) => unknown);
+    aggregate?: AgridAggregate;
     /**
      * Return one or more CSS class names to apply to every cell in this column based on the
      * cell's value and row data. Useful for conditional highlighting without a custom renderer.
@@ -1026,10 +1404,26 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * ```
      */
     validate?: (value: T[K], row: T) => string | null | undefined;
+    /**
+     * Custom component rendered for the cell's display (read) state, instead of the plain text value.
+     * The component injects {@link AGRID_RENDERER_CONTEXT} to read the value, row, and column. Unlike
+     * {@link cellRenderer}, this supports full Angular bindings, event handlers, and child components
+     * with no manual escaping.
+     *
+     * @example
+     * ```ts
+     * { field: 'status', cellRendererComponent: StatusBadgeComponent }
+     * ```
+     */
+    cellRendererComponent?: Type<unknown>;
     /**
      * Custom cell renderer. Returns an HTML string displayed instead of the plain text value.
      * Angular's built-in HTML sanitization is applied automatically.
      *
+     * @deprecated Use {@link cellRendererComponent} instead. A component renderer supports Angular
+     * bindings and event handlers, and avoids the HTML-string escaping/sanitization caveats. The
+     * string renderer remains supported for now but will be removed in a future release.
+     *
      * @example
      * ```ts
      * { field: 'status', cellRenderer: ({ value }) =>
@@ -1040,6 +1434,18 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
         value: T[K];
         row: T;
     }) => string;
+    /**
+     * Custom editor component shown while the cell is in edit mode, instead of the built-in
+     * text input / dropdown / checkbox. The component injects {@link AGRID_EDITOR_CONTEXT} to read
+     * the current value and stage drafts; the grid keeps ownership of validation, history, and the
+     * commit/cancel lifecycle, so Tab, Enter, and Escape work without extra wiring.
+     *
+     * @example
+     * ```ts
+     * { field: 'rating', cellEditor: RatingEditor }
+     * ```
+     */
+    cellEditor?: Type<unknown>;
     /**
      * Show a right-aligned info button in this column's cells.
      * Pass a predicate to show it only for selected rows or values.
@@ -1070,6 +1476,21 @@ interface GroupAction {
     /** Called with the group's display label when the item is clicked. */
     action: (groupLabel: string) => void;
 }
+/** Parameters passed to a master/detail text-template action. */
+interface DetailActionParams<T extends object = any> {
+    /** Row shown by the expanded detail panel. */
+    row: T;
+    /** Original datasource index of the row. */
+    rowIndex: number;
+}
+/** Text-template button shown above the editable master/detail textarea. */
+interface DetailAction<T extends object = any> {
+    id: string;
+    /** Button text. */
+    label: string;
+    /** Text inserted into the detail textarea, or a row-aware resolver. */
+    text?: string | ((params: DetailActionParams<T>) => string);
+}
 /**
  * Internal row item used in the virtual scroll list.
  * - `{ row, originalIndex }` — a real data row
@@ -1082,6 +1503,9 @@ interface GroupAction {
 type GridItem<T extends object = Record<string, unknown>> = {
     row: T;
     originalIndex: number;
+} | {
+    loading: true;
+    originalIndex: number;
 } | null | 'ghost' | {
     groupLabel: string;
     count: number;
@@ -1102,6 +1526,13 @@ interface PathTreeNodeItem {
     expandable: true;
     /** Whether the branch's descendants are currently visible. */
     expanded: boolean;
+    /**
+     * Field-to-value rollups computed from all datasource leaves below this generated branch.
+     * Present only when the grid enables {@link AgridTreeConfig.aggregateTreeNodes}; standalone
+     * trees do not compute column aggregates.
+     * @internal
+     */
+    aggregates?: Record<string, unknown>;
 }
 /**
  * A master/detail panel row rendered immediately beneath its expanded parent data row.
@@ -1136,6 +1567,12 @@ interface TreeRowItem<T extends object = Record<string, unknown>> {
     expanded: boolean;
     /** Optional display-only label for the tree cell, used by path-based trees. */
     treeLabel?: string;
+    /**
+     * Field-to-value rollups computed from this node's descendant leaves. Parent rows are excluded
+     * so a stored subtotal is not counted again. Present only for expandable rows when enabled.
+     * @internal
+     */
+    aggregates?: Record<string, unknown>;
 }
 /**
  * Host-supplied configuration that turns the grid into a tree.
@@ -1169,6 +1606,35 @@ interface AgridTreeConfigBase<T extends object> {
      * Defaults to `true`. (Applied by the projection layer, not by {@link GridItem} flattening.)
      */
     keepAncestorsOnFilter?: boolean;
+    /**
+     * Display aggregate-column rollups on expandable nodes in `AgridComponent` tree mode.
+     *
+     * Parent/id trees aggregate descendant leaves and deliberately exclude intermediate parent
+     * values to avoid counting stored subtotals twice. Generated path branches aggregate every
+     * datasource leaf below that branch. Expansion does not affect the result, while active filters
+     * limit the contributing leaves. Aggregate cells on datasource-backed parents are display-only.
+     *
+     * The function comes from {@link ColDef.aggregate} or a runtime
+     * `AgridControl.setAggregate()` override. The standalone `AgridTreeComponent` has no columns and
+     * therefore ignores this option.
+     *
+     * @default false
+     * @example
+     * ```ts
+     * const columns = [
+     *   { field: 'name', header: 'Name' },
+     *   { field: 'amount', header: 'Amount', aggregate: 'sum' },
+     * ];
+     *
+     * const treeConfig = {
+     *   getId: row => row.id,
+     *   getParentId: row => row.parentId,
+     *   treeField: 'name',
+     *   aggregateTreeNodes: true,
+     * };
+     * ```
+     */
+    aggregateTreeNodes?: boolean;
 }
 /** Tree configuration for rows that already expose stable id and parent-id values. */
 interface AgridParentTreeConfig<T extends object = any> extends AgridTreeConfigBase<T> {
@@ -1251,7 +1717,7 @@ interface ValidationFailedEvent<T extends object = any> {
     /** Message returned by the `validate` hook. */
     message: string;
     /** Which editing surface produced the rejected edit. */
-    source: 'inline' | 'sidebar';
+    source: 'inline' | 'sidebar' | 'detail';
 }
 /** Emitted by `(cellEdit)` after the user commits a cell change. */
 type GridEditEvent<T extends object = any> = {
@@ -1313,6 +1779,45 @@ interface RowSelectEvent<T extends object = any> {
         originalIndex: number;
     }[];
 }
+/** Emitted when a row is marked or unmarked through the row header or marker checkbox. */
+interface RowMarkEvent<T extends object = any> {
+    /** Row whose mark state changed. */
+    row: T;
+    /** Zero-based index of the row in the data source. */
+    originalIndex: number;
+    /** Current mark state after the interaction. */
+    marked: boolean;
+}
+/** Emitted when a column is marked or unmarked from its header. */
+interface ColumnMarkEvent<T extends object = any> {
+    column: ColDef<T>;
+    field: AgridField<T>;
+    marked: boolean;
+}
+/** Emitted when a custom column-header menu command is selected. */
+interface ColumnHeaderActionEvent<T extends object = any> {
+    column: ColDef<T>;
+    key: string;
+}
+/** Emitted once after the grid first renders with rows from its active datasource. */
+interface FirstDataRenderedEvent<T extends object = any> {
+    /** Rows present in the datasource for the first non-empty render. */
+    rows: readonly T[];
+    /** Number of rows present for that render. */
+    rowCount: number;
+    /** Provider attached to the rendered grid. */
+    provider: AgridProvider<T>;
+    /** Active datasource that supplied the rows. */
+    datasource: AgridDataSource<T>;
+}
+/** Live numeric statistics for the active cell or range selection. */
+interface AgridSelectionSummary {
+    count: number;
+    sum: number;
+    average: number;
+    min: number;
+    max: number;
+}
 /** Emitted when the user clicks a data row. */
 interface RowClickEvent<T extends object = any> {
     /** Snapshot of the clicked row. */
@@ -1344,6 +1849,14 @@ interface RowUpdateEvent<T extends object = any> {
     /** Zero-based index of the updated row in the data source. */
     originalIndex: number;
 }
+interface RowDetailActionEvent<T extends object = any> {
+    /** the id of the button */
+    id: string;
+    /** Updated row data. */
+    row: T;
+    /** Zero-based index of the updated row in the data source. */
+    originalIndex: number;
+}
 /**
  * Emitted by `(rowReorder)` when the user finishes dragging a row to a new position.
  * The grid does **not** reorder data itself — call `dataSource.moveRow(oldIndex, newIndex)`
@@ -1415,6 +1928,50 @@ interface NewRecord<T extends object = any> {
     /** Exact data source containing the inserted row. */
     datasource: AgridDataSource<T>;
 }
+/**
+ * Precomputed per-column header state. @internal
+ *
+ * The header/filter rows would otherwise call a dozen helpers per column on every
+ * change-detection pass (e.g. `getSort`, `hasActiveFilter`, `isColDragging`). The header
+ * view-model computeds resolve all of that once per column — and only when an underlying
+ * signal changes — so the template reads plain fields instead.
+ */
+interface AgridHeaderColumn {
+    col: ColDef;
+    field: string;
+    ariaColIndex: number;
+    sort: 'asc' | 'desc' | null;
+    sortPriority: number;
+    hasFilter: boolean;
+    dragging: boolean;
+    dropSide: 'before' | 'after' | null;
+    reorderOffset: number;
+    grouped: boolean;
+    lastPinned: boolean;
+    firstRightPinned: boolean;
+    columnWidth: number;
+    textFilter: string;
+    menuFilterType: 'text' | 'number' | 'date' | null;
+    hasCondition: boolean;
+    conditionLabel: string;
+}
+/**
+ * Precomputed per-column state for the data-row, footer, and ghost cell loops. @internal
+ *
+ * Deliberately leaner than {@link AgridHeaderColumn}: it omits sort/filter state so the body
+ * view-model only changes on column layout, drag, or pinning — sorting or filtering does not
+ * invalidate it (and therefore does not force every rendered cell to re-render).
+ */
+interface AgridBodyColumn {
+    col: ColDef;
+    field: string;
+    visibleColIndex: number;
+    ariaColIndex: number;
+    dragging: boolean;
+    reorderOffset: number;
+    lastPinned: boolean;
+    firstRightPinned: boolean;
+}
 
 /** View state for the floating column header shown during a reorder drag. @internal */
 interface AgridColumnDragPreview {
@@ -1471,17 +2028,26 @@ interface AgridColumnMenuValueItem {
 /** Position and target field of the open column menu. @internal */
 type AgridColumnMenuState = {
     field: string;
+    mode: 'column' | 'condition';
     x: number;
     y: number;
 };
 
-/** One contiguous segment in the optional grouped-header row. @internal */
-interface AgridHeaderGroupRun {
-    key: string;
-    id: string | null;
-    label: string;
-    fields: string[];
-    span: number;
+/**
+ * The contiguous slice of scrollable columns to render, plus the pixel widths of the
+ * hidden columns on either side (used to size leading/trailing spacer grid items so the
+ * full column layout and scroll width are preserved).
+ * @internal
+ */
+interface AgridColumnWindow {
+    /** Index of the first rendered scrollable column (inclusive). */
+    start: number;
+    /** Index just past the last rendered scrollable column (exclusive). */
+    end: number;
+    /** Combined width of the hidden columns before {@link start}. */
+    leftWidth: number;
+    /** Combined width of the hidden columns from {@link end} onward. */
+    rightWidth: number;
 }
 
 /** Rectangular bounds in projected row and visible column coordinates. @internal */
@@ -1492,6 +2058,20 @@ type VisibleCellBounds = {
     colEnd: number;
 };
 
+/** One contiguous segment in the optional grouped-header row. @internal */
+interface AgridHeaderGroupRun {
+    key: string;
+    id: string | null;
+    label: string;
+    fields: string[];
+    span: number;
+}
+/** A grouped-header run enriched with reactive lock/drag state. @internal */
+interface AgridHeaderGroup extends AgridHeaderGroupRun {
+    locked: boolean;
+    dragging: boolean;
+}
+
 /** Dependencies and callbacks required by {@link AgridDragHandler}. @internal */
 interface AgridDragHandlerOptions {
     dataSource: Signal<AgridDataSource>;
@@ -1568,6 +2148,8 @@ declare class AgridTreeController {
     collapseAll(): void;
 }
 
+/** Tabs available from the grid's vertical sidebar strip. @internal */
+type AgridSidebarTab = 'columns' | 'detail' | 'pivot';
 /** Field edit emitted by the sidebar detail form. @internal */
 interface AgridSidebarEdit {
     /** Data field being edited. */
@@ -1607,6 +2189,9 @@ interface AgridSidebarDetailField {
  * | Key | Action |
  * |-----|--------|
  * | Arrow keys | Move selection |
+ * | Page Up / Page Down | Move by one visible viewport page |
+ * | Home / End | Move to the first / last cell in the current row |
+ * | Ctrl/Cmd+Home / Ctrl/Cmd+End | Move to the first / last cell in the grid |
  * | Tab / Shift+Tab | Move right / left (wraps rows) |
  * | Enter | Enter edit mode |
  * | Ctrl/Cmd+Enter | Toggle an expandable tree node |
@@ -1615,23 +2200,25 @@ interface AgridSidebarDetailField {
  * | Escape | Close any open menu or cancel edit |
  * | Tab / Enter (while editing) | Commit and move according to navigation settings |
  */
-declare class AgridComponent<T extends object = any> {
+declare class AgridComponent<T extends object = any> implements OnChanges {
     /** Grid provider containing columns, data source, control, and options. */
     provider: _angular_core.InputSignal<AgridProvider<T>>;
+    private restoredProvider?;
     readonly rowHeight: Signal<number>;
     readonly minHeight: Signal<string | undefined>;
     readonly maxHeight: Signal<string | undefined>;
     readonly allowAddRows: Signal<boolean>;
     readonly autoAddRows: Signal<boolean>;
     readonly enableRowMarking: Signal<boolean>;
+    readonly enableColumnMarking: Signal<boolean>;
     readonly showControlColumn: Signal<boolean>;
-    readonly controlColumnWidth: Signal<48 | 24>;
+    readonly controlColumnWidth: Signal<24 | 48>;
     readonly showSidebar: Signal<boolean>;
     readonly autoOpenDetail: Signal<boolean>;
     readonly serverSideFiltering: Signal<boolean>;
     readonly filterDebounceMs: Signal<number>;
     readonly enableQuickFilter: Signal<boolean>;
-    readonly menuBarItems: Signal<AgridMenuBarItem<T>[]>;
+    readonly menuBarItems: Signal<_thkl_agrid.AgridMenuBarItem<T>[]>;
     readonly quickFilterValue: Signal<string>;
     readonly sortOption: Signal<"single" | "multi" | "none">;
     readonly rowSelection: Signal<"single" | "multi" | "none">;
@@ -1641,6 +2228,8 @@ declare class AgridComponent<T extends object = any> {
     readonly cellMenuItems: Signal<(CellContextMenuItem<T> | null)[]>;
     readonly headerGroups: Signal<_thkl_agrid.HeaderGroup[]>;
     readonly treeConfig: Signal<_thkl_agrid.AgridTreeConfig<T> | null>;
+    /** Whether the provider is rendering a derived client-side pivot table. */
+    readonly pivotMode: Signal<boolean>;
     readonly zebraStripes: Signal<boolean>;
     readonly showChangedCellIndicator: Signal<boolean>;
     readonly confirmRowDelete: Signal<boolean>;
@@ -1648,6 +2237,7 @@ declare class AgridComponent<T extends object = any> {
     readonly loading: Signal<boolean>;
     readonly emptyText: Signal<string | undefined>;
     readonly useSidebarEditor: Signal<boolean>;
+    readonly hideGridStatusBar: Signal<boolean | undefined>;
     /** Host callback for per-row CSS classes, or `undefined`. */
     readonly rowClassFn: Signal<((params: {
         row: Record<string, unknown>;
@@ -1655,6 +2245,8 @@ declare class AgridComponent<T extends object = any> {
     }) => string) | undefined>;
     /** Host callback designating pinned rows, or `undefined`. */
     readonly pinRowFn: Signal<((row: Record<string, unknown>, index: number) => "top" | "bottom" | undefined) | undefined>;
+    readonly pivotRowColumnField: Signal<Extract<keyof T, string> | undefined>;
+    readonly pivotHeaderLabel: Signal<string | undefined>;
     /**
      * Effective pin resolver fed to the projection: a runtime UI override wins (including an explicit
      * `null` unpin), otherwise the provider `pinRow` predicate decides. Returns `undefined` when
@@ -1665,10 +2257,21 @@ declare class AgridComponent<T extends object = any> {
     readonly masterDetail: Signal<boolean>;
     /** Fixed detail-panel height in pixels. */
     readonly detailRowHeight: Signal<number>;
-    /** Column definitions from the active provider. */
+    /** Column configured as the expanded panel's multiline detail field. */
+    readonly detailColumn: Signal<ColDefBase<any, string> | null>;
+    /** Text-template buttons configured for the expanded panel's multiline detail field. */
+    readonly detailActions: Signal<DetailAction<T>[]>;
+    /** Read-only pivot rows and generated columns, or `null` in the normal datasource view. */
+    private readonly pivotResult;
+    /** Reactive row projection linked into a stable datasource instance for pivot mode. */
+    private readonly pivotRows;
+    private readonly pivotDataSource;
+    /** Column definitions from the active provider or generated by the active pivot. */
     readonly colDefs: Signal<ColDefBase<any, string>[]>;
-    /** Signal-based data container from the active provider. */
+    /** Signal-based source rows or a derived, read-only pivot datasource. */
     readonly dataSource: Signal<AgridDataSource<any>>;
+    /** Active lazy server-side row model, when configured on the provider. */
+    readonly serverSideRowModel: Signal<_thkl_agrid.AgridServerSideRowModel<T> | null>;
     private readonly treeParentIds;
     /** Grid UI state container from the active provider. */
     readonly control: Signal<AgridControl | null>;
@@ -1678,6 +2281,8 @@ declare class AgridComponent<T extends object = any> {
     readonly localeText: Signal<AgridLocaleText>;
     /** Effective empty-state label. */
     readonly emptyTextLabel: Signal<string>;
+    readonly gridId: Signal<string | undefined>;
+    readonly enableExportButtons: Signal<boolean | undefined>;
     /** Emitted after the user commits a cell edit. */
     cellEdit: _angular_core.OutputEmitterRef<GridEditEvent<T>>;
     /**
@@ -1693,11 +2298,21 @@ declare class AgridComponent<T extends object = any> {
     rowReorder: _angular_core.OutputEmitterRef<RowReorderEvent<T>>;
     /** Emitted when the row selection changes. `null` = selection cleared. */
     rowSelect: _angular_core.OutputEmitterRef<RowSelectEvent<T> | null>;
+    /** Emitted when a row is marked or unmarked from its row header. */
+    rowMark: _angular_core.OutputEmitterRef<RowMarkEvent<T>>;
+    /** Emitted when a complete column is marked or unmarked from its header. */
+    columnMark: _angular_core.OutputEmitterRef<ColumnMarkEvent<T>>;
+    /** Emitted when a custom column-header menu command is selected. */
+    columnHeaderAction: _angular_core.OutputEmitterRef<ColumnHeaderActionEvent<T>>;
+    /** Emitted once after the first non-empty datasource render has completed. */
+    firstDataRendered: _angular_core.OutputEmitterRef<FirstDataRenderedEvent<T>>;
     rowDoubleClicked: _angular_core.OutputEmitterRef<RowClickEvent<T>>;
     /** Emitted when the user single-clicks a data row. */
     rowClick: _angular_core.OutputEmitterRef<RowClickEvent<T>>;
     /** Emitted when the user single-clicks a generated path-tree branch node. */
     treeNodeClick: _angular_core.OutputEmitterRef<TreeNodeClickEvent>;
+    /** Emitted after sidebar changes produce a new persistable grid settings snapshot. */
+    settingsChange: _angular_core.OutputEmitterRef<AgridSettings>;
     /** Emitted when the user double-clicks a generated path-tree branch node. */
     treeNodeDoubleClicked: _angular_core.OutputEmitterRef<TreeNodeClickEvent>;
     /**
@@ -1727,10 +2342,10 @@ declare class AgridComponent<T extends object = any> {
     cellInfo: _angular_core.OutputEmitterRef<CellInfoEvent<T>>;
     /** Emitted for every enabled menu-bar button or dropdown item, carrying its configured id. */
     menuBarAction: _angular_core.OutputEmitterRef<string>;
+    /** Emitted if there is a Detail pane Action without text property */
+    detailAction: _angular_core.OutputEmitterRef<RowDetailActionEvent<T>>;
     /** Currently focused cell, or `null`. */
     readonly selectedCell: _angular_core.WritableSignal<CellPosition | null>;
-    /** Original index of the row awaiting delete confirmation, or `null`. */
-    readonly pendingDeleteRow: _angular_core.WritableSignal<number | null>;
     /** Original indices of rows whose master/detail panel is currently expanded. */
     private readonly _expandedDetailIds;
     /**
@@ -1740,12 +2355,12 @@ declare class AgridComponent<T extends object = any> {
      */
     private readonly _pinnedRows;
     private readonly markedIndices;
+    private readonly markedFields;
+    private firstDataRenderedEmitted;
     /** Original datasource indices marked for inclusion in copy operations. */
     readonly markedRowIndices: Signal<ReadonlySet<number>>;
-    /** Horizontal position of the delete prompt inside the scrollable row. */
-    readonly deleteConfirmationLeft: _angular_core.WritableSignal<number>;
-    /** Visible width available to the delete prompt. */
-    readonly deleteConfirmationWidth: _angular_core.WritableSignal<number>;
+    /** Fields currently marked as complete columns. */
+    readonly markedColumnFields: Signal<ReadonlySet<string>>;
     /** Rectangular cell range selected by Shift+arrow or Shift+click. */
     readonly selectedRange: _angular_core.WritableSignal<CellRange | null>;
     /** @internal Stable callback passed to child components for row-aware editability checks. */
@@ -1763,26 +2378,29 @@ declare class AgridComponent<T extends object = any> {
     /** Toggle the sidebar open/closed. */
     toggleSidebar(): void;
     /** @internal */
-    onSidebarStripClick(tab: 'columns' | 'detail'): void;
+    onSidebarStripClick(tab: AgridSidebarTab): void;
+    /** @internal Replace the active pivot configuration from the sidebar controls. */
+    onSidebarPivotChange(config: AgridPivotConfig): void;
+    /** Return a detached, JSON-safe snapshot suitable for persistence by the host application. */
+    saveSettings(): AgridSettings;
+    /** Apply a saved settings snapshot to this live grid. */
+    loadSettings(settings: AgridSettings): void;
+    /** Emit when the active state is JSON-safe; custom function aggregates remain host-owned. */
+    private emitSettingsChange;
+    ngOnChanges(): void;
     /** @internal */
     onSidebarDetailEdit(event: AgridSidebarEdit): void;
     /** @internal Commit an edit made via the detail panel. */
     commitDetailEdit(field: string, col: ColDef, stringValue: string): void;
     onSidebarDetailSave(_event: AgridSidebarDetailField[]): void;
-    /**
-     * Download the currently visible, filtered rows as a CSV file.
-     * Uses display values (ValueOption labels, formatters) and respects column visibility.
-     * Group header rows are excluded — only data rows are exported.
-     *
-     * @param filename  Output filename, defaults to `'export.csv'`.
-     */
-    exportCsv(filename?: string): void;
     /** @internal */ goToFirstPage(): void;
     /** @internal */ goToLastPage(): void;
     /** @internal */ goToNextPage(): void;
     /** @internal */ goToPrevPage(): void;
     /** Resize every visible column to fit its header and current row values. */
     autosizeAllColumns(): void;
+    /** return yes if we have saved config so a autosize from the client can be surpressed */
+    hasSavedSizeConfig(): boolean;
     /**
      * Clears changed-cell markers after persistence succeeds.
      * Omit `originalIndex` to clear every marker; omit `fields` to clear the whole row.
@@ -1790,6 +2408,12 @@ declare class AgridComponent<T extends object = any> {
     clearChangedCells(originalIndex?: number, fields?: readonly string[]): void;
     /** @internal Whether a cell has an unsaved-change marker. */
     isCellChanged(originalIndex: number, field: string): boolean;
+    /** @internal Whether a row is currently in the colored phase of a control indication. */
+    rowIndicationActive(originalIndex: number): boolean;
+    /** @internal CSS color for a transient row indication. */
+    rowIndicationColor(originalIndex: number): string | null;
+    /** @internal Fade duration for a transient row indication. */
+    rowIndicationDuration(originalIndex: number): number | null;
     /** @internal Full display value for a cell — used as the `title` tooltip attribute. */
     getCellTitle(col: ColDef, value: unknown): string;
     /** @internal Dynamic CSS class string for a cell from `ColDef.cellClass`. */
@@ -1825,6 +2449,31 @@ declare class AgridComponent<T extends object = any> {
     readonly pinnedHeaderGroupRuns: Signal<AgridHeaderGroupRun[]>;
     readonly scrollableHeaderGroupRuns: Signal<AgridHeaderGroupRun[]>;
     readonly rightHeaderGroupRuns: Signal<AgridHeaderGroupRun[]>;
+    /** @internal Header view-model for the left-pinned, scrollable, and right-pinned panes. */
+    readonly pinnedHeaderColumns: Signal<AgridHeaderColumn[]>;
+    readonly scrollableHeaderColumns: Signal<AgridHeaderColumn[]>;
+    readonly rightHeaderColumns: Signal<AgridHeaderColumn[]>;
+    /** @internal Grouped-header view-model per pane (run + reactive lock/drag state). */
+    readonly pinnedHeaderGroups: Signal<AgridHeaderGroup[]>;
+    readonly scrollableHeaderGroups: Signal<AgridHeaderGroup[]>;
+    readonly rightHeaderGroups: Signal<AgridHeaderGroup[]>;
+    /**
+     * Resolves every per-column header/filter binding into a flat view-model. Called from the
+     * pane header computeds; reads the same signal-backed helpers the template used directly, so
+     * the result is memoized and recomputed only when sort/filter/drag/sizing state changes.
+     */
+    private buildHeaderColumns;
+    private buildHeaderGroups;
+    /** @internal Body view-model for the left-pinned, scrollable, and right-pinned panes. */
+    readonly pinnedBodyColumns: Signal<AgridBodyColumn[]>;
+    readonly scrollableBodyColumns: Signal<AgridBodyColumn[]>;
+    readonly rightBodyColumns: Signal<AgridBodyColumn[]>;
+    /**
+     * Resolves the per-column bindings shared by every data, footer, and ghost cell. Reads only
+     * layout/drag/pinning signals, so the result is reused across all rows and recomputes only
+     * when columns move, resize, drag, or change pinning.
+     */
+    private buildBodyColumns;
     private readonly columnState;
     private readonly projection;
     private readonly editController;
@@ -1856,11 +2505,29 @@ declare class AgridComponent<T extends object = any> {
     readonly totalWidth: Signal<number>;
     readonly pinnedPaneWidth: Signal<number>;
     readonly scrollableTotalWidth: Signal<number>;
+    /** Live horizontal scroll metrics of the scrollable pane, fed to column virtualization. */
+    private readonly colScrollLeft;
+    private readonly colViewportWidth;
+    /** Scrollable-column count above which column virtualization activates. */
+    readonly columnVirtualizationThreshold: Signal<number>;
+    /** Windows the scrollable-pane columns to those near the horizontal viewport. */
+    private readonly columnVirtualization;
+    /** @internal Current rendered column window (full set + zero spacers when inactive). */
+    readonly columnWindow: Signal<AgridColumnWindow>;
+    /** @internal Scrollable body columns sliced to the active window. */
+    readonly virtualScrollableBodyColumns: Signal<AgridBodyColumn[]>;
+    /** @internal Number of hidden scrollable columns after the window (trailing spacer span). */
+    readonly columnWindowRightSpan: Signal<number>;
     /**
      * Filtered, sorted, and optionally grouped row list for `*cdkVirtualFor`.
      * Appends `null` when the explicit add-row placeholder is active.
      */
     readonly filteredItems: Signal<GridItem[]>;
+    /**
+     * @internal The full filtered + sorted row set (grouping/pagination ignored). Reused for export
+     * and published to the provider as `visibleRows` so charts and consumers can react to filters.
+     */
+    readonly ɵvisibleRows: Signal<Record<string, unknown>[]>;
     /** Virtual scroll source — injects ghost row during a reorder drag. */
     /** Maps originalIndex → true if the data row should receive the odd-row stripe. Counts only data rows, so group headers don't shift the pattern. */
     readonly dataRowIsOdd: Signal<Map<number, boolean>>;
@@ -1898,7 +2565,18 @@ declare class AgridComponent<T extends object = any> {
     private readonly destroyRef;
     private readonly _hostEl;
     private readonly browser;
+    private viewReady;
     private readonly rangeController;
+    /** Live numeric statistics for the active cell or rectangular range. */
+    readonly selectionSummary: Signal<AgridSelectionSummary | null>;
+    /** Locale-formatted status-bar values derived from {@link selectionSummary}. */
+    readonly selectionSummaryDisplay: Signal<{
+        count: string;
+        sum: string;
+        average: string;
+        min: string;
+        max: string;
+    } | null>;
     private readonly columnSizing;
     private readonly columnMenuController;
     readonly filterMenu: _angular_core.WritableSignal<AgridColumnMenuState | null>;
@@ -1919,31 +2597,46 @@ declare class AgridComponent<T extends object = any> {
     readonly findQuery: _angular_core.WritableSignal<string>;
     readonly findActiveIndex: _angular_core.WritableSignal<number>;
     readonly findMatches: Signal<AgridFindMatch[]>;
+    private readonly detailController;
+    /** @internal Detail-field editor state, re-exported for the template. */
+    readonly detailEditingRow: _angular_core.WritableSignal<number | null>;
+    readonly detailDraft: _angular_core.WritableSignal<string>;
+    readonly detailValidationError: _angular_core.WritableSignal<string | null>;
     private readonly navigationController;
+    /** Maps logical covered columns to a rendered span anchor (or past it when moving right). */
+    private resolveSpannedColumn;
     private readonly rowController;
     readonly selectedRowIndices: Signal<ReadonlySet<number>>;
     readonly selectedRowIndex: Signal<number | null>;
     readonly contextMenu: _angular_core.WritableSignal<AgridRowContextMenu | null>;
     readonly cellContextMenuState: _angular_core.WritableSignal<AgridCellContextMenu | null>;
+    readonly pendingDeleteRow: _angular_core.WritableSignal<number | null>;
+    readonly deleteConfirmationLeft: _angular_core.WritableSignal<number>;
+    readonly deleteConfirmationWidth: _angular_core.WritableSignal<number>;
+    private readonly menuBarController;
     /** Id of the menu-bar button whose dropdown is open, or `null`. */
     readonly openMenuBarItemId: _angular_core.WritableSignal<string | null>;
     /** Runtime state passed to menu-bar visibility, active, and disabled resolvers. */
-    readonly menuBarContext: Signal<AgridMenuBarContext<T>>;
+    readonly menuBarContext: Signal<_thkl_agrid.AgridMenuBarContext<T>>;
     /** Menu-bar buttons currently allowed by their visibility resolvers. */
-    readonly visibleMenuBarItems: Signal<AgridMenuBarItem<T>[]>;
+    readonly visibleMenuBarItems: Signal<(_thkl_agrid.AgridMenuBarItem<any> | _thkl_agrid.AgridMenuBarItem<T>)[]>;
     private readonly sidebarController;
     readonly sidebarOpen: _angular_core.WritableSignal<boolean>;
     /** @internal Per-field sidebar validation messages. */
     readonly sidebarValidationErrors: _angular_core.WritableSignal<Record<string, string>>;
-    readonly sidebarTab: _angular_core.WritableSignal<"columns" | "detail">;
+    readonly sidebarTab: _angular_core.WritableSignal<AgridSidebarTab>;
     readonly sidebarRow: Signal<Record<string, unknown> | null>;
     readonly sidebarHiddenColumns: Signal<ReadonlySet<string>>;
+    /** Original provider columns used as pivot field choices. */
+    readonly sidebarPivotColumns: Signal<ColDefBase<any, string>[]>;
     private readonly clipboardHandler;
     readonly dragHandler: AgridDragHandler;
     private readonly columnReorder;
     readonly columnDragPreview: _angular_core.WritableSignal<AgridColumnDragPreview | null>;
     /** @internal Start a column header drag. */
     onColHeaderPointerDown(event: PointerEvent, field: string): void;
+    /** @internal Toggles a complete column when its non-interactive header surface is clicked. */
+    onColHeaderClick(event: MouseEvent, field: string): void;
     /** @internal Start dragging all columns in one contiguous grouped-header segment. */
     onHeaderGroupPointerDown(event: PointerEvent, fields: string[], label: string): void;
     /** @internal Whether any field in a grouped-header segment is being dragged. */
@@ -1960,18 +2653,14 @@ declare class AgridComponent<T extends object = any> {
     private readonly _seededControls;
     private readonly dirtyInlineRows;
     private dirtyRowsDataSource;
-    private readonly changedCells;
     private changedCellsDataSource;
     private emitEditEvents;
     private emitSidebarEditEvents;
     private emitRecordEdit;
     private markInlineRowDirty;
     private markCellChanged;
-    private changedCellKey;
-    private parseChangedCellKey;
     private flushDirtyInlineRows;
     private reconcileDirtyInlineRowsAfterRemoval;
-    private reconcileChangedCellsAfterRemoval;
     private emitRowChanged;
     private createRecordEvent;
     constructor();
@@ -1980,6 +2669,11 @@ declare class AgridComponent<T extends object = any> {
         row: Record<string, unknown>;
         originalIndex: number;
     };
+    /** @internal Whether this virtual row is waiting for a server-side block. */
+    isLoadingRow(item: GridItem): item is {
+        loading: true;
+        originalIndex: number;
+    };
     /** @internal */
     isGroupHeaderItem(item: GridItem): item is {
         groupLabel: string;
@@ -1996,6 +2690,23 @@ declare class AgridComponent<T extends object = any> {
     rowPx(item: GridItem): number;
     /** @internal Resolved HTML for an expanded detail panel (auto-sanitized by `[innerHTML]`). */
     detailHtml(item: GridItem): string;
+    /** @internal Formatted value shown while a configured detail field is not being edited. */
+    detailFieldDisplay(item: DetailRowItem): string;
+    /** @internal Whether the configured detail field can be edited for this row. */
+    isDetailFieldEditable(item: DetailRowItem): boolean;
+    /** @internal Enter multiline editing for one expanded detail row. */
+    startDetailFieldEdit(item: DetailRowItem, event?: Event): void;
+    /** @internal Keep the multiline draft synchronized with textarea input. */
+    onDetailDraftInput(event: Event): void;
+    /** @internal Commit on blur or Ctrl/Cmd+Enter, and cancel on Escape. */
+    onDetailEditorKeydown(item: DetailRowItem, event: KeyboardEvent): void;
+    /** @internal Insert a configured text template into the active detail textarea. */
+    applyDetailAction(item: DetailRowItem, action: DetailAction, event: Event): void;
+    private focusDetailEditorFromKeyboard;
+    /** @internal Commit a multiline detail edit through normal grid edit semantics. */
+    commitDetailFieldEdit(item: DetailRowItem): void;
+    /** @internal Discard the active multiline detail draft. */
+    cancelDetailFieldEdit(): void;
     /** @internal Resolved per-row CSS classes from the host `getRowClass` callback. */
     getRowClass(row: Record<string, unknown>, index: number): string;
     /** Whether the master/detail panel for `originalIndex` is currently expanded. */
@@ -2023,8 +2734,20 @@ declare class AgridComponent<T extends object = any> {
     treeRowExpandable(item: GridItem): boolean;
     /** @internal Whether a tree row is currently expanded. */
     treeRowExpanded(item: GridItem): boolean;
-    /** @internal Display-only final path segment for a datasource-backed path-tree leaf. */
+    /**
+     * @internal Resolve the non-persistent value shown by a tree cell.
+     *
+     * A formatted path-leaf label wins in the tree column. In every other aggregate column, an
+     * expandable parent shows its descendant rollup instead of its stored value. Returning `null`
+     * delegates to the normal cell formatter. The source row is never mutated.
+     */
     treeCellDisplayOverride(item: GridItem, col: ColDef): string | null;
+    /**
+     * @internal True when a datasource-backed tree parent cell displays a computed rollup.
+     * The template uses this to prevent editing a display-only value into the source parent row.
+     * Generated path branches are not cell components and render their aggregates separately.
+     */
+    isTreeAggregateCell(item: GridItem, col: ColDef): boolean;
     /** @internal Whether the configured info action is visible for this cell. */
     showCellInfoIcon(col: ColDef, row: Record<string, unknown>): boolean;
     /** @internal Emits the typed cell information action. */
@@ -2122,6 +2845,10 @@ declare class AgridComponent<T extends object = any> {
     onStartEdit(originalIndex: number, ci: number): void;
     /** @internal */
     onDraftChange(value: unknown): void;
+    /** @internal A custom cell editor requested a commit (e.g. picking a value). */
+    onEditorCommit(): void;
+    /** @internal A custom cell editor requested cancellation. */
+    onEditorCancel(): void;
     private quickFilterTimer;
     /**
      * @internal Quick-filter input handler. Stores the text on the control (drives the bound value
@@ -2155,12 +2882,24 @@ declare class AgridComponent<T extends object = any> {
     onHandlePointerDown(event: PointerEvent, originalIndex: number): void;
     /** @internal Handles the control column without letting the row receive a second pointer event. */
     onControlPointerDown(event: PointerEvent, originalIndex: number): void;
-    /** @internal Toggle whether a row is included in subsequent copy operations. */
+    /** @internal Marks a row when its control-column header surface is clicked. */
+    onControlCellClick(event: MouseEvent, originalIndex: number): void;
+    /** Toggle whether a row is included in subsequent copy operations and emit its new state. */
     toggleRowMarked(originalIndex: number): void;
+    /** Set one row's mark state and emit `rowMark` when that state changes. */
+    setRowMarked(originalIndex: number, marked: boolean): void;
     /** @internal Returns whether a row is marked for copying. */
     isRowMarked(originalIndex: number): boolean;
     /** Clear every row marked for clipboard inclusion. */
     clearMarkedRows(): void;
+    /** Set one complete column's mark state and emit `columnMark` when it changes. */
+    setColumnMarked(field: string, marked: boolean): void;
+    /** Toggle one complete column's mark state. */
+    toggleColumnMarked(field: string): void;
+    /** Clear all marked columns. */
+    clearMarkedColumns(): void;
+    /** @internal Emits a custom header command for its typed column and closes the menu. */
+    onColumnHeaderAction(field: string, key: string): void;
     /** @internal Copy the active range or cell as TSV. */
     onCopy(event: ClipboardEvent): void;
     /** @internal Paste TSV/CSV-like plain text into the current cell. */
@@ -2181,28 +2920,12 @@ declare class AgridComponent<T extends object = any> {
     closeCellContextMenu(): void;
     /** @internal Closes any row, cell, menu-bar, group-action, or column menu owned by this grid. */
     closeOpenMenus(): boolean;
-    /** @internal Resolves a menu-bar state callback against the current grid state. */
-    resolveMenuBarState(state: AgridMenuBarState<T> | undefined, fallback: boolean): boolean;
-    /** @internal Whether a menu-bar button or dropdown item should be rendered. */
-    isMenuBarItemVisible(item: AgridMenuBarMenuItem<T>): boolean;
-    /** @internal Whether a menu-bar button or dropdown item is active. */
-    isMenuBarItemActive(item: AgridMenuBarMenuItem<T>): boolean;
-    /** @internal Whether a menu-bar button or dropdown item is disabled. */
-    isMenuBarItemDisabled(item: AgridMenuBarMenuItem<T>): boolean;
-    /** @internal Visible dropdown entries for a menu-bar button. */
-    visibleMenuBarChildren(item: AgridMenuBarItem<T>): AgridMenuBarMenuItem<T>[];
-    /** @internal Emits one menu-bar action and closes its dropdown. */
-    runMenuBarAction(event: Event, item: AgridMenuBarMenuItem<T>): void;
-    /** @internal Opens or closes a split button's additional command menu. */
-    toggleMenuBarMenu(event: Event, item: AgridMenuBarItem<T>): void;
-    /** @internal Opens a dropdown from the keyboard and focuses its first/last enabled item. */
-    onMenuBarTriggerKeydown(event: KeyboardEvent, item: AgridMenuBarItem<T>): void;
-    /** @internal Provides standard keyboard navigation within an open menu-bar dropdown. */
-    onMenuBarMenuKeydown(event: KeyboardEvent): void;
     /** @internal Closes the currently open menu-bar dropdown. */
     closeMenuBarMenu(): void;
     /** @internal Synchronizes dropdown state and closes competing grid menus when one opens. */
     onMenuBarOpenItemChange(id: string | null): void;
+    /** @internal Dispatches a menu-bar action (or persists config for the built-in save entry). */
+    onMenuBarAction(id: string): void;
     /** @internal Runs a typed provider context-menu action against erased controller state. */
     runCellMenuItem(item: CellContextMenuItem<T>, menu: AgridCellContextMenu): void;
     /** @internal Copy one field from the target and marked rows. */
@@ -2219,8 +2942,6 @@ declare class AgridComponent<T extends object = any> {
     confirmPendingRowDelete(): void;
     /** @internal Cancel the active row-delete confirmation. */
     cancelRowDelete(): void;
-    private deleteRowImmediately;
-    private updateDeleteConfirmationPosition;
     /** @internal */
     onGroupHeaderClick(label: string): void;
     /** Expand all groups. No-op when grouping is not active. */
@@ -2238,7 +2959,7 @@ declare class AgridComponent<T extends object = any> {
     /** @internal */
     onTextFilterChange(event: Event, field: string): void;
     /** @internal */
-    openFilterMenu(event: MouseEvent, field: string): void;
+    openFilterMenu(event: MouseEvent, field: string, mode?: 'column' | 'condition'): void;
     /** @internal */
     closeFilterMenu(): void;
     /** @internal */
@@ -2263,8 +2984,11 @@ declare class AgridComponent<T extends object = any> {
     onSidebarToggleColumnGroup(fields: string[], visible: boolean): void;
     /** @internal Mirrors vertical scrolling from the main viewport into both pinned panes. */
     onBodyScroll(): void;
+    private ensureServerRowsVisible;
     /** @internal Keeps the row-delete prompt visible while columns scroll horizontally. */
     onHorizontalScroll(): void;
+    /** @internal Refreshes the scroll offset / viewport width driving column virtualization. */
+    private syncColumnViewportMetrics;
     /** @internal */
     onRightPinnedBodyScroll(): void;
     /** @internal */
@@ -2299,7 +3023,7 @@ declare class AgridComponent<T extends object = any> {
     getColumnWidth(col: ColDef): number;
     private getColumnWidthToken;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgridComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridComponent<any>, "agrid", never, { "provider": { "alias": "provider"; "required": false; "isSignal": true; }; }, { "cellEdit": "cellEdit"; "recordEdit": "recordEdit"; "rowRemoved": "rowRemoved"; "prepareAddRecord": "prepareAddRecord"; "rowReorder": "rowReorder"; "rowSelect": "rowSelect"; "rowDoubleClicked": "rowDoubleClicked"; "rowClick": "rowClick"; "treeNodeClick": "treeNodeClick"; "treeNodeDoubleClicked": "treeNodeDoubleClicked"; "rowChanged": "rowChanged"; "pageChange": "pageChange"; "filterChange": "filterChange"; "sortChange": "sortChange"; "quickFilterChange": "quickFilterChange"; "validationFailed": "validationFailed"; "cellInfo": "cellInfo"; "menuBarAction": "menuBarAction"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridComponent<any>, "agrid", never, { "provider": { "alias": "provider"; "required": false; "isSignal": true; }; }, { "cellEdit": "cellEdit"; "recordEdit": "recordEdit"; "rowRemoved": "rowRemoved"; "prepareAddRecord": "prepareAddRecord"; "rowReorder": "rowReorder"; "rowSelect": "rowSelect"; "rowMark": "rowMark"; "columnMark": "columnMark"; "columnHeaderAction": "columnHeaderAction"; "firstDataRendered": "firstDataRendered"; "rowDoubleClicked": "rowDoubleClicked"; "rowClick": "rowClick"; "treeNodeClick": "treeNodeClick"; "settingsChange": "settingsChange"; "treeNodeDoubleClicked": "treeNodeDoubleClicked"; "rowChanged": "rowChanged"; "pageChange": "pageChange"; "filterChange": "filterChange"; "sortChange": "sortChange"; "quickFilterChange": "quickFilterChange"; "validationFailed": "validationFailed"; "cellInfo": "cellInfo"; "menuBarAction": "menuBarAction"; "detailAction": "detailAction"; }, never, never, true, never>;
 }
 
 /** Identifier supported by the standalone page selector. */
@@ -2355,7 +3079,12 @@ declare class AgridPageSelectorComponent<TId extends AgridPageId = AgridPageId>
 
 /** Configuration accepted by {@link AgridTreeProvider}. */
 interface AgridTreeProviderConfig<T extends object> {
+    /** Flat datasource whose rows are linked by parent ids or path segments. */
     datasource: AgridDataSource<T>;
+    /**
+     * Hierarchy, identity, labeling, filtering, and initial-expansion configuration.
+     * `aggregateTreeNodes` is ignored because the standalone tree has no grid columns.
+     */
     treeConfig: AgridTreeConfig<T>;
     /** Label for parent-linked rows. Defaults to the configured `treeField` value. */
     getLabel?: (row: T) => string;
@@ -2372,14 +3101,23 @@ interface AgridTreeProviderConfig<T extends object> {
 }
 /** Provider-style configuration and datasource container for `<agrid-tree>`. */
 declare class AgridTreeProvider<T extends object = any> {
+    /** Rows projected into the standalone tree. */
     readonly datasource: AgridDataSource<T>;
+    /** Shared hierarchy configuration; column-specific aggregation is not used here. */
     readonly treeConfig: AgridTreeConfig<T>;
+    /** Optional host label resolver for parent-linked datasource rows. */
     readonly getLabel?: (row: T) => string;
+    /** Optional host resolver for secondary node text. */
     readonly getDescription?: (row: T) => string | undefined;
+    /** Effective node selection behavior. */
     readonly selection: AgridTreeSelectionMode;
+    /** Effective fixed node height in pixels. */
     readonly rowHeight: number;
+    /** Effective accessible name applied to the tree root. */
     readonly ariaLabel: string;
+    /** Effective empty-state message. */
     readonly emptyText: string;
+    /** Normalize optional standalone-tree settings and retain the reactive datasource. */
     constructor(config: AgridTreeProviderConfig<T>);
 }
 
@@ -2387,6 +3125,7 @@ type StandaloneTreeItem<T extends object> = TreeRowItem<T> | PathTreeNodeItem;
 /** Standalone accessible tree control backed by the same projection logic as `AgridComponent`. */
 declare class AgridTreeComponent<T extends object = any> {
     provider: _angular_core.InputSignal<AgridTreeProvider<T>>;
+    localeText: _angular_core.InputSignal<AgridLocaleText>;
     nodeClick: _angular_core.OutputEmitterRef<AgridTreeNodeEvent<T>>;
     nodeDoubleClicked: _angular_core.OutputEmitterRef<AgridTreeNodeEvent<T>>;
     selectionChange: _angular_core.OutputEmitterRef<AgridTreeSelectionEvent<T>>;
@@ -2426,9 +3165,281 @@ declare class AgridTreeComponent<T extends object = any> {
     private focusNode;
     private findParentIndex;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgridTreeComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridTreeComponent<any>, "agrid-tree", never, { "provider": { "alias": "provider"; "required": true; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeDoubleClicked": "nodeDoubleClicked"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridTreeComponent<any>, "agrid-tree", never, { "provider": { "alias": "provider"; "required": true; "isSignal": true; }; "localeText": { "alias": "localeText"; "required": false; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeDoubleClicked": "nodeDoubleClicked"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+/**
+ * Context handed to a custom cell editor component through dependency injection.
+ *
+ * A custom editor is any standalone component referenced by {@link ColDef.cellEditor}.
+ * The grid instantiates it while a cell is in edit mode and provides this context via the
+ * {@link AGRID_EDITOR_CONTEXT} token. The editor is purely an *input surface*: it reads the
+ * current value and pushes drafts back through {@link setDraft}. The grid keeps full ownership
+ * of validation, history (undo/redo), and the commit/cancel lifecycle — so Tab, Enter, and
+ * Escape continue to work without the editor doing anything.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'rating-editor',
+ *   template: `
+ *     <select #s [value]="ctx.value()" (change)="ctx.setDraft(+s.value); ctx.commit()">
+ *       @for (n of [1,2,3,4,5]; track n) { <option [value]="n">{{ n }} ★</option> }
+ *     </select>`,
+ * })
+ * export class RatingEditor {
+ *   readonly ctx = inject(AGRID_EDITOR_CONTEXT);
+ * }
+ *
+ * // ColDef: { field: 'rating', cellEditor: RatingEditor }
+ * ```
+ */
+interface AgridEditorContext<TValue = unknown> {
+    /** The cell's current value at the moment editing started. */
+    readonly value: Signal<TValue>;
+    /** The full row record the cell belongs to. */
+    readonly row: Signal<Record<string, unknown>>;
+    /** The column definition this cell is rendered from. */
+    readonly column: Signal<ColDef>;
+    /**
+     * The printable character that triggered type-to-edit, or `''` when editing started another
+     * way (double-click, Enter, F2). Useful for seeding a free-text editor.
+     */
+    readonly seedChar: Signal<string>;
+    /** Stage a new value. The grid commits whatever was last staged on Tab/Enter. */
+    setDraft(value: unknown): void;
+    /** Programmatically commit the staged value (same as the user pressing Enter). */
+    commit(): void;
+    /** Programmatically discard the edit (same as the user pressing Escape). */
+    cancel(): void;
+}
+/** DI token a custom {@link ColDef.cellEditor} component injects to talk to the grid. */
+declare const AGRID_EDITOR_CONTEXT: InjectionToken<AgridEditorContext<unknown>>;
+
+/**
+ * Context handed to a custom cell renderer component through dependency injection.
+ *
+ * A custom renderer is any standalone component referenced by {@link ColDef.cellRendererComponent}.
+ * The grid instantiates it for the cell's *display* (read) state and provides this context via the
+ * {@link AGRID_RENDERER_CONTEXT} token. Unlike the HTML-string {@link ColDef.cellRenderer}, a
+ * component renderer supports full Angular bindings, event handlers, and child components — and
+ * needs no manual escaping or sanitization.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'status-badge',
+ *   template: `<span class="badge" [class]="'badge--' + value()">{{ value() }}</span>`,
+ * })
+ * export class StatusBadge {
+ *   private readonly ctx = inject(AGRID_RENDERER_CONTEXT);
+ *   readonly value = computed(() => String(this.ctx.value() ?? ''));
+ * }
+ *
+ * // ColDef: { field: 'status', cellRendererComponent: StatusBadge }
+ * ```
+ */
+interface AgridRendererContext<TValue = unknown> {
+    /** The cell's current value. */
+    readonly value: Signal<TValue>;
+    /** The full row record the cell belongs to. */
+    readonly row: Signal<Record<string, unknown>>;
+    /** The column definition this cell is rendered from. */
+    readonly column: Signal<ColDef>;
+}
+/** DI token a custom {@link ColDef.cellRendererComponent} component injects to read cell data. */
+declare const AGRID_RENDERER_CONTEXT: InjectionToken<AgridRendererContext<unknown>>;
+
+/**
+ * Zero-dependency chart geometry. Pure math that turns a typed dataset + a diagram type into flat
+ * SVG primitives (bars, line/area paths, pie slices, gridlines, labels), so the chart component
+ * only has to emit elements. No charting library — same hand-rolled approach as the xlsx writer
+ * and the sparkline helper.
+ */
+/** Supported diagram types. */
+type AgridChartType = 'column' | 'bar' | 'line' | 'area' | 'pie' | 'donut';
+/** One data series (a row of values aligned to {@link AgridChartData.categories}). */
+interface AgridChartSeries {
+    /** Series name shown in the legend. */
+    name?: string;
+    /** Explicit colour; falls back to the palette by index. */
+    color?: string;
+    values: number[];
+}
+/** The dataset fed to a chart: one or more series sharing a category axis. */
+interface AgridChartData {
+    /** Category labels (x-axis ticks, or pie/donut slice labels). */
+    categories?: string[];
+    series: AgridChartSeries[];
+}
+/** Box dimensions and styling knobs the dataset is laid out into. */
+interface AgridChartOptions {
+    width: number;
+    height: number;
+    palette?: string[];
+    /** Whether value/category axes and gridlines are produced (cartesian types only). */
+    showAxis?: boolean;
+}
+interface ChartBar {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    value: number;
+    seriesIndex: number;
+    categoryIndex: number;
+}
+interface ChartPath {
+    d: string;
+    color: string;
+    name: string;
+}
+interface ChartPoint {
+    x: number;
+    y: number;
+    color: string;
+}
+interface ChartSlice {
+    d: string;
+    color: string;
+    value: number;
+    label: string;
+    percentText: string;
+    labelX: number;
+    labelY: number;
+    full: boolean;
+}
+interface ChartGridline {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+interface ChartLabel {
+    x: number;
+    y: number;
+    text: string;
+    anchor: 'start' | 'middle' | 'end';
+    baseline: 'auto' | 'middle' | 'hanging';
+}
+interface ChartLegendItem {
+    name: string;
+    color: string;
+}
+/** Flat, drawable primitives for a chart. */
+interface AgridChartLayout {
+    type: AgridChartType;
+    width: number;
+    height: number;
+    bars: ChartBar[];
+    areas: ChartPath[];
+    lines: ChartPath[];
+    points: ChartPoint[];
+    slices: ChartSlice[];
+    gridlines: ChartGridline[];
+    axisLabels: ChartLabel[];
+    legend: ChartLegendItem[];
+}
+/** Default qualitative palette (colour-blind-friendly-ish, distinct hues). */
+declare const AGRID_CHART_PALETTE: string[];
+/** Builds drawable geometry for a chart. Empty/invalid input yields an empty layout. */
+declare function buildChart(type: AgridChartType, data: AgridChartData, options: AgridChartOptions): AgridChartLayout;
+
+/**
+ * Construction options for an {@link AgridChartProvider}.
+ *
+ * Provide a static {@link data} set, or link a live {@link source} (e.g. a grid provider's
+ * `visibleRows`) together with a {@link transform} so the chart follows the grid's filtering and
+ * sorting automatically.
+ */
+interface AgridChartProviderConfig<T = any> {
+    /** Diagram type: column, bar, line, area, pie, or donut. */
+    type: AgridChartType;
+    /** Static dataset. Ignored when {@link source} + {@link transform} are provided. */
+    data?: AgridChartData;
+    /**
+     * A reactive row source to derive the dataset from — typically a grid provider's `visibleRows`,
+     * which reflects the grid's current filters and sorting. Requires {@link transform}.
+     */
+    source?: Signal<readonly T[]>;
+    /**
+     * Turns the {@link source} rows (and the current chart type) into a chart dataset. Re-runs
+     * whenever the source rows or the chart type change.
+     */
+    transform?: (rows: readonly T[], type: AgridChartType) => AgridChartData;
+    /** Chart height in pixels (width follows the host). @default 220 */
+    height?: number;
+    /** Show the series/category legend below the chart. @default true */
+    showLegend?: boolean;
+    /** Draw value/category axes for cartesian types. @default true */
+    showAxis?: boolean;
+    /** Override the colour palette. */
+    palette?: string[];
+}
+/**
+ * Bundles a chart's type, dataset, and display options behind one object, so a chart is configured
+ * exactly like a grid: `<agrid-chart [provider]="chartProvider" />`.
+ *
+ * @example Static data
+ * ```ts
+ * new AgridChartProvider({ type: 'column', data: { categories: ['Q1','Q2'], series: [{ values: [10, 14] }] } });
+ * ```
+ *
+ * @example Linked to a grid (follows filters/sorting)
+ * ```ts
+ * new AgridChartProvider({
+ *   type: 'column',
+ *   source: gridProvider.visibleRows,
+ *   transform: (rows, type) => ({ categories: rows.map(r => r.region), series: [{ values: rows.map(r => r.total) }] }),
+ * });
+ * ```
+ */
+declare class AgridChartProvider<T = any> {
+    /** Diagram type. Writable — set it to switch chart type at runtime. */
+    readonly type: WritableSignal<AgridChartType>;
+    /** The dataset rendered by the chart (derived from the source when linked). */
+    readonly data: Signal<AgridChartData>;
+    /** Chart height in pixels. */
+    readonly height: WritableSignal<number>;
+    /** Whether the legend is shown. */
+    readonly showLegend: WritableSignal<boolean>;
+    /** Whether cartesian axes are drawn. */
+    readonly showAxis: WritableSignal<boolean>;
+    /** Colour palette override, or `undefined` for the default. */
+    readonly palette: WritableSignal<string[] | undefined>;
+    /** Writable backing store in static mode; `null` when the data is derived from a source. */
+    private readonly _data;
+    constructor(config: AgridChartProviderConfig<T>);
+    /** Replace the dataset. Only valid in static mode (no linked {@link AgridChartProviderConfig.source}). */
+    setData(data: AgridChartData): void;
+}
+
+/**
+ * Zero-dependency chart component. Configured exactly like the grid — hand it an
+ * {@link AgridChartProvider} and it renders an SVG column / bar / line / area / pie / donut chart
+ * with no charting library. The chart sizes itself to the host width (observed) and the provider's
+ * height.
+ *
+ * @example
+ * ```html
+ * <agrid-chart [provider]="chartProvider" />
+ * ```
+ */
+declare class AgridChartComponent {
+    /** All chart configuration — type, data, and display options. */
+    readonly provider: _angular_core.InputSignal<AgridChartProvider<any>>;
+    private readonly host;
+    protected readonly width: _angular_core.WritableSignal<number>;
+    protected readonly height: _angular_core.Signal<number>;
+    protected readonly showLegend: _angular_core.Signal<boolean>;
+    protected readonly sliceLabels: _angular_core.Signal<boolean>;
+    protected readonly layout: _angular_core.Signal<_thkl_agrid.AgridChartLayout>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgridChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridChartComponent, "agrid-chart", never, { "provider": { "alias": "provider"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { AGRID_LOCALE_TEXT, AgridComponent, AgridControl, AgridDataSource, AgridPageSelectorComponent, AgridProvider, AgridTreeComponent, AgridTreeProvider, ColDefAutoSize };
-export type { AgridControlState, AgridEnterEditAction, AgridField, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridMenuBarContext, AgridMenuBarItem, AgridMenuBarMenuItem, AgridMenuBarState, AgridPageId, AgridPageItem, AgridParentTreeConfig, AgridPathSegmentParams, AgridPathTreeConfig, AgridProviderConfig, AgridTreeConfig, AgridTreeNodeEvent, AgridTreeProviderConfig, AgridTreeSelectionEvent, AgridTreeSelectionMode, CellContextMenuItem, CellInfoEvent, CellPosition, CellReadonlyParams, ColDef, ColumnFilter, DetailRowItem, FilterChangeEvent, FilterOperator, GridEditEvent, GroupAction, HeaderGroup, HistoryEntry, HistoryItem, InputMaskParams, NewRecord, PageChangeEvent, PathTreeNodeItem, RecordEditEvent, RowClickEvent, RowRemovedEvent, RowReorderEvent, RowSelectEvent, RowUpdateEvent, SortChangeEvent, TreeNodeClickEvent, TreeRowItem, ValidationFailedEvent, ValueOption };
+export { AGRID_CHART_PALETTE, AGRID_EDITOR_CONTEXT, AGRID_LOCALE_TEXT, AGRID_RENDERER_CONTEXT, AgridBrowserAdapter, AgridChartComponent, AgridChartProvider, AgridComponent, AgridControl, AgridDataSource, AgridPageSelectorComponent, AgridProvider, AgridServerSideRowModel, AgridTreeComponent, AgridTreeProvider, ColDefAutoSize, buildChart };
+export type { AgridAggregate, AgridChartData, AgridChartLayout, AgridChartOptions, AgridChartProviderConfig, AgridChartSeries, AgridChartType, AgridColumnHeaderMenuItem, AgridControlState, AgridEditorContext, AgridEnterEditAction, AgridField, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridMenuBarContext, AgridMenuBarItem, AgridMenuBarMenuItem, AgridMenuBarState, AgridPageId, AgridPageItem, AgridParentTreeConfig, AgridPathSegmentParams, AgridPathTreeConfig, AgridPivotConfig, AgridPivotSettings, AgridProviderConfig, AgridRendererContext, AgridRowIndication, AgridSelectionSummary, AgridServerSideDatasource, AgridServerSideRequest, AgridServerSideResult, AgridServerSideRowModelConfig, AgridServerSideSort, AgridSettings, AgridTreeConfig, AgridTreeNodeEvent, AgridTreeProviderConfig, AgridTreeSelectionEvent, AgridTreeSelectionMode, CellContextMenuItem, CellFormat, CellFormatParams, CellInfoEvent, CellPosition, CellReadonlyParams, CellSpanParams, ColDef, ColumnFilter, ColumnHeaderActionEvent, ColumnMarkEvent, DetailAction, DetailActionParams, DetailRowItem, FilterChangeEvent, FilterOperator, FirstDataRenderedEvent, GridEditEvent, GroupAction, HeaderGroup, HistoryEntry, HistoryItem, InputMaskParams, NewRecord, PageChangeEvent, PathTreeNodeItem, RecordEditEvent, RowClickEvent, RowMarkEvent, RowRemovedEvent, RowReorderEvent, RowSelectEvent, RowUpdateEvent, SortChangeEvent, TreeNodeClickEvent, TreeRowItem, ValidationFailedEvent, ValueOption };
 //# sourceMappingURL=thkl-agrid.d.ts.map