@thkl/agrid 0.1.11 → 0.1.14

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. */
@@ -115,6 +127,15 @@ interface AgridControlState {
     /** Per-field aggregate function set via the column menu. Only built-in string values are serializable. */
     aggregates?: Record<string, 'sum' | 'avg' | 'min' | 'max' | 'count'>;
 }
+/** Detached, JSON-safe filter/search/sort state for {@link AgridControl}. */
+interface AgridFilterModel {
+    /** Per-field column filter and sort state. */
+    filters: Record<string, ColumnFilter>;
+    /** Global quick-filter text. Empty or omitted means inactive. */
+    quickFilter?: string;
+    /** Ordered sorted fields, from highest to lowest priority. */
+    sortOrder?: string[];
+}
 /**
  * Signal-based container for mutable grid UI state such as column widths and active filters.
  *
@@ -150,12 +171,40 @@ declare class AgridControl {
     private readonly _loading;
     private readonly _readonly;
     private readonly _autoAddRows;
+    private readonly _filterReapplyRevision;
+    private readonly _filterReapplyNeeded;
+    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. */
@@ -164,6 +213,20 @@ declare class AgridControl {
     readonly autoAddRows: Signal<boolean>;
     /** Enable or disable automatic row insertion at runtime. */
     setAutoAddRows(value: boolean): void;
+    /**
+     * Reapply active filters to rows that were inserted while filters were already active.
+     * By default, newly inserted rows stay visible until this method is called.
+     */
+    reapplyFilters(): void;
+    /**
+     * `true` when inserted rows are currently bypassing active filters or sorts.
+     * Bind this to visual feedback for a "Reapply filters" action.
+     */
+    readonly filterReapplyNeeded: Signal<boolean>;
+    /** @internal Updates {@link filterReapplyNeeded} from the rendered grid projection. */
+    ɵsetFilterReapplyNeeded(value: boolean): void;
+    /** @internal Emits whenever {@link reapplyFilters} is called. */
+    readonly ɵfilterReapplyRevision: Signal<number>;
     /**
      * When `true`, the control column shows a drag handle and rows can be
      * reordered by dragging. Requires `showControlColumn` to be enabled on the grid.
@@ -322,6 +385,15 @@ declare class AgridControl {
      * Returns a default (inactive) filter when no state is stored for the field.
      */
     getFilter(field: string): ColumnFilter;
+    /** Replace the complete filter/sort state for one field. */
+    setFilter(field: string, filter: ColumnFilter): void;
+    /** Return a detached JSON-safe snapshot of active column filters, quick filter, and sort order. */
+    getFilterModel(): AgridFilterModel;
+    /**
+     * Replace active column filters, quick filter, and sort order from a filter model.
+     * Pass `null` to clear all filters and sorts.
+     */
+    setFilterModel(model: AgridFilterModel | null): void;
     /**
      * Set the free-text filter for a column.
      * An empty string removes the text filter for that column.
@@ -378,6 +450,7 @@ declare class AgridControl {
     toJSON(): AgridControlState;
     /** Restore an `AgridControl` from a previously serialized state. */
     static fromJSON(state: Partial<AgridControlState>): AgridControl;
+    private cloneFilters;
 }
 
 /**
@@ -401,6 +474,7 @@ declare class AgridDataSource<T extends object = any> {
     private readonly _rows;
     private _writableLinkedRows;
     private readonly _rowAdded;
+    private readonly _unfilteredAddedRows;
     private _changeSequence;
     /**
      * @param initialData Rows to seed the data source with.
@@ -417,6 +491,12 @@ declare class AgridDataSource<T extends object = any> {
         index: number;
         sequence: number;
     } | null>;
+    /**
+     * Rows inserted since filters were last explicitly reapplied.
+     * Attached grids include these rows even when they do not match active filters.
+     * @internal
+     */
+    readonly ɵunfilteredAddedRows: Signal<ReadonlySet<number>>;
     /**
      * Link an external row signal to this data source.
      *
@@ -469,6 +549,8 @@ declare class AgridDataSource<T extends object = any> {
     private updateRows;
     /** Replace the backing row array without copying. Intended for specialized datasource models. */
     protected setRows(rows: T[]): void;
