@thkl/agrid 0.1.11 → 0.1.12

package/types/thkl-agrid.d.ts

@@ -1,5 +1,5 @@
 import * as _angular_core from '@angular/core';
-import { Signal, WritableSignal, DestroyRef } from '@angular/core';
+import { Signal, WritableSignal, Type, DestroyRef, OnChanges, InjectionToken } from '@angular/core';
 import * as _thkl_agrid from '@thkl/agrid';
 
 /** Guarded access to browser-only APIs used by the grid. @internal */
@@ -34,6 +34,9 @@ declare class AgridBrowserAdapter {
     writeClipboard(text: string): Promise<boolean>;
     /** Downloads text through a temporary object URL and anchor element. */
     downloadText(filename: string, text: string, mimeType: string): boolean;
+    /** Downloads raw bytes (e.g. a generated `.xlsx`) through a temporary object URL. */
+    downloadBytes(filename: string, bytes: Uint8Array, mimeType: string): boolean;
+    private downloadBlob;
 }
 
 /**
@@ -80,6 +83,15 @@ interface ColumnFilter {
     /** Upper-bound operand used only when {@link operator} is `'between'`. */
     operand2?: string | null;
 }
+/** Transient row indication state produced by {@link AgridControl.indicate}. */
+interface AgridRowIndication {
+    /** CSS color shown while the row flash is active. */
+    color: string;
+    /** Fade duration in milliseconds. */
+    durationMs: number;
+    /** `true` while the row flash is present. */
+    active: boolean;
+}
 /** Serializable snapshot of the grid's UI state. Used with `toJSON` / `fromJSON`. */
 interface AgridControlState {
     /** Per-field column width overrides in pixels. */
@@ -150,12 +162,38 @@ declare class AgridControl {
     private readonly _loading;
     private readonly _readonly;
     private readonly _autoAddRows;
+    private readonly _rowIndications;
+    private readonly _changedCells;
+    private readonly rowIndicationTimers;
     /** @param state Optional initial state, e.g. deserialized from storage. */
     constructor(state?: Partial<AgridControlState>);
     /** Whether the grid displays its loading overlay. This transient state is not serialized. */
     readonly loading: Signal<boolean>;
     /** Show or hide the grid loading overlay. */
     setLoading(value: boolean): void;
+    /** Transient row flash indicators keyed by original datasource row index. */
+    readonly rowIndications: Signal<ReadonlyMap<number, AgridRowIndication>>;
+    /**
+     * Flash one datasource row with `color`, then fade back over `durationMs`.
+     * This is transient UI state and is not serialized.
+     */
+    indicate(rowIndex: number, color: string, durationMs?: number): void;
+    private clearRowIndicationTimers;
+    /** Changed-cell markers keyed by original datasource row index and field. */
+    readonly changedCells: Signal<ReadonlySet<string>>;
+    /** Mark one cell as changed. Used by the grid when `showChangedCellIndicator` is enabled. */
+    markChangedCell(rowIndex: number, field: string): void;
+    /**
+     * Clears changed-cell markers after persistence succeeds.
+     * Omit `rowIndex` to clear every marker; omit `fields` to clear the whole row.
+     */
+    clearChangedCells(rowIndex?: number, fields?: readonly string[]): void;
+    /** Returns whether one cell is currently marked as changed. */
+    isCellChanged(rowIndex: number, field: string): boolean;
+    /** Reconciles changed-cell markers after a datasource row is removed. */
+    reconcileChangedCellsAfterRemoval(removedIndex: number): void;
+    private changedCellKey;
+    private parseChangedCellKey;
     /** Whether all grid editing and mutation UI is disabled. This transient state is not serialized. */
     readonly readonly: Signal<boolean>;
     /** Enable or disable readonly mode at runtime. */
@@ -567,6 +605,7 @@ interface AgridLocaleText {
     close: string;
     columnMenu: string;
     columns: string;
+    collapse: string;
     detail: string;
     toggleDetail: string;
     hiddenColumn: string;
@@ -606,6 +645,7 @@ interface AgridLocaleText {
     lastPage: string;
     loading: string;
     markRow: string;
+    moreInformation: string;
     next: string;
     noRows: string;
     pagination: string;
@@ -622,6 +662,7 @@ interface AgridLocaleText {
     unpinRow: string;
     previous: string;
     resizeColumn: string;
+    expand: string;
     rows: (count: number) => string;
     quickFilterPlaceholder: string;
     searchValuesPlaceholder: string;
@@ -632,6 +673,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>;
@@ -698,6 +744,8 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     showControlColumn?: boolean;
     /** Show row-marking checkboxes in a 48 px control column for clipboard inclusion. @default false */
     enableRowMarking?: boolean;
+    /** Allow clicking column headers to mark complete columns. @default false */
+    enableColumnMarking?: boolean;
     /** Show the sidebar panel. */
     showSidebar?: boolean;
     /** Automatically open the detail panel when a row is selected. */
@@ -752,6 +800,12 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     cellMenuItems?: (CellContextMenuItem<T> | null)[];
     /** Shade every other row slightly for easier reading. @default false */
     zebraStripes?: boolean;
+    /**
+     * Render only the scrollable columns near the horizontal viewport once the scrollable-column
+     * count exceeds this threshold. Lower it to virtualize sooner, or set a very large value
+     * (e.g. `Infinity`) to disable column virtualization entirely. @default 30
+     */
+    columnVirtualizationThreshold?: number;
     /** Show a color marker on cells changed through grid editing. @default false */
     showChangedCellIndicator?: boolean;
     /** Ask for confirmation before grid row-delete actions. @default false */
@@ -808,8 +862,18 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     detailRenderer?: (params: {
         row: T;
     }) => string;
+    /** Column displayed as a multiline editable field beneath the custom detail renderer. */
+    detailColumnField?: AgridField<T>;
+    /** Optional text-template buttons shown above the editable master/detail textarea. */
+    detailActions?: DetailAction<T>[];
     /** Fixed height in pixels of an expanded detail panel row. @default 200 */
     detailRowHeight?: number;
+    /** this is the id of the grid its stored in the provider the grid will read it as signal */
+    gridId?: string;
+    /** Hides the grids status bar if set to true. @default false */
+    hideGridStatusBar?: boolean;
+    /** Enable Menubuttons for csv and xsls export @default false */
+    enableExportButtons?: boolean;
 }
 /**
  * Bundles a grid's data source, control state, columns, and display options.
@@ -817,6 +881,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 +913,20 @@ declare class AgridProvider<T extends object = any> {
     /** Shared grid options such as locale. */
     options: AGridOptions;
     private readonly _localizations;
+    private exportBridge;
+    private readonly _visibleRows;
+    /**
+     * The grid's currently filtered and sorted rows, as published by the rendered grid component.
+     * Falls back to every datasource row when no grid is attached. Link a chart to this signal to
+     * keep it in sync with the grid's filters and sorting.
+     */
+    readonly visibleRows: Signal<readonly T[]>;
+    /**
+     * @internal Published by the rendered grid whenever its filtered/sorted projection changes.
+     * Pass `null` on teardown so {@link visibleRows} falls back to the raw datasource. The grid works
+     * in terms of record rows; the public {@link visibleRows} re-types them as `T`.
+     */
+    ɵsetVisibleRows(rows: readonly Record<string, unknown>[] | null): void;
     /** Read-only view of registered per-locale text overrides. Used by the grid to resolve locale text. */
     get localizations(): ReadonlyMap<string, AgridLocaleTextOverrides>;
     /**
@@ -863,6 +950,8 @@ declare class AgridProvider<T extends object = any> {
     showControlColumn: boolean;
     /** Whether rows can be marked for inclusion in clipboard copies. */
     enableRowMarking: boolean;
+    /** Whether complete columns can be marked from their headers. */
+    enableColumnMarking: boolean;
     /** Whether the sidebar is available. */
     showSidebar: boolean;
     /** Whether selecting a row automatically opens its detail panel. */
@@ -891,6 +980,8 @@ declare class AgridProvider<T extends object = any> {
     cellMenuItems: (CellContextMenuItem<T> | null)[];
     /** Whether alternating data rows receive stripe styling. */
     zebraStripes: boolean;
+    /** Scrollable-column count above which column virtualization activates. */
+    columnVirtualizationThreshold: number;
     /** Whether committed cell changes receive a visual marker. */
     showChangedCellIndicator: boolean;
     /** Whether grid row-delete actions require in-row confirmation. */
@@ -912,8 +1003,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 +1034,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 +1096,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)'`. */
@@ -1087,6 +1215,21 @@ interface HeaderGroup {
     /** Text displayed in the grouped header row. */
     label: string;
 }
+/** Custom command appended to a column's header menu. */
+interface AgridColumnHeaderMenuItem {
+    /** Stable key emitted through `(columnHeaderAction)`. */
+    key: string;
+    /** Visible command label. */
+    label: string;
+    /** Optional compact icon or glyph shown before the label. */
+    icon?: string;
+    /** Disable the command without hiding it. */
+    disabled?: boolean;
+    /** Class a optional classes for the icon */
+    iconClasses?: string[];
+    /** Classes to apply on the complete button */
+    itemClasses?: string[];
+}
 /** Defines the behavior shared by every typed column. */
 interface ColDefBase<T extends object, K extends AgridField<T>> {
     /** Data field name — must match a key in the row object. */
@@ -1095,6 +1238,8 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
     header: string;
     /** Optional header-group identifier configured through `AgridProvider.headerGroups`. */
     group?: string;
+    /** Custom commands appended to this column's header menu. */
+    headerMenuItems?: AgridColumnHeaderMenuItem[];
     /**
      * Default column width in pixels. Can be overridden at runtime via {@link AgridControl}.
      * Use `-1` (or omit) to make the column auto-scale and fill available space (`1fr`).
@@ -1141,6 +1286,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.
      *
@@ -1241,10 +1404,26 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * ```
      */
     validate?: (value: T[K], row: T) => string | null | undefined;
+    /**
+     * Custom component rendered for the cell's display (read) state, instead of the plain text value.
+     * The component injects {@link AGRID_RENDERER_CONTEXT} to read the value, row, and column. Unlike
+     * {@link cellRenderer}, this supports full Angular bindings, event handlers, and child components
+     * with no manual escaping.
+     *
+     * @example
+     * ```ts
+     * { field: 'status', cellRendererComponent: StatusBadgeComponent }
+     * ```
+     */
+    cellRendererComponent?: Type<unknown>;
     /**
      * Custom cell renderer. Returns an HTML string displayed instead of the plain text value.
      * Angular's built-in HTML sanitization is applied automatically.
      *
+     * @deprecated Use {@link cellRendererComponent} instead. A component renderer supports Angular
+     * bindings and event handlers, and avoids the HTML-string escaping/sanitization caveats. The
+     * string renderer remains supported for now but will be removed in a future release.
+     *
      * @example
      * ```ts
      * { field: 'status', cellRenderer: ({ value }) =>
@@ -1255,6 +1434,18 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
         value: T[K];
         row: T;
     }) => string;
+    /**
+     * Custom editor component shown while the cell is in edit mode, instead of the built-in
+     * text input / dropdown / checkbox. The component injects {@link AGRID_EDITOR_CONTEXT} to read
+     * the current value and stage drafts; the grid keeps ownership of validation, history, and the
+     * commit/cancel lifecycle, so Tab, Enter, and Escape work without extra wiring.
+     *
+     * @example
+     * ```ts
+     * { field: 'rating', cellEditor: RatingEditor }
+     * ```
+     */
+    cellEditor?: Type<unknown>;
     /**
      * Show a right-aligned info button in this column's cells.
      * Pass a predicate to show it only for selected rows or values.
@@ -1285,6 +1476,21 @@ interface GroupAction {
     /** Called with the group's display label when the item is clicked. */
     action: (groupLabel: string) => void;
 }
+/** Parameters passed to a master/detail text-template action. */
+interface DetailActionParams<T extends object = any> {
+    /** Row shown by the expanded detail panel. */
+    row: T;
+    /** Original datasource index of the row. */
+    rowIndex: number;
+}
+/** Text-template button shown above the editable master/detail textarea. */
+interface DetailAction<T extends object = any> {
+    id: string;
+    /** Button text. */
+    label: string;
+    /** Text inserted into the detail textarea, or a row-aware resolver. */
+    text?: string | ((params: DetailActionParams<T>) => string);
+}
 /**
  * Internal row item used in the virtual scroll list.
  * - `{ row, originalIndex }` — a real data row
@@ -1511,7 +1717,7 @@ interface ValidationFailedEvent<T extends object = any> {
     /** Message returned by the `validate` hook. */
     message: string;
     /** Which editing surface produced the rejected edit. */
-    source: 'inline' | 'sidebar';
+    source: 'inline' | 'sidebar' | 'detail';
 }
 /** Emitted by `(cellEdit)` after the user commits a cell change. */
 type GridEditEvent<T extends object = any> = {
@@ -1573,6 +1779,45 @@ interface RowSelectEvent<T extends object = any> {
         originalIndex: number;
     }[];
 }
+/** Emitted when a row is marked or unmarked through the row header or marker checkbox. */
+interface RowMarkEvent<T extends object = any> {
+    /** Row whose mark state changed. */
+    row: T;
+    /** Zero-based index of the row in the data source. */
+    originalIndex: number;
+    /** Current mark state after the interaction. */
+    marked: boolean;
+}
+/** Emitted when a column is marked or unmarked from its header. */
+interface ColumnMarkEvent<T extends object = any> {
+    column: ColDef<T>;
+    field: AgridField<T>;
+    marked: boolean;
+}
+/** Emitted when a custom column-header menu command is selected. */
+interface ColumnHeaderActionEvent<T extends object = any> {
+    column: ColDef<T>;
+    key: string;
+}
+/** Emitted once after the grid first renders with rows from its active datasource. */
+interface FirstDataRenderedEvent<T extends object = any> {
+    /** Rows present in the datasource for the first non-empty render. */
+    rows: readonly T[];
+    /** Number of rows present for that render. */
+    rowCount: number;
+    /** Provider attached to the rendered grid. */
+    provider: AgridProvider<T>;
+    /** Active datasource that supplied the rows. */
+    datasource: AgridDataSource<T>;
+}
+/** Live numeric statistics for the active cell or range selection. */
+interface AgridSelectionSummary {
+    count: number;
+    sum: number;
+    average: number;
+    min: number;
+    max: number;
+}
 /** Emitted when the user clicks a data row. */
 interface RowClickEvent<T extends object = any> {
     /** Snapshot of the clicked row. */
@@ -1604,6 +1849,14 @@ interface RowUpdateEvent<T extends object = any> {
     /** Zero-based index of the updated row in the data source. */
     originalIndex: number;
 }
+interface RowDetailActionEvent<T extends object = any> {
+    /** the id of the button */
+    id: string;
+    /** Updated row data. */
+    row: T;
+    /** Zero-based index of the updated row in the data source. */
+    originalIndex: number;
+}
 /**
  * Emitted by `(rowReorder)` when the user finishes dragging a row to a new position.
  * The grid does **not** reorder data itself — call `dataSource.moveRow(oldIndex, newIndex)`
@@ -1675,6 +1928,50 @@ interface NewRecord<T extends object = any> {
     /** Exact data source containing the inserted row. */
     datasource: AgridDataSource<T>;
 }
+/**
+ * Precomputed per-column header state. @internal
+ *
+ * The header/filter rows would otherwise call a dozen helpers per column on every
+ * change-detection pass (e.g. `getSort`, `hasActiveFilter`, `isColDragging`). The header
+ * view-model computeds resolve all of that once per column — and only when an underlying
+ * signal changes — so the template reads plain fields instead.
+ */
+interface AgridHeaderColumn {
+    col: ColDef;
+    field: string;
+    ariaColIndex: number;
+    sort: 'asc' | 'desc' | null;
+    sortPriority: number;
+    hasFilter: boolean;
+    dragging: boolean;
+    dropSide: 'before' | 'after' | null;
+    reorderOffset: number;
+    grouped: boolean;
+    lastPinned: boolean;
+    firstRightPinned: boolean;
+    columnWidth: number;
+    textFilter: string;
+    menuFilterType: 'text' | 'number' | 'date' | null;
+    hasCondition: boolean;
+    conditionLabel: string;
+}
+/**
+ * Precomputed per-column state for the data-row, footer, and ghost cell loops. @internal
+ *
+ * Deliberately leaner than {@link AgridHeaderColumn}: it omits sort/filter state so the body
+ * view-model only changes on column layout, drag, or pinning — sorting or filtering does not
+ * invalidate it (and therefore does not force every rendered cell to re-render).
+ */
+interface AgridBodyColumn {
+    col: ColDef;
+    field: string;
+    visibleColIndex: number;
+    ariaColIndex: number;
+    dragging: boolean;
+    reorderOffset: number;
+    lastPinned: boolean;
+    firstRightPinned: boolean;
+}
 
 /** View state for the floating column header shown during a reorder drag. @internal */
 interface AgridColumnDragPreview {
@@ -1731,17 +2028,26 @@ interface AgridColumnMenuValueItem {
 /** Position and target field of the open column menu. @internal */
 type AgridColumnMenuState = {
     field: string;
+    mode: 'column' | 'condition';
     x: number;
     y: number;
 };
 
-/** One contiguous segment in the optional grouped-header row. @internal */
-interface AgridHeaderGroupRun {
-    key: string;
-    id: string | null;
-    label: string;
-    fields: string[];
-    span: number;
+/**
+ * The contiguous slice of scrollable columns to render, plus the pixel widths of the
+ * hidden columns on either side (used to size leading/trailing spacer grid items so the
+ * full column layout and scroll width are preserved).
+ * @internal
+ */
+interface AgridColumnWindow {
+    /** Index of the first rendered scrollable column (inclusive). */
+    start: number;
+    /** Index just past the last rendered scrollable column (exclusive). */
+    end: number;
+    /** Combined width of the hidden columns before {@link start}. */
+    leftWidth: number;
+    /** Combined width of the hidden columns from {@link end} onward. */
+    rightWidth: number;
 }
 
 /** Rectangular bounds in projected row and visible column coordinates. @internal */
@@ -1752,6 +2058,20 @@ type VisibleCellBounds = {
     colEnd: number;
 };
 
+/** One contiguous segment in the optional grouped-header row. @internal */
+interface AgridHeaderGroupRun {
+    key: string;
+    id: string | null;
+    label: string;
+    fields: string[];
+    span: number;
+}
+/** A grouped-header run enriched with reactive lock/drag state. @internal */
+interface AgridHeaderGroup extends AgridHeaderGroupRun {
+    locked: boolean;
+    dragging: boolean;
+}
+
 /** Dependencies and callbacks required by {@link AgridDragHandler}. @internal */
 interface AgridDragHandlerOptions {
     dataSource: Signal<AgridDataSource>;
@@ -1880,23 +2200,25 @@ interface AgridSidebarDetailField {
  * | Escape | Close any open menu or cancel edit |
  * | Tab / Enter (while editing) | Commit and move according to navigation settings |
  */
-declare class AgridComponent<T extends object = any> {
+declare class AgridComponent<T extends object = any> implements OnChanges {
     /** Grid provider containing columns, data source, control, and options. */
     provider: _angular_core.InputSignal<AgridProvider<T>>;
+    private restoredProvider?;
     readonly rowHeight: Signal<number>;
     readonly minHeight: Signal<string | undefined>;
     readonly maxHeight: Signal<string | undefined>;
     readonly allowAddRows: Signal<boolean>;
     readonly autoAddRows: Signal<boolean>;
     readonly enableRowMarking: Signal<boolean>;
+    readonly enableColumnMarking: Signal<boolean>;
     readonly showControlColumn: Signal<boolean>;
-    readonly controlColumnWidth: Signal<48 | 24>;
+    readonly controlColumnWidth: Signal<24 | 48>;
     readonly showSidebar: Signal<boolean>;
     readonly autoOpenDetail: Signal<boolean>;
     readonly serverSideFiltering: Signal<boolean>;
     readonly filterDebounceMs: Signal<number>;
     readonly enableQuickFilter: Signal<boolean>;
-    readonly menuBarItems: Signal<AgridMenuBarItem<T>[]>;
+    readonly menuBarItems: Signal<_thkl_agrid.AgridMenuBarItem<T>[]>;
     readonly quickFilterValue: Signal<string>;
     readonly sortOption: Signal<"single" | "multi" | "none">;
     readonly rowSelection: Signal<"single" | "multi" | "none">;
@@ -1915,6 +2237,7 @@ declare class AgridComponent<T extends object = any> {
     readonly loading: Signal<boolean>;
     readonly emptyText: Signal<string | undefined>;
     readonly useSidebarEditor: Signal<boolean>;
+    readonly hideGridStatusBar: Signal<boolean | undefined>;
     /** Host callback for per-row CSS classes, or `undefined`. */
     readonly rowClassFn: Signal<((params: {
         row: Record<string, unknown>;
@@ -1934,6 +2257,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 +2281,8 @@ declare class AgridComponent<T extends object = any> {
     readonly localeText: Signal<AgridLocaleText>;
     /** Effective empty-state label. */
     readonly emptyTextLabel: Signal<string>;
+    readonly gridId: Signal<string | undefined>;
+    readonly enableExportButtons: Signal<boolean | undefined>;
     /** Emitted after the user commits a cell edit. */
     cellEdit: _angular_core.OutputEmitterRef<GridEditEvent<T>>;
     /**
@@ -1969,6 +2298,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>>;
@@ -2005,10 +2342,10 @@ declare class AgridComponent<T extends object = any> {
     cellInfo: _angular_core.OutputEmitterRef<CellInfoEvent<T>>;
     /** Emitted for every enabled menu-bar button or dropdown item, carrying its configured id. */
     menuBarAction: _angular_core.OutputEmitterRef<string>;
+    /** Emitted if there is a Detail pane Action without text property */
+    detailAction: _angular_core.OutputEmitterRef<RowDetailActionEvent<T>>;
     /** Currently focused cell, or `null`. */
     readonly selectedCell: _angular_core.WritableSignal<CellPosition | null>;
-    /** Original index of the row awaiting delete confirmation, or `null`. */
-    readonly pendingDeleteRow: _angular_core.WritableSignal<number | null>;
     /** Original indices of rows whose master/detail panel is currently expanded. */
     private readonly _expandedDetailIds;
     /**
@@ -2018,12 +2355,12 @@ declare class AgridComponent<T extends object = any> {
      */
     private readonly _pinnedRows;
     private readonly markedIndices;
+    private readonly markedFields;
+    private firstDataRenderedEmitted;
     /** Original datasource indices marked for inclusion in copy operations. */
     readonly markedRowIndices: Signal<ReadonlySet<number>>;
-    /** Horizontal position of the delete prompt inside the scrollable row. */
-    readonly deleteConfirmationLeft: _angular_core.WritableSignal<number>;
-    /** Visible width available to the delete prompt. */
-    readonly deleteConfirmationWidth: _angular_core.WritableSignal<number>;
+    /** Fields currently marked as complete columns. */
+    readonly markedColumnFields: Signal<ReadonlySet<string>>;
     /** Rectangular cell range selected by Shift+arrow or Shift+click. */
     readonly selectedRange: _angular_core.WritableSignal<CellRange | null>;
     /** @internal Stable callback passed to child components for row-aware editability checks. */
@@ -2050,25 +2387,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 +2408,12 @@ declare class AgridComponent<T extends object = any> {
     clearChangedCells(originalIndex?: number, fields?: readonly string[]): void;
     /** @internal Whether a cell has an unsaved-change marker. */
     isCellChanged(originalIndex: number, field: string): boolean;
+    /** @internal Whether a row is currently in the colored phase of a control indication. */
+    rowIndicationActive(originalIndex: number): boolean;
+    /** @internal CSS color for a transient row indication. */
+    rowIndicationColor(originalIndex: number): string | null;
+    /** @internal Fade duration for a transient row indication. */
+    rowIndicationDuration(originalIndex: number): number | null;
     /** @internal Full display value for a cell — used as the `title` tooltip attribute. */
     getCellTitle(col: ColDef, value: unknown): string;
     /** @internal Dynamic CSS class string for a cell from `ColDef.cellClass`. */
@@ -2111,6 +2449,31 @@ declare class AgridComponent<T extends object = any> {
     readonly pinnedHeaderGroupRuns: Signal<AgridHeaderGroupRun[]>;
     readonly scrollableHeaderGroupRuns: Signal<AgridHeaderGroupRun[]>;
     readonly rightHeaderGroupRuns: Signal<AgridHeaderGroupRun[]>;
+    /** @internal Header view-model for the left-pinned, scrollable, and right-pinned panes. */
+    readonly pinnedHeaderColumns: Signal<AgridHeaderColumn[]>;
+    readonly scrollableHeaderColumns: Signal<AgridHeaderColumn[]>;
+    readonly rightHeaderColumns: Signal<AgridHeaderColumn[]>;
+    /** @internal Grouped-header view-model per pane (run + reactive lock/drag state). */
+    readonly pinnedHeaderGroups: Signal<AgridHeaderGroup[]>;
+    readonly scrollableHeaderGroups: Signal<AgridHeaderGroup[]>;
+    readonly rightHeaderGroups: Signal<AgridHeaderGroup[]>;
+    /**
+     * Resolves every per-column header/filter binding into a flat view-model. Called from the
+     * pane header computeds; reads the same signal-backed helpers the template used directly, so
+     * the result is memoized and recomputed only when sort/filter/drag/sizing state changes.
+     */
+    private buildHeaderColumns;
+    private buildHeaderGroups;
+    /** @internal Body view-model for the left-pinned, scrollable, and right-pinned panes. */
+    readonly pinnedBodyColumns: Signal<AgridBodyColumn[]>;
+    readonly scrollableBodyColumns: Signal<AgridBodyColumn[]>;
+    readonly rightBodyColumns: Signal<AgridBodyColumn[]>;
+    /**
+     * Resolves the per-column bindings shared by every data, footer, and ghost cell. Reads only
+     * layout/drag/pinning signals, so the result is reused across all rows and recomputes only
+     * when columns move, resize, drag, or change pinning.
+     */
+    private buildBodyColumns;
     private readonly columnState;
     private readonly projection;
     private readonly editController;
@@ -2142,11 +2505,29 @@ declare class AgridComponent<T extends object = any> {
     readonly totalWidth: Signal<number>;
     readonly pinnedPaneWidth: Signal<number>;
     readonly scrollableTotalWidth: Signal<number>;
+    /** Live horizontal scroll metrics of the scrollable pane, fed to column virtualization. */
+    private readonly colScrollLeft;
+    private readonly colViewportWidth;
+    /** Scrollable-column count above which column virtualization activates. */
+    readonly columnVirtualizationThreshold: Signal<number>;
+    /** Windows the scrollable-pane columns to those near the horizontal viewport. */
+    private readonly columnVirtualization;
+    /** @internal Current rendered column window (full set + zero spacers when inactive). */
+    readonly columnWindow: Signal<AgridColumnWindow>;
+    /** @internal Scrollable body columns sliced to the active window. */
+    readonly virtualScrollableBodyColumns: Signal<AgridBodyColumn[]>;
+    /** @internal Number of hidden scrollable columns after the window (trailing spacer span). */
+    readonly columnWindowRightSpan: Signal<number>;
     /**
      * Filtered, sorted, and optionally grouped row list for `*cdkVirtualFor`.
      * Appends `null` when the explicit add-row placeholder is active.
      */
     readonly filteredItems: Signal<GridItem[]>;
+    /**
+     * @internal The full filtered + sorted row set (grouping/pagination ignored). Reused for export
+     * and published to the provider as `visibleRows` so charts and consumers can react to filters.
+     */
+    readonly ɵvisibleRows: Signal<Record<string, unknown>[]>;
     /** Virtual scroll source — injects ghost row during a reorder drag. */
     /** Maps originalIndex → true if the data row should receive the odd-row stripe. Counts only data rows, so group headers don't shift the pattern. */
     readonly dataRowIsOdd: Signal<Map<number, boolean>>;
@@ -2186,6 +2567,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 +2597,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 +2635,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,18 +2653,14 @@ declare class AgridComponent<T extends object = any> {
     private readonly _seededControls;
     private readonly dirtyInlineRows;
     private dirtyRowsDataSource;
-    private readonly changedCells;
     private changedCellsDataSource;
     private emitEditEvents;
     private emitSidebarEditEvents;
     private emitRecordEdit;
     private markInlineRowDirty;
     private markCellChanged;
-    private changedCellKey;
-    private parseChangedCellKey;
     private flushDirtyInlineRows;
     private reconcileDirtyInlineRowsAfterRemoval;
-    private reconcileChangedCellsAfterRemoval;
     private emitRowChanged;
     private createRecordEvent;
     constructor();
@@ -2290,6 +2690,23 @@ declare class AgridComponent<T extends object = any> {
     rowPx(item: GridItem): number;
     /** @internal Resolved HTML for an expanded detail panel (auto-sanitized by `[innerHTML]`). */
     detailHtml(item: GridItem): string;
+    /** @internal Formatted value shown while a configured detail field is not being edited. */
+    detailFieldDisplay(item: DetailRowItem): string;
+    /** @internal Whether the configured detail field can be edited for this row. */
+    isDetailFieldEditable(item: DetailRowItem): boolean;
+    /** @internal Enter multiline editing for one expanded detail row. */
+    startDetailFieldEdit(item: DetailRowItem, event?: Event): void;
+    /** @internal Keep the multiline draft synchronized with textarea input. */
+    onDetailDraftInput(event: Event): void;
+    /** @internal Commit on blur or Ctrl/Cmd+Enter, and cancel on Escape. */
+    onDetailEditorKeydown(item: DetailRowItem, event: KeyboardEvent): void;
+    /** @internal Insert a configured text template into the active detail textarea. */
+    applyDetailAction(item: DetailRowItem, action: DetailAction, event: Event): void;
+    private focusDetailEditorFromKeyboard;
+    /** @internal Commit a multiline detail edit through normal grid edit semantics. */
+    commitDetailFieldEdit(item: DetailRowItem): void;
+    /** @internal Discard the active multiline detail draft. */
+    cancelDetailFieldEdit(): void;
     /** @internal Resolved per-row CSS classes from the host `getRowClass` callback. */
     getRowClass(row: Record<string, unknown>, index: number): string;
     /** Whether the master/detail panel for `originalIndex` is currently expanded. */
@@ -2428,6 +2845,10 @@ declare class AgridComponent<T extends object = any> {
     onStartEdit(originalIndex: number, ci: number): void;
     /** @internal */
     onDraftChange(value: unknown): void;
+    /** @internal A custom cell editor requested a commit (e.g. picking a value). */
+    onEditorCommit(): void;
+    /** @internal A custom cell editor requested cancellation. */
+    onEditorCancel(): void;
     private quickFilterTimer;
     /**
      * @internal Quick-filter input handler. Stores the text on the control (drives the bound value
@@ -2461,12 +2882,24 @@ declare class AgridComponent<T extends object = any> {
     onHandlePointerDown(event: PointerEvent, originalIndex: number): void;
     /** @internal Handles the control column without letting the row receive a second pointer event. */
     onControlPointerDown(event: PointerEvent, originalIndex: number): void;
-    /** @internal Toggle whether a row is included in subsequent copy operations. */
+    /** @internal Marks a row when its control-column header surface is clicked. */
+    onControlCellClick(event: MouseEvent, originalIndex: number): void;
+    /** Toggle whether a row is included in subsequent copy operations and emit its new state. */
     toggleRowMarked(originalIndex: number): void;
+    /** Set one row's mark state and emit `rowMark` when that state changes. */
+    setRowMarked(originalIndex: number, marked: boolean): void;
     /** @internal Returns whether a row is marked for copying. */
     isRowMarked(originalIndex: number): boolean;
     /** Clear every row marked for clipboard inclusion. */
     clearMarkedRows(): void;
+    /** Set one complete column's mark state and emit `columnMark` when it changes. */
+    setColumnMarked(field: string, marked: boolean): void;
+    /** Toggle one complete column's mark state. */
+    toggleColumnMarked(field: string): void;
+    /** Clear all marked columns. */
+    clearMarkedColumns(): void;
+    /** @internal Emits a custom header command for its typed column and closes the menu. */
+    onColumnHeaderAction(field: string, key: string): void;
     /** @internal Copy the active range or cell as TSV. */
     onCopy(event: ClipboardEvent): void;
     /** @internal Paste TSV/CSV-like plain text into the current cell. */
@@ -2487,28 +2920,12 @@ declare class AgridComponent<T extends object = any> {
     closeCellContextMenu(): void;
     /** @internal Closes any row, cell, menu-bar, group-action, or column menu owned by this grid. */
     closeOpenMenus(): boolean;
-    /** @internal Resolves a menu-bar state callback against the current grid state. */
-    resolveMenuBarState(state: AgridMenuBarState<T> | undefined, fallback: boolean): boolean;
-    /** @internal Whether a menu-bar button or dropdown item should be rendered. */
-    isMenuBarItemVisible(item: AgridMenuBarMenuItem<T>): boolean;
-    /** @internal Whether a menu-bar button or dropdown item is active. */
-    isMenuBarItemActive(item: AgridMenuBarMenuItem<T>): boolean;
-    /** @internal Whether a menu-bar button or dropdown item is disabled. */
-    isMenuBarItemDisabled(item: AgridMenuBarMenuItem<T>): boolean;
-    /** @internal Visible dropdown entries for a menu-bar button. */
-    visibleMenuBarChildren(item: AgridMenuBarItem<T>): AgridMenuBarMenuItem<T>[];
-    /** @internal Emits one menu-bar action and closes its dropdown. */
-    runMenuBarAction(event: Event, item: AgridMenuBarMenuItem<T>): void;
-    /** @internal Opens or closes a split button's additional command menu. */
-    toggleMenuBarMenu(event: Event, item: AgridMenuBarItem<T>): void;
-    /** @internal Opens a dropdown from the keyboard and focuses its first/last enabled item. */
-    onMenuBarTriggerKeydown(event: KeyboardEvent, item: AgridMenuBarItem<T>): void;
-    /** @internal Provides standard keyboard navigation within an open menu-bar dropdown. */
-    onMenuBarMenuKeydown(event: KeyboardEvent): void;
     /** @internal Closes the currently open menu-bar dropdown. */
     closeMenuBarMenu(): void;
     /** @internal Synchronizes dropdown state and closes competing grid menus when one opens. */
     onMenuBarOpenItemChange(id: string | null): void;
+    /** @internal Dispatches a menu-bar action (or persists config for the built-in save entry). */
+    onMenuBarAction(id: string): void;
     /** @internal Runs a typed provider context-menu action against erased controller state. */
     runCellMenuItem(item: CellContextMenuItem<T>, menu: AgridCellContextMenu): void;
     /** @internal Copy one field from the target and marked rows. */
@@ -2525,8 +2942,6 @@ declare class AgridComponent<T extends object = any> {
     confirmPendingRowDelete(): void;
     /** @internal Cancel the active row-delete confirmation. */
     cancelRowDelete(): void;
-    private deleteRowImmediately;
-    private updateDeleteConfirmationPosition;
     /** @internal */
     onGroupHeaderClick(label: string): void;
     /** Expand all groups. No-op when grouping is not active. */
@@ -2544,7 +2959,7 @@ declare class AgridComponent<T extends object = any> {
     /** @internal */
     onTextFilterChange(event: Event, field: string): void;
     /** @internal */
-    openFilterMenu(event: MouseEvent, field: string): void;
+    openFilterMenu(event: MouseEvent, field: string, mode?: 'column' | 'condition'): void;
     /** @internal */
     closeFilterMenu(): void;
     /** @internal */
@@ -2572,6 +2987,8 @@ declare class AgridComponent<T extends object = any> {
     private ensureServerRowsVisible;
     /** @internal Keeps the row-delete prompt visible while columns scroll horizontally. */
     onHorizontalScroll(): void;
+    /** @internal Refreshes the scroll offset / viewport width driving column virtualization. */
+    private syncColumnViewportMetrics;
     /** @internal */
     onRightPinnedBodyScroll(): void;
     /** @internal */
@@ -2606,7 +3023,7 @@ declare class AgridComponent<T extends object = any> {
     getColumnWidth(col: ColDef): number;
     private getColumnWidthToken;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgridComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridComponent<any>, "agrid", never, { "provider": { "alias": "provider"; "required": false; "isSignal": true; }; }, { "cellEdit": "cellEdit"; "recordEdit": "recordEdit"; "rowRemoved": "rowRemoved"; "prepareAddRecord": "prepareAddRecord"; "rowReorder": "rowReorder"; "rowSelect": "rowSelect"; "rowDoubleClicked": "rowDoubleClicked"; "rowClick": "rowClick"; "treeNodeClick": "treeNodeClick"; "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"; "quickFilterChange": "quickFilterChange"; "validationFailed": "validationFailed"; "cellInfo": "cellInfo"; "menuBarAction": "menuBarAction"; "detailAction": "detailAction"; }, never, never, true, never>;
 }
 
 /** Identifier supported by the standalone page selector. */
@@ -2708,6 +3125,7 @@ type StandaloneTreeItem<T extends object> = TreeRowItem<T> | PathTreeNodeItem;
 /** Standalone accessible tree control backed by the same projection logic as `AgridComponent`. */
 declare class AgridTreeComponent<T extends object = any> {
     provider: _angular_core.InputSignal<AgridTreeProvider<T>>;
+    localeText: _angular_core.InputSignal<AgridLocaleText>;
     nodeClick: _angular_core.OutputEmitterRef<AgridTreeNodeEvent<T>>;
     nodeDoubleClicked: _angular_core.OutputEmitterRef<AgridTreeNodeEvent<T>>;
     selectionChange: _angular_core.OutputEmitterRef<AgridTreeSelectionEvent<T>>;
@@ -2747,9 +3165,281 @@ declare class AgridTreeComponent<T extends object = any> {
     private focusNode;
     private findParentIndex;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgridTreeComponent<any>, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridTreeComponent<any>, "agrid-tree", never, { "provider": { "alias": "provider"; "required": true; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeDoubleClicked": "nodeDoubleClicked"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridTreeComponent<any>, "agrid-tree", never, { "provider": { "alias": "provider"; "required": true; "isSignal": true; }; "localeText": { "alias": "localeText"; "required": false; "isSignal": true; }; }, { "nodeClick": "nodeClick"; "nodeDoubleClicked": "nodeDoubleClicked"; "selectionChange": "selectionChange"; }, never, never, true, never>;
+}
+
+/**
+ * Context handed to a custom cell editor component through dependency injection.
+ *
+ * A custom editor is any standalone component referenced by {@link ColDef.cellEditor}.
+ * The grid instantiates it while a cell is in edit mode and provides this context via the
+ * {@link AGRID_EDITOR_CONTEXT} token. The editor is purely an *input surface*: it reads the
+ * current value and pushes drafts back through {@link setDraft}. The grid keeps full ownership
+ * of validation, history (undo/redo), and the commit/cancel lifecycle — so Tab, Enter, and
+ * Escape continue to work without the editor doing anything.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'rating-editor',
+ *   template: `
+ *     <select #s [value]="ctx.value()" (change)="ctx.setDraft(+s.value); ctx.commit()">
+ *       @for (n of [1,2,3,4,5]; track n) { <option [value]="n">{{ n }} ★</option> }
+ *     </select>`,
+ * })
+ * export class RatingEditor {
+ *   readonly ctx = inject(AGRID_EDITOR_CONTEXT);
+ * }
+ *
+ * // ColDef: { field: 'rating', cellEditor: RatingEditor }
+ * ```
+ */
+interface AgridEditorContext<TValue = unknown> {
+    /** The cell's current value at the moment editing started. */
+    readonly value: Signal<TValue>;
+    /** The full row record the cell belongs to. */
+    readonly row: Signal<Record<string, unknown>>;
+    /** The column definition this cell is rendered from. */
+    readonly column: Signal<ColDef>;
+    /**
+     * The printable character that triggered type-to-edit, or `''` when editing started another
+     * way (double-click, Enter, F2). Useful for seeding a free-text editor.
+     */
+    readonly seedChar: Signal<string>;
+    /** Stage a new value. The grid commits whatever was last staged on Tab/Enter. */
+    setDraft(value: unknown): void;
+    /** Programmatically commit the staged value (same as the user pressing Enter). */
+    commit(): void;
+    /** Programmatically discard the edit (same as the user pressing Escape). */
+    cancel(): void;
+}
+/** DI token a custom {@link ColDef.cellEditor} component injects to talk to the grid. */
+declare const AGRID_EDITOR_CONTEXT: InjectionToken<AgridEditorContext<unknown>>;
+
+/**
+ * Context handed to a custom cell renderer component through dependency injection.
+ *
+ * A custom renderer is any standalone component referenced by {@link ColDef.cellRendererComponent}.
+ * The grid instantiates it for the cell's *display* (read) state and provides this context via the
+ * {@link AGRID_RENDERER_CONTEXT} token. Unlike the HTML-string {@link ColDef.cellRenderer}, a
+ * component renderer supports full Angular bindings, event handlers, and child components — and
+ * needs no manual escaping or sanitization.
+ *
+ * @example
+ * ```ts
+ * @Component({
+ *   selector: 'status-badge',
+ *   template: `<span class="badge" [class]="'badge--' + value()">{{ value() }}</span>`,
+ * })
+ * export class StatusBadge {
+ *   private readonly ctx = inject(AGRID_RENDERER_CONTEXT);
+ *   readonly value = computed(() => String(this.ctx.value() ?? ''));
+ * }
+ *
+ * // ColDef: { field: 'status', cellRendererComponent: StatusBadge }
+ * ```
+ */
+interface AgridRendererContext<TValue = unknown> {
+    /** The cell's current value. */
+    readonly value: Signal<TValue>;
+    /** The full row record the cell belongs to. */
+    readonly row: Signal<Record<string, unknown>>;
+    /** The column definition this cell is rendered from. */
+    readonly column: Signal<ColDef>;
+}
+/** DI token a custom {@link ColDef.cellRendererComponent} component injects to read cell data. */
+declare const AGRID_RENDERER_CONTEXT: InjectionToken<AgridRendererContext<unknown>>;
+
+/**
+ * Zero-dependency chart geometry. Pure math that turns a typed dataset + a diagram type into flat
+ * SVG primitives (bars, line/area paths, pie slices, gridlines, labels), so the chart component
+ * only has to emit elements. No charting library — same hand-rolled approach as the xlsx writer
+ * and the sparkline helper.
+ */
+/** Supported diagram types. */
+type AgridChartType = 'column' | 'bar' | 'line' | 'area' | 'pie' | 'donut';
+/** One data series (a row of values aligned to {@link AgridChartData.categories}). */
+interface AgridChartSeries {
+    /** Series name shown in the legend. */
+    name?: string;
+    /** Explicit colour; falls back to the palette by index. */
+    color?: string;
+    values: number[];
+}
+/** The dataset fed to a chart: one or more series sharing a category axis. */
+interface AgridChartData {
+    /** Category labels (x-axis ticks, or pie/donut slice labels). */
+    categories?: string[];
+    series: AgridChartSeries[];
+}
+/** Box dimensions and styling knobs the dataset is laid out into. */
+interface AgridChartOptions {
+    width: number;
+    height: number;
+    palette?: string[];
+    /** Whether value/category axes and gridlines are produced (cartesian types only). */
+    showAxis?: boolean;
+}
+interface ChartBar {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color: string;
+    value: number;
+    seriesIndex: number;
+    categoryIndex: number;
+}
+interface ChartPath {
+    d: string;
+    color: string;
+    name: string;
+}
+interface ChartPoint {
+    x: number;
+    y: number;
+    color: string;
+}
+interface ChartSlice {
+    d: string;
+    color: string;
+    value: number;
+    label: string;
+    percentText: string;
+    labelX: number;
+    labelY: number;
+    full: boolean;
+}
+interface ChartGridline {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}
+interface ChartLabel {
+    x: number;
+    y: number;
+    text: string;
+    anchor: 'start' | 'middle' | 'end';
+    baseline: 'auto' | 'middle' | 'hanging';
+}
+interface ChartLegendItem {
+    name: string;
+    color: string;
+}
+/** Flat, drawable primitives for a chart. */
+interface AgridChartLayout {
+    type: AgridChartType;
+    width: number;
+    height: number;
+    bars: ChartBar[];
+    areas: ChartPath[];
+    lines: ChartPath[];
+    points: ChartPoint[];
+    slices: ChartSlice[];
+    gridlines: ChartGridline[];
+    axisLabels: ChartLabel[];
+    legend: ChartLegendItem[];
+}
+/** Default qualitative palette (colour-blind-friendly-ish, distinct hues). */
+declare const AGRID_CHART_PALETTE: string[];
+/** Builds drawable geometry for a chart. Empty/invalid input yields an empty layout. */
+declare function buildChart(type: AgridChartType, data: AgridChartData, options: AgridChartOptions): AgridChartLayout;
+
+/**
+ * Construction options for an {@link AgridChartProvider}.
+ *
+ * Provide a static {@link data} set, or link a live {@link source} (e.g. a grid provider's
+ * `visibleRows`) together with a {@link transform} so the chart follows the grid's filtering and
+ * sorting automatically.
+ */
+interface AgridChartProviderConfig<T = any> {
+    /** Diagram type: column, bar, line, area, pie, or donut. */
+    type: AgridChartType;
+    /** Static dataset. Ignored when {@link source} + {@link transform} are provided. */
+    data?: AgridChartData;
+    /**
+     * A reactive row source to derive the dataset from — typically a grid provider's `visibleRows`,
+     * which reflects the grid's current filters and sorting. Requires {@link transform}.
+     */
+    source?: Signal<readonly T[]>;
+    /**
+     * Turns the {@link source} rows (and the current chart type) into a chart dataset. Re-runs
+     * whenever the source rows or the chart type change.
+     */
+    transform?: (rows: readonly T[], type: AgridChartType) => AgridChartData;
+    /** Chart height in pixels (width follows the host). @default 220 */
+    height?: number;
+    /** Show the series/category legend below the chart. @default true */
+    showLegend?: boolean;
+    /** Draw value/category axes for cartesian types. @default true */
+    showAxis?: boolean;
+    /** Override the colour palette. */
+    palette?: string[];
+}
+/**
+ * Bundles a chart's type, dataset, and display options behind one object, so a chart is configured
+ * exactly like a grid: `<agrid-chart [provider]="chartProvider" />`.
+ *
+ * @example Static data
+ * ```ts
+ * new AgridChartProvider({ type: 'column', data: { categories: ['Q1','Q2'], series: [{ values: [10, 14] }] } });
+ * ```
+ *
+ * @example Linked to a grid (follows filters/sorting)
+ * ```ts
+ * new AgridChartProvider({
+ *   type: 'column',
+ *   source: gridProvider.visibleRows,
+ *   transform: (rows, type) => ({ categories: rows.map(r => r.region), series: [{ values: rows.map(r => r.total) }] }),
+ * });
+ * ```
+ */
+declare class AgridChartProvider<T = any> {
+    /** Diagram type. Writable — set it to switch chart type at runtime. */
+    readonly type: WritableSignal<AgridChartType>;
+    /** The dataset rendered by the chart (derived from the source when linked). */
+    readonly data: Signal<AgridChartData>;
+    /** Chart height in pixels. */
+    readonly height: WritableSignal<number>;
+    /** Whether the legend is shown. */
+    readonly showLegend: WritableSignal<boolean>;
+    /** Whether cartesian axes are drawn. */
+    readonly showAxis: WritableSignal<boolean>;
+    /** Colour palette override, or `undefined` for the default. */
+    readonly palette: WritableSignal<string[] | undefined>;
+    /** Writable backing store in static mode; `null` when the data is derived from a source. */
+    private readonly _data;
+    constructor(config: AgridChartProviderConfig<T>);
+    /** Replace the dataset. Only valid in static mode (no linked {@link AgridChartProviderConfig.source}). */
+    setData(data: AgridChartData): void;
+}
+
+/**
+ * Zero-dependency chart component. Configured exactly like the grid — hand it an
+ * {@link AgridChartProvider} and it renders an SVG column / bar / line / area / pie / donut chart
+ * with no charting library. The chart sizes itself to the host width (observed) and the provider's
+ * height.
+ *
+ * @example
+ * ```html
+ * <agrid-chart [provider]="chartProvider" />
+ * ```
+ */
+declare class AgridChartComponent {
+    /** All chart configuration — type, data, and display options. */
+    readonly provider: _angular_core.InputSignal<AgridChartProvider<any>>;
+    private readonly host;
+    protected readonly width: _angular_core.WritableSignal<number>;
+    protected readonly height: _angular_core.Signal<number>;
+    protected readonly showLegend: _angular_core.Signal<boolean>;
+    protected readonly sliceLabels: _angular_core.Signal<boolean>;
+    protected readonly layout: _angular_core.Signal<_thkl_agrid.AgridChartLayout>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgridChartComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridChartComponent, "agrid-chart", never, { "provider": { "alias": "provider"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { AGRID_LOCALE_TEXT, AgridComponent, AgridControl, AgridDataSource, AgridPageSelectorComponent, AgridProvider, 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_LOCALE_TEXT, AGRID_RENDERER_CONTEXT, AgridBrowserAdapter, AgridChartComponent, AgridChartProvider, AgridComponent, AgridControl, AgridDataSource, AgridPageSelectorComponent, AgridProvider, AgridServerSideRowModel, AgridTreeComponent, AgridTreeProvider, ColDefAutoSize, buildChart };
+export type { AgridAggregate, AgridChartData, AgridChartLayout, AgridChartOptions, AgridChartProviderConfig, AgridChartSeries, AgridChartType, AgridColumnHeaderMenuItem, AgridControlState, AgridEditorContext, AgridEnterEditAction, AgridField, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridMenuBarContext, AgridMenuBarItem, AgridMenuBarMenuItem, AgridMenuBarState, AgridPageId, AgridPageItem, AgridParentTreeConfig, AgridPathSegmentParams, AgridPathTreeConfig, AgridPivotConfig, AgridPivotSettings, AgridProviderConfig, AgridRendererContext, AgridRowIndication, AgridSelectionSummary, AgridServerSideDatasource, AgridServerSideRequest, AgridServerSideResult, AgridServerSideRowModelConfig, AgridServerSideSort, AgridSettings, AgridTreeConfig, AgridTreeNodeEvent, AgridTreeProviderConfig, AgridTreeSelectionEvent, AgridTreeSelectionMode, CellContextMenuItem, CellFormat, CellFormatParams, CellInfoEvent, CellPosition, CellReadonlyParams, CellSpanParams, ColDef, ColumnFilter, ColumnHeaderActionEvent, ColumnMarkEvent, DetailAction, DetailActionParams, DetailRowItem, FilterChangeEvent, FilterOperator, FirstDataRenderedEvent, GridEditEvent, GroupAction, HeaderGroup, HistoryEntry, HistoryItem, InputMaskParams, NewRecord, PageChangeEvent, PathTreeNodeItem, RecordEditEvent, RowClickEvent, RowMarkEvent, RowRemovedEvent, RowReorderEvent, RowSelectEvent, RowUpdateEvent, SortChangeEvent, TreeNodeClickEvent, TreeRowItem, ValidationFailedEvent, ValueOption };
 //# sourceMappingURL=thkl-agrid.d.ts.map