+    /** @internal Clears the transient filter bypass applied to newly inserted rows. */
+    ɵreapplyFiltersToAddedRows(): void;
 }
 
 /** Sort entry sent to a server-side row datasource. */
@@ -503,6 +585,11 @@ interface AgridServerSideRowModelConfig<T extends object> {
     /** Known initial total. Omit when the server determines it from the first request. */
     initialRowCount?: number;
 }
+/** Refresh behavior for server-side block cache invalidation. */
+interface AgridServerSideRefreshOptions {
+    /** When `true`, clear all cached rows and replace them with placeholders. @default true */
+    purge?: boolean;
+}
 /**
  * Sparse datasource that lazy-loads row blocks while retaining global datasource indices.
  * Attach it to an `AgridProvider` through `serverSideRowModel`.
@@ -514,6 +601,7 @@ declare class AgridServerSideRowModel<T extends object = any> extends AgridDataS
     private slots;
     private readonly loadedBlocks;
     private readonly loadingBlocks;
+    private readonly failedBlocks;
     private query;
     private queryKey;
     private generation;
@@ -531,8 +619,14 @@ declare class AgridServerSideRowModel<T extends object = any> extends AgridDataS
     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;
+    /** Invalidate cached blocks while preserving the current query and known total row count. */
+    refresh(options?: AgridServerSideRefreshOptions): void;
+    /** Clear the block cache and show placeholders until requested blocks are reloaded. */
+    purgeCache(): void;
+    /** Retry the most recently failed block, or a specific block index when supplied. */
+    retryFailedBlock(block?: number): void;
+    /** Failed block indices that can be passed to {@link retryFailedBlock}. */
+    failedBlockIndices(): number[];
     /** 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. */
@@ -567,6 +661,7 @@ interface AgridLocaleText {
     close: string;
     columnMenu: string;
     columns: string;
+    collapse: string;
     detail: string;
     toggleDetail: string;
     hiddenColumn: string;
@@ -606,6 +701,7 @@ interface AgridLocaleText {
     lastPage: string;
     loading: string;
     markRow: string;
+    moreInformation: string;
     next: string;
     noRows: string;
     pagination: string;
@@ -622,6 +718,7 @@ interface AgridLocaleText {
     unpinRow: string;
     previous: string;
     resizeColumn: string;
+    expand: string;
     rows: (count: number) => string;
     quickFilterPlaceholder: string;
     searchValuesPlaceholder: string;
@@ -632,6 +729,11 @@ 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>;
@@ -696,8 +798,12 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     autoAddRows?: boolean;
     /** Show a 24 px control column with a drag handle and right-click context menu. */
     showControlColumn?: boolean;
+    /** Show automatic row numbers in the control column instead of the drag-handle glyph. @default false */
+    showRowNumbers?: 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. */
@@ -716,6 +822,12 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
      * instead of filtering locally. @default false
      */
     enableQuickFilter?: boolean;
+    /**
+     * Show an Excel-style formula/input bar above the grid body. It displays the selected cell's raw
+     * value and lets users edit it in a wider input. Useful for formula and long text cells.
+     * @default false
+     */
+    showFormulaBar?: boolean;
     /**
      * Optional command bar rendered above the column headers. Buttons and dropdown items emit
      * their id through the grid's single `(menuBarAction)` output.
@@ -752,6 +864,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 */
@@ -777,6 +895,14 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
         row: T;
         index: number;
     }) => string;
+    /**
+     * Optional application-owned predicate applied after built-in client-side filters and quick
+     * filter. Use this for filters that live outside the column menu.
+     */
+    externalFilter?: (params: {
+        row: T;
+        index: number;
+    }) => boolean;
     /**
      * Designate rows to pin to the top or bottom of the grid body. Pinned rows stay visible during
      * vertical scroll and are excluded from grouping and pagination, but remain fully interactive
@@ -808,8 +934,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.
@@ -817,6 +953,15 @@ 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>;
@@ -840,6 +985,29 @@ declare class AgridProvider<T extends object = any> {
     /** Shared grid options such as locale. */
     options: AGridOptions;
     private readonly _localizations;
+    private exportBridge;
+    private readonly _visibleRows;
+    private readonly _serverQuery;
+    /**
+     * 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[]>;
+    /**
+     * Complete server-side filter/sort/page query published by the rendered grid.
+     * Useful for signal-backed stores that fetch data from an API. `null` means the grid is not in
+     * server-side filtering or pagination mode.
+     */
+    readonly serverQuery: Signal<AgridServerQuery | null>;
+    /**
+     * @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;
+    /** @internal Published by the rendered grid whenever the server-side query state changes. */
+    ɵsetServerQuery(query: AgridServerQuery | null): void;
     /** Read-only view of registered per-locale text overrides. Used by the grid to resolve locale text. */
     get localizations(): ReadonlyMap<string, AgridLocaleTextOverrides>;
     /**
@@ -861,8 +1029,12 @@ declare class AgridProvider<T extends object = any> {
     allowAddRows: boolean;
     /** Whether the control column is rendered. */
     showControlColumn: boolean;
+    /** Whether the control column displays automatic row numbers. */
+    showRowNumbers: 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. */
@@ -873,6 +1045,8 @@ declare class AgridProvider<T extends object = any> {
     filterDebounceMs: number;
     /** Whether the global quick-filter box is shown above the grid. */
     enableQuickFilter: boolean;
+    /** Whether the formula/input bar is shown above the grid body. */
+    showFormulaBar: boolean;
     /** Commands rendered in the optional menu bar above the column headers. */
     menuBarItems: AgridMenuBarItem<T>[];
     /** Enabled sorting mode. */
@@ -891,6 +1065,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. */
@@ -904,6 +1080,11 @@ declare class AgridProvider<T extends object = any> {
         row: T;
         index: number;
     }) => string;
+    /** Optional application-owned row predicate applied by the client-side projection. */
+    externalFilter?: (params: {
+        row: T;
+        index: number;
+    }) => boolean;
     /** Optional callback designating rows pinned to the top or bottom of the body. */
     pinRow?: (row: T, index: number) => 'top' | 'bottom' | undefined;
     /** Whether master/detail expandable detail rows are enabled. */
@@ -912,8 +1093,18 @@ 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;
+    /** 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>;
     /** @deprecated Use `control.readonly` and `control.setReadonly()` instead. */
@@ -933,6 +1124,31 @@ declare class AgridProvider<T extends object = any> {
      * 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. */
@@ -970,6 +1186,8 @@ interface CellReadonlyParams<T extends object = any, K extends AgridField<T> = A
 }
 /** 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)'`. */
@@ -1078,6 +1296,34 @@ interface ValueOption<TValue = unknown> {
     /** Human-readable label shown in the cell, dropdown, and filter menu. */
     label: string;
 }
+/**
+ * Built-in editor surfaces available without registering a custom Angular component.
+ *
+ * - `'text'` uses the default single-line input.
+ * - `'largeText'` uses a multiline textarea for longer content.
+ * - `'richSelect'` uses a searchable select surface backed by `values` or `asyncValues`.
+ * - `'formula'` uses a formula-friendly input. Pair it with {@link ColDefBase.formula} to
+ *   evaluate strings that start with `=`.
+ */
+type AgridBuiltInEditor = 'text' | 'largeText' | 'richSelect' | 'formula';
+/** Parameters passed to {@link ColDefBase.asyncValues} when the rich-select editor opens. */
+interface AsyncValueOptionsParams<T extends object = any, K extends AgridField<T> = AgridField<T>> {
+    /** Row currently being edited. */
+    row: T;
+    /** Current raw value stored in the edited cell. */
+    value: T[K];
+    /** Column definition for the edited cell. */
+    column: ColDef<T, K>;
+    /** Original datasource index for the edited row. */
+    originalIndex: number;
+}
+/**
+ * Sync or async value options used by the built-in rich-select editor.
+ *
+ * Strings are stored and displayed as-is. {@link ValueOption} entries display `label` while
+ * committing `value` into the datasource.
+ */
+type AgridAsyncValues<TValue = unknown> = readonly (string | ValueOption<TValue>)[] | Promise<readonly (string | ValueOption<TValue>)[]>;
 /** Width sentinel that makes a column fill the remaining horizontal space. */
 declare const ColDefAutoSize = -1;
 /** Label definition for a group displayed above contiguous column headers. */
@@ -1087,6 +1333,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. */
@@ -1095,6 +1356,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`).
@@ -1141,6 +1404,24 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * ```
      */
     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.
      *
@@ -1149,6 +1430,24 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      *   displayed label (`label`). Useful when the dataset stores IDs but should show names.
      */
     values?: string[] | ValueOption<T[K]>[];
+    /**
+     * Built-in editor to use for this column.
+     * - `'richSelect'` renders a searchable select surface and can load async values.
+     * - `'largeText'` renders a multiline textarea for longer notes.
+     * - `'formula'` renders a formula input. Pair with `formula: true` to evaluate formulas.
+     * - `'text'` forces the default text input.
+     */
+    editor?: AgridBuiltInEditor;
+    /**
+     * Values loaded when the built-in rich-select editor opens. Use this for large or remote option
+     * lists. Static `values` are used immediately; `asyncValues` can return a Promise.
+     */
+    asyncValues?: (params: AsyncValueOptionsParams<T, K>) => AgridAsyncValues<T[K]>;
+    /**
+     * Evaluate strings beginning with `=` as row-local formulas for display, filtering, and export.
+     * Formulas support arithmetic, parentheses, and field-name references from the same row.
+     */
+    formula?: boolean;
     /**
      * Optional display formatter applied when the column has no `values` list.
      * Receives the raw cell value and returns the string to display in the cell.
@@ -1183,6 +1482,16 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * At least one filterable column must exist for the filter row to appear.
      */
     filterable?: boolean;
+    /**
+     * Custom component rendered inside this column's filter menu.
+     * The component injects `AGRID_FILTER_CONTEXT` to read and update the field filter.
+     */
+    filterComponent?: Type<unknown>;
+    /**
+     * Maximum number of value-filter choices rendered at once. Search still runs against the full
+     * value list, then caps the displayed matches. Defaults to `250`.
+     */
+    filterValueLimit?: number;
     /**
      * Set to `true` to allow grouping the grid by this column.
      * When set, the filter dropdown shows a "Group by" toggle for this column.
@@ -1241,10 +1550,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 }) =>
@@ -1255,6 +1580,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.
@@ -1285,6 +1622,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
@@ -1511,7 +1863,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> = {
@@ -1541,6 +1893,32 @@ type CellInfoEvent<T extends object = any> = {
         column: ColDef<T, K>;
     };
 }[AgridField<T>];
+/** Current selected row returned by {@link AgridComponent.getCurrentRow}. */
+interface AgridCurrentRow<T extends object = any> {
+    /** Selected datasource row. */
+    row: T;
+    /** Zero-based row index in the datasource. */
+    originalIndex: number;
+}
+/** Current selected cell returned by {@link AgridComponent.getCurrentCell} and emitted by `(cellSelect)`. */
+type AgridCurrentCell<T extends object = any> = {
+    [K in AgridField<T>]: {
+        /** Selected cell position. */
+        position: CellPosition;
+        /** Datasource row containing the selected cell. */
+        row: T;
+        /** Zero-based row index in the datasource. */
+        originalIndex: number;
+        /** Selected column field. */
+        field: K;
+        /** Current raw field value. */
+        value: T[K];
+        /** Column definition for the selected cell. */
+        column: ColDef<T, K>;
+    };
+}[AgridField<T>];
+/** Emitted when the selected cell changes. `null` means the cell selection was cleared. */
+type CellSelectEvent<T extends object = any> = AgridCurrentCell<T>;
 /**
  * Emitted asynchronously after an edit changes a row and the data source has been updated.
  *
@@ -1573,6 +1951,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. */
@@ -1604,6 +2021,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)`
@@ -1636,12 +2061,49 @@ interface PageChangeEvent {
     /** Zero-based index of the last row on this page (inclusive). */
     endRow: number;
 }
-/** Emitted when a header text filter or column-menu condition changes server-side. */
+/** Sort entry used by server-side query snapshots. */
+interface AgridServerSort {
+    /** Field name of the sorted column. */
+    field: string;
+    /** Sort direction for this field. */
+    direction: 'asc' | 'desc';
+}
+/**
+ * Complete server-side query snapshot derived from `AgridControl`.
+ *
+ * It is emitted by `(serverQueryChange)` and published as `AgridProvider.serverQuery` whenever
+ * `serverSideFiltering` is enabled or `AgridControl.totalRows` enables server-side pagination.
+ * `endRow` follows the existing `(pageChange)` event: it is inclusive. Server totals are not part
+ * of the query so updating `control.setTotalRows(...)` after a response does not itself trigger a
+ * second fetch.
+ */
+interface AgridServerQuery {
+    /** Active column filters keyed by field. */
+    filters: Readonly<Record<string, ColumnFilter>>;
+    /** Ordered sort stack after the grid's `sortOption` is applied. */
+    sort: readonly AgridServerSort[];
+    /** Global quick-filter text. Empty string when inactive. */
+    quickFilter: string;
+    /** Current page number (1-based). */
+    page: number;
+    /** Rows per page. `0` means no page size is configured. */
+    pageSize: number;
+    /** Zero-based index of the first requested row. */
+    startRow: number;
+    /** Zero-based index of the last requested row (inclusive), or `-1` when no rows are known. */
+    endRow: number;
+}
+/** Emitted when a header text, value, or column-menu condition changes server-side. */
 interface FilterChangeEvent {
     /** Field name of the filtered column. */
     field: string;
     /** Current free-text filter value. An empty string clears the text filter. */
     value: string;
+    /**
+     * Current value-checklist selection.
+     * `null` means all values are selected / no value filter is active.
+     */
+    selectedValues?: readonly string[] | null;
     /**
      * Text, number, or date condition operator from the column-menu UI.
      * `null` clears the condition.
@@ -1675,6 +2137,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 {
@@ -1731,17 +2237,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 */
@@ -1752,6 +2267,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>;
@@ -1858,7 +2387,7 @@ interface AgridSidebarDetailField {
 }
 
 /**
- * Excel-like data grid for Angular 21.
+ * Excel-like data grid for Angular 21 and 22.
  *
  * ## Minimal setup
  * ```html
@@ -1880,23 +2409,27 @@ 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 showRowNumbers: Signal<boolean>;
     readonly showControlColumn: Signal<boolean>;
-    readonly controlColumnWidth: Signal<48 | 24>;
+    readonly controlColumnWidth: Signal<number>;
     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 showFormulaBar: Signal<boolean>;
+    readonly menuBarItems: Signal<_thkl_agrid.AgridMenuBarItem<T>[]>;
     readonly quickFilterValue: Signal<string>;
     readonly sortOption: Signal<"single" | "multi" | "none">;
     readonly rowSelection: Signal<"single" | "multi" | "none">;
@@ -1915,11 +2448,16 @@ 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>;
         index: number;
     }) => string) | undefined>;
+    readonly externalFilterFn: Signal<((params: {
+        row: Record<string, unknown>;
+        index: number;
+    }) => boolean) | 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>;
@@ -1934,6 +2472,10 @@ declare class AgridComponent<T extends object = any> {
     readonly masterDetail: Signal<boolean>;
     /** Fixed detail-panel height in pixels. */
     readonly detailRowHeight: Signal<number>;
+    /** 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. */
@@ -1954,6 +2496,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>>;
     /**
@@ -1969,6 +2513,14 @@ 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>>;
@@ -1993,6 +2545,8 @@ declare class AgridComponent<T extends object = any> {
     filterChange: _angular_core.OutputEmitterRef<FilterChangeEvent>;
     /** Emitted when a column sort changes in server-side filtering mode. */
     sortChange: _angular_core.OutputEmitterRef<SortChangeEvent>;
+    /** Emitted with the complete server-side filter/sort/page query snapshot. */
+    serverQueryChange: _angular_core.OutputEmitterRef<AgridServerQuery>;
     /**
      * Emitted (debounced) when the global quick-filter text changes in server-side filtering mode.
      * The host should refetch rows matching the text. Not emitted in client mode, where the grid
@@ -2003,12 +2557,15 @@ declare class AgridComponent<T extends object = any> {
     validationFailed: _angular_core.OutputEmitterRef<ValidationFailedEvent<any>>;
     /** Emitted when a column's optional cell information button is clicked. */
     cellInfo: _angular_core.OutputEmitterRef<CellInfoEvent<T>>;
+    /** Emitted when the selected cell changes. `null` = cell selection cleared. */
+    cellSelect: _angular_core.OutputEmitterRef<CellSelectEvent<T> | null>;
     /** 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>;
+    private lastEmittedCell;
     /** Original indices of rows whose master/detail panel is currently expanded. */
     private readonly _expandedDetailIds;
     /**
@@ -2017,13 +2574,17 @@ declare class AgridComponent<T extends object = any> {
      * provider predicate by {@link effectivePinRow}.
      */
     private readonly _pinnedRows;
+    readonly formulaBarDraft: _angular_core.WritableSignal<string>;
+    private readonly formulaBarFocused;
+    private formulaBarEditCell;
     private readonly markedIndices;
+    private readonly markedFields;
+    private firstDataRenderedEmitted;
+    private serverQueryProvider;
     /** 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. */
@@ -2038,6 +2599,13 @@ declare class AgridComponent<T extends object = any> {
     get editSeedChar(): _angular_core.WritableSignal<string>;
     /** Whether the active text editor should select all text when it opens. */
     get selectTextOnEdit(): _angular_core.WritableSignal<boolean>;
+    /** Return the first currently selected row, or `null` when no row is selected. */
+    getCurrentRow(): AgridCurrentRow<T> | null;
+    /** Return the currently selected cell with row, field, value, and column metadata. */
+    getCurrentCell(): AgridCurrentCell<T> | null;
+    readonly formulaBarLabel: Signal<string>;
+    private resolveCurrentCell;
+    private sameCell;
     /** Toggle the sidebar open/closed. */
     toggleSidebar(): void;
     /** @internal */
@@ -2050,25 +2618,20 @@ declare class AgridComponent<T extends object = any> {
     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.
@@ -2076,6 +2639,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`. */
@@ -2111,6 +2680,35 @@ 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[]>;
+    /** @internal Whether a pane needs per-cell span resolution. */
+    readonly pinnedPaneHasSpans: Signal<boolean>;
+    readonly scrollablePaneHasSpans: Signal<boolean>;
+    readonly rightPaneHasSpans: Signal<boolean>;
+    /**
+     * 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;
@@ -2142,14 +2740,36 @@ 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>>;
+    /** Maps originalIndex → 1-based filtered/sorted row number for the control column. */
+    readonly rowNumbers: Signal<Map<number, number>>;
+    /** Width needed for the largest currently rendered row number. */
+    readonly rowNumberColumnWidth: Signal<number>;
     readonly displayItems: Signal<GridItem[]>;
     /** Rows pinned to the top of the body (rendered in a fixed container, outside virtual scroll). */
     readonly pinnedTopItems: Signal<{
@@ -2186,6 +2806,16 @@ declare class AgridComponent<T extends object = any> {
     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>;
@@ -2206,18 +2836,29 @@ 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. */
@@ -2233,6 +2874,8 @@ declare class AgridComponent<T extends object = any> {
     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. */
@@ -2249,20 +2892,21 @@ declare class AgridComponent<T extends object = any> {
     private readonly _seededControls;
     private readonly dirtyInlineRows;
     private dirtyRowsDataSource;
-    private readonly changedCells;
     private changedCellsDataSource;
+    private dirtyInlineRowsIdleTimer;
+    private readonly dirtyInlineRowsIdleFlushMs;
     private emitEditEvents;
     private emitSidebarEditEvents;
     private emitRecordEdit;
     private markInlineRowDirty;
     private markCellChanged;
-    private changedCellKey;
-    private parseChangedCellKey;
     private flushDirtyInlineRows;
+    private scheduleDirtyInlineRowsIdleFlush;
+    private clearDirtyInlineRowsIdleFlush;
     private reconcileDirtyInlineRowsAfterRemoval;
-    private reconcileChangedCellsAfterRemoval;
     private emitRowChanged;
     private createRecordEvent;
+    private buildServerQuery;
     constructor();
     /** @internal */
     isDataRowItem(item: GridItem): item is {
@@ -2284,12 +2928,31 @@ declare class AgridComponent<T extends object = any> {
     isPathTreeNodeItem(item: GridItem): boolean;
     /** @internal */
     getItemOriginalIndex(item: GridItem): number | null;
+    /** @internal 1-based row number for visible data rows. */
+    visibleRowNumber(item: GridItem): number | null;
     /** @internal True when the item is a master/detail panel row. */
     isDetailRowItem(item: GridItem): item is DetailRowItem;
     /** @internal Rendered pixel height of a virtual-scroll item (detail panels are taller). */
     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. */
@@ -2369,6 +3032,8 @@ declare class AgridComponent<T extends object = any> {
     /** @internal Whether more than one column is currently sorted. */
     hasMultiSort(): boolean;
     getTextFilter(field: string): string;
+    /** @internal Complete filter snapshot for custom filter components. */
+    getColumnFilter(field: string): ColumnFilter;
     /** @internal Condition input type for a column, or `null` when unsupported. */
     getMenuFilterType(field: string): 'text' | 'number' | 'date' | null;
     /** @internal Short label for an active header condition. */
@@ -2428,6 +3093,22 @@ declare class AgridComponent<T extends object = any> {
     onStartEdit(originalIndex: number, ci: number): void;
     /** @internal */
     onDraftChange(value: unknown): void;
+    /** @internal */
+    onFormulaBarFocus(): void;
+    /** @internal */
+    onFormulaBarInput(event: Event): void;
+    /** @internal */
+    onFormulaBarBlur(): void;
+    /** @internal */
+    onFormulaBarKeydown(event: KeyboardEvent): void;
+    /** @internal */
+    commitFormulaBar(targetCell?: CellPosition | null): boolean;
+    private finishFormulaBarInteraction;
+    private resetFormulaBarDraft;
+    /** @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
@@ -2444,6 +3125,7 @@ declare class AgridComponent<T extends object = any> {
     onCellPointerDown(event: PointerEvent, originalIndex: number, colIndex: number): void;
     /** @internal Main keyboard handler delegated from the wrapper div. */
     onKeyDown(event: KeyboardEvent): void;
+    private isToolbarInputEvent;
     /** @internal Clears cell navigation while a header filter control owns focus. */
     onGridFocusIn(event: FocusEvent): void;
     /** Open the find panel and focus its input. */
@@ -2461,12 +3143,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. */
@@ -2487,28 +3181,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. */
@@ -2525,8 +3203,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. */
@@ -2544,7 +3220,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 */
@@ -2564,14 +3240,23 @@ declare class AgridComponent<T extends object = any> {
     /** @internal */
     onMenuToggleValue(field: string, rawStr: string): void;
     /** @internal */
+    onMenuReplaceFilter(field: string, filter: ColumnFilter): void;
+    /** @internal */
     onSidebarToggleColumn(field: string): void;
     /** @internal Sets every column in a sidebar header group to the requested visibility. */
     onSidebarToggleColumnGroup(fields: string[], visible: boolean): void;
     /** @internal Mirrors vertical scrolling from the main viewport into both pinned panes. */
     onBodyScroll(): void;
     private ensureServerRowsVisible;
+    /** Refresh the attached server-side row model and optionally reset vertical scroll to row zero. */
+    refreshServerSideRows(options?: {
+        purge?: boolean;
+        resetScroll?: boolean;
+    }): void;
     /** @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 */
@@ -2606,7 +3291,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"; "settingsChange": "settingsChange"; "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"; "serverQueryChange": "serverQueryChange"; "quickFilterChange": "quickFilterChange"; "validationFailed": "validationFailed"; "cellInfo": "cellInfo"; "cellSelect": "cellSelect"; "menuBarAction": "menuBarAction"; "detailAction": "detailAction"; }, never, never, true, never>;
 }
 
 /** Identifier supported by the standalone page selector. */
@@ -2708,6 +3393,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>>;
@@ -2747,9 +3433,317 @@ 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>>;
+
+/**
+ * Runtime context handed to a custom column-filter component through dependency injection.
+ *
+ * Custom filters should write normal {@link ColumnFilter} state through {@link setFilter}. That
+ * keeps filter persistence, server query generation, and the active-filter header state aligned
+ * with built-in filters.
+ *
+ * @example
+ * ```ts
+ * const ctx = inject(AGRID_FILTER_CONTEXT);
+ * ctx.setFilter({ ...ctx.filter(), text: 'active' });
+ * ```
+ */
+interface AgridFilterContext {
+    /** Field currently being filtered. */
+    readonly field: string;
+    /** Column definition for the active filter menu. */
+    readonly column: ColDef;
+    /** Shared grid control that owns filter state. */
+    readonly control: AgridControl | null;
+    /** Current filter snapshot for this field. */
+    readonly filter: Signal<ColumnFilter>;
+    /** Replace this field's filter state, preserving any fields the component copies forward. */
+    setFilter(filter: ColumnFilter): void;
+    /** Clear this field's filter state. */
+    clear(): void;
+    /** Close the column menu. */
+    close(): void;
+}
+/**
+ * DI token a custom {@link ColDef.filterComponent} injects to control column filtering.
+ *
+ * The token is only available while the component is rendered inside an aGrid column menu.
+ */
+declare const AGRID_FILTER_CONTEXT: InjectionToken<AgridFilterContext>;
+
+/**
+ * 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, AgridServerSideRowModel, AgridTreeComponent, AgridTreeProvider, ColDefAutoSize };
-export type { AgridAggregate, AgridControlState, AgridEnterEditAction, AgridField, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridMenuBarContext, AgridMenuBarItem, AgridMenuBarMenuItem, AgridMenuBarState, AgridPageId, AgridPageItem, AgridParentTreeConfig, AgridPathSegmentParams, AgridPathTreeConfig, AgridPivotConfig, AgridPivotSettings, AgridProviderConfig, AgridServerSideDatasource, AgridServerSideRequest, AgridServerSideResult, AgridServerSideRowModelConfig, AgridServerSideSort, AgridSettings, AgridTreeConfig, AgridTreeNodeEvent, AgridTreeProviderConfig, AgridTreeSelectionEvent, AgridTreeSelectionMode, CellContextMenuItem, CellFormat, CellFormatParams, 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_FILTER_CONTEXT, AGRID_LOCALE_TEXT, AGRID_RENDERER_CONTEXT, AgridBrowserAdapter, AgridChartComponent, AgridChartProvider, AgridComponent, AgridControl, AgridDataSource, AgridPageSelectorComponent, AgridProvider, AgridServerSideRowModel, AgridTreeComponent, AgridTreeProvider, ColDefAutoSize, buildChart };
+export type { AgridAggregate, AgridAsyncValues, AgridBuiltInEditor, AgridChartData, AgridChartLayout, AgridChartOptions, AgridChartProviderConfig, AgridChartSeries, AgridChartType, AgridColumnHeaderMenuItem, AgridControlState, AgridCurrentCell, AgridCurrentRow, AgridEditorContext, AgridEnterEditAction, AgridField, AgridFilterContext, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridMenuBarContext, AgridMenuBarItem, AgridMenuBarMenuItem, AgridMenuBarState, AgridPageId, AgridPageItem, AgridParentTreeConfig, AgridPathSegmentParams, AgridPathTreeConfig, AgridPivotConfig, AgridPivotSettings, AgridProviderConfig, AgridRendererContext, AgridRowIndication, AgridSelectionSummary, AgridServerQuery, AgridServerSideDatasource, AgridServerSideRefreshOptions, AgridServerSideRequest, AgridServerSideResult, AgridServerSideRowModelConfig, AgridServerSideSort, AgridServerSort, AgridSettings, AgridTreeConfig, AgridTreeNodeEvent, AgridTreeProviderConfig, AgridTreeSelectionEvent, AgridTreeSelectionMode, AsyncValueOptionsParams, CellContextMenuItem, CellFormat, CellFormatParams, CellInfoEvent, CellPosition, CellReadonlyParams, CellSelectEvent, 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