@thkl/agrid 0.1.0

package/types/thkl-agrid.d.ts

@@ -0,0 +1,1496 @@
+import * as _angular_core from '@angular/core';
+import { Signal, WritableSignal, DestroyRef } from '@angular/core';
+
+/** Guarded access to browser-only APIs used by the grid. @internal */
+declare class AgridBrowserAdapter {
+    private readonly doc;
+    private readonly win;
+    /** Creates an adapter using injected browser globals or the current environment. */
+    constructor(doc?: Document | null, win?: Window | null);
+    /** Returns whether both document and window APIs are available. */
+    get available(): boolean;
+    /** Registers a document event listener when a document is available. */
+    addDocumentListener<K extends keyof DocumentEventMap>(type: K, listener: (event: DocumentEventMap[K]) => void): void;
+    /** Removes a previously registered document event listener. */
+    removeDocumentListener<K extends keyof DocumentEventMap>(type: K, listener: (event: DocumentEventMap[K]) => void): void;
+    /** Returns the element stack at viewport coordinates. */
+    elementsFromPoint(x: number, y: number): Element[];
+    /** Appends an element to the document body when available. */
+    appendToBody(element: HTMLElement): boolean;
+    /** Sets cursor and text-selection styles on the document body. */
+    setBodyInteraction(cursor: string, userSelect: string): void;
+    /** Returns the viewport width or infinity during server rendering. */
+    viewportWidth(): number;
+    /** Returns computed styles when a window is available. */
+    computedStyle(element: Element): CSSStyleDeclaration | null;
+    /** Creates a 2D canvas context for text measurement. */
+    createCanvasContext(): CanvasRenderingContext2D | null;
+    /** Schedules a callback with the environment timer. */
+    schedule(callback: () => void, delay?: number): ReturnType<typeof setTimeout>;
+    /** Writes text to the system clipboard, returning whether it succeeded. */
+    writeClipboard(text: string): Promise<boolean>;
+    /** Downloads text through a temporary object URL and anchor element. */
+    downloadText(filename: string, text: string, mimeType: string): boolean;
+}
+
+/**
+ * Signal-based data container shared between the grid and the host component.
+ *
+ * Both the grid and the host component hold a reference to the same `AgridDataSource`
+ * instance. Mutations made by either side (e.g. the grid calling `patchRow` when a cell
+ * is committed, or the host calling `setData` to load fresh data) are immediately reflected
+ * in the grid because {@link rows} is a readonly Angular signal.
+ *
+ * @example
+ * ```ts
+ * readonly ds = new AgridDataSource(generateRows(1000));
+ *
+ * // Later — update one row from outside the grid:
+ * this.ds.patchRow(5, { salary: 99000 });
+ * ```
+ */
+declare class AgridDataSource<T extends object = any> {
+    private readonly _linkedRows;
+    private readonly _rows;
+    private _writableLinkedRows;
+    private readonly _rowAdded;
+    private _changeSequence;
+    /**
+     * @param initialData Rows to seed the data source with.
+     *   The array is shallow-copied so external mutations do not affect the source.
+     */
+    constructor(initialData?: T[]);
+    /**
+     * Readonly signal of the current row array.
+     * Read it inside Angular templates or `computed()` to react to changes automatically.
+     */
+    readonly rows: Signal<T[]>;
+    /** Latest row insertion, used by attached grids to reveal the inserted row. */
+    readonly rowAdded: Signal<{
+        index: number;
+        sequence: number;
+    } | null>;
+    /**
+     * Link an external row signal to this data source.
+     *
+     * Whenever `source` changes, its array becomes the current datasource value without an
+     * intermediate effect or array copy. If `source` is writable, datasource mutations are written
+     * back to it automatically. Mutations remain local when linking a readonly signal.
+    */
+    linkSignal(source: Signal<T[]>): void;
+    /**
+     * Replace the entire row array.
+     * Triggers a full grid re-render via the signal.
+     */
+    setData(rows: T[]): void;
+    /**
+     * Overwrite the row at `index` with a new row object.
+     * Use {@link patchRow} when you only want to change specific fields.
+     */
+    updateRow(index: number, row: T): void;
+    /**
+     * Merge `patch` into the existing row at `index`, leaving other fields untouched.
+     * The grid calls this internally when a cell edit is committed.
+     */
+    patchRow(index: number, patch: Partial<T>): void;
+    /**
+     * Insert a row into the data source and return the index at which it was inserted.
+     *
+     * @param row The row object to insert.
+     * @param atIndex Optional insertion index. Defaults to the end of the array.
+     * @returns The index the row was inserted at.
+     */
+    addRow(row: T, atIndex?: number): number;
+    /**
+     * Remove the row at `index`.
+     * The grid adjusts `selectedCell` and `editingCell` internally when a deletion occurs
+     * via the control column context menu.
+     */
+    removeRow(index: number): void;
+    /**
+     * Move the row at `from` to position `to` (insert-before semantics).
+     * Designed to be called directly from a `(rowReorder)` handler:
+     * ```ts
+     * onReorder(e: RowReorderEvent) { this.ds.moveRow(e.oldIndex, e.newIndex); }
+     * ```
+     */
+    moveRow(from: number, to: number): void;
+    /** Return the current row at `index` (non-reactive snapshot). */
+    getRow(index: number): T;
+    /** Current number of rows (non-reactive snapshot). */
+    get length(): number;
+    private updateRows;
+    private setRows;
+}
+
+/**
+ * A single reversible cell edit stored in the undo/redo history.
+ * Both `oldValue` and `newValue` are the raw values as stored in the data source.
+ */
+interface HistoryEntry {
+    rowIndex: number;
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+/** A single undo/redo history item. Multi-cell operations are stored as one batch. */
+type HistoryItem = HistoryEntry | HistoryEntry[];
+/**
+ * Per-column filter state stored inside {@link AgridControl}.
+ *
+ * All three fields are independent — text, value selection, and sort are ANDed together
+ * when computing the visible rows.
+ */
+interface ColumnFilter {
+    /** Free-text substring filter (case-insensitive). Empty string = no text filter. */
+    text: string;
+    /**
+     * Allowed values for the value-picker filter.
+     * - `null` → all values pass (no value filter active)
+     * - `string[]` → only rows whose field value is in this list are shown
+     */
+    selectedValues: string[] | null;
+    /** Sort direction, or `null` when this column is not sorted. */
+    sort: 'asc' | 'desc' | null;
+}
+/** Serializable snapshot of the grid's UI state. Used with `toJSON` / `fromJSON`. */
+interface AgridControlState {
+    /** Per-field column width overrides in pixels. */
+    columnWidths: Record<string, number>;
+    /** Per-field filter and sort state. Fields with default state may be omitted. */
+    filters: Record<string, ColumnFilter>;
+    /** When `true`, rows can be reordered by dragging the control-column handle. */
+    allowRowReorder?: boolean;
+    /** Field to group rows by, or `null` / omitted for no grouping. */
+    groupByField?: string | null;
+    /** Fields that are currently hidden from the grid view. */
+    hiddenColumns?: string[];
+    /** Ordered list of field names defining the column display order. */
+    columnOrder?: string[];
+    /** Fields that are pinned to the left edge. */
+    pinnedColumns?: string[];
+    /** Fields that are pinned to the right edge. */
+    pinnedRightColumns?: string[];
+    /** Ordered list of field names currently sorted, from highest to lowest priority. */
+    sortOrder?: string[];
+    /** Number of rows per page. `0` means no pagination (show all rows). */
+    pageSize?: number;
+    /** Current page (1-based). */
+    currentPage?: number;
+    /**
+     * Total row count supplied by the server. When greater than zero the grid enters
+     * server-side pagination mode: it no longer slices rows locally and instead emits
+     * a `(pageChange)` event so the host can fetch the correct slice.
+     */
+    totalRows?: number;
+    /** Per-field aggregate function set via the column menu. Only built-in string values are serializable. */
+    aggregates?: Record<string, 'sum' | 'avg' | 'min' | 'max' | 'count'>;
+}
+/**
+ * Signal-based container for mutable grid UI state such as column widths and active filters.
+ *
+ * Assign an instance to `AgridProvider.control` so the grid can store runtime state
+ * in a place the host component can persist across sessions.
+ *
+ * @example
+ * ```ts
+ * // Restore saved state:
+ * readonly ctrl = AgridControl.fromJSON(
+ *   JSON.parse(localStorage.getItem('grid') ?? '{}')
+ * );
+ *
+ * // Save on demand:
+ * localStorage.setItem('grid', JSON.stringify(this.ctrl.toJSON()));
+ * ```
+ */
+declare class AgridControl {
+    private readonly _columnWidths;
+    private readonly _filters;
+    private readonly _allowRowReorder;
+    private readonly _groupByField;
+    private readonly _hiddenColumns;
+    private readonly _columnOrder;
+    private readonly _pinnedColumns;
+    private readonly _pinnedRightColumns;
+    private readonly _pageSize;
+    private readonly _currentPage;
+    private readonly _totalRows;
+    private readonly _aggregates;
+    private readonly _sortOrder;
+    /** @param state Optional initial state, e.g. deserialized from storage. */
+    constructor(state?: Partial<AgridControlState>);
+    /**
+     * When `true`, the control column shows a drag handle and rows can be
+     * reordered by dragging. Requires `showControlColumn` to be enabled on the grid.
+     */
+    readonly allowRowReorder: Signal<boolean>;
+    /** Enable or disable row reordering at runtime. */
+    setAllowRowReorder(value: boolean): void;
+    /**
+     * The field currently used to group rows, or `null` when grouping is off.
+     * When set, rows are bucketed by the display value of this field and a header
+     * row is inserted before each group. Secondary sorts still apply within groups.
+     */
+    readonly groupByField: Signal<string | null>;
+    /**
+     * Enable grouping by `field`, or pass `null` to turn grouping off.
+     */
+    setGroupBy(field: string | null): void;
+    /**
+     * Reactive set of field names that are currently hidden.
+     * An empty set means all columns are visible.
+     */
+    readonly hiddenColumns: Signal<Set<string>>;
+    /** Return `true` when the given field is currently hidden. */
+    isColumnHidden(field: string): boolean;
+    /**
+     * Show or hide a column by field name.
+     * Hiding a column does not clear its filter or sort — they resume when it is shown again.
+     */
+    setColumnVisibility(field: string, visible: boolean): void;
+    /** Toggle the visibility of a column. */
+    toggleColumnVisibility(field: string): void;
+    /**
+     * Ordered list of field names that defines the left-to-right column display order.
+     * An empty array means "use the original `colDefs` order".
+     */
+    readonly columnOrder: Signal<string[]>;
+    /** Replace the entire column order with a new list of field names. */
+    setColumnOrder(fields: string[]): void;
+    /**
+     * Move `fromField` to a new position relative to `toField`.
+     * `currentVisibleOrder` should be the current `visibleColDefs` field array so the
+     * operation works correctly whether or not an order has been set before.
+     */
+    moveColumn(currentVisibleOrder: string[], fromField: string, toField: string, insertBefore: boolean): void;
+    /** Reactive set of field names currently pinned to the left edge. */
+    readonly pinnedColumns: Signal<Set<string>>;
+    /** Return `true` when the given field is pinned. */
+    isPinned(field: string): boolean;
+    /** Pin or unpin a column to the left edge. Pinning left auto-unpins right. */
+    setPinned(field: string, pinned: boolean): void;
+    /** Toggle left-pin state of a column. */
+    togglePinned(field: string): void;
+    /** Reactive set of field names currently pinned to the right edge. */
+    readonly pinnedRightColumns: Signal<Set<string>>;
+    /** Return `true` when the given field is pinned to the right edge. */
+    isPinnedRight(field: string): boolean;
+    /** Pin or unpin a column to the right edge. Pinning right auto-unpins left. */
+    setPinnedRight(field: string, pinned: boolean): void;
+    /** Toggle right-pin state of a column. */
+    togglePinnedRight(field: string): void;
+    /** Number of rows per page. `0` means all rows are shown (no pagination). */
+    readonly pageSize: Signal<number>;
+    /** Current page number (1-based). */
+    readonly currentPage: Signal<number>;
+    /** Set rows per page. Pass `0` to disable pagination. Resets to page 1. */
+    setPageSize(size: number): void;
+    /** Navigate to a specific page (1-based). Clamped to valid range by the grid. */
+    setPage(page: number): void;
+    /**
+     * Set the total number of rows available on the server.
+     * When greater than zero the grid switches to **server-side pagination mode**:
+     * - Rows in the data source are shown as-is (no local slicing).
+     * - `totalPages` is derived from this value instead of the local row count.
+     * - A `(pageChange)` event is emitted whenever the user navigates to a new page.
+     *
+     * Pass `0` to return to client-side pagination.
+     */
+    setTotalRows(count: number): void;
+    /**
+     * Total server-side row count. `0` means client-side mode (grid slices locally).
+     */
+    readonly totalRows: Signal<number>;
+    /** Per-field aggregate overrides set via the column menu. */
+    readonly aggregates: Signal<Record<string, 'sum' | 'avg' | 'min' | 'max' | 'count'>>;
+    /**
+     * Set or clear the aggregate function for a column.
+     * Pass `null` to remove the aggregate (hides the footer cell for that column).
+     */
+    setAggregate(field: string, fn: 'sum' | 'avg' | 'min' | 'max' | 'count' | null): void;
+    private readonly _history;
+    private readonly _historyPointer;
+    private static readonly MAX_HISTORY;
+    /** `true` when there is at least one edit that can be undone. */
+    readonly canUndo: Signal<boolean>;
+    /** `true` when there is at least one edit that can be re-applied. */
+    readonly canRedo: Signal<boolean>;
+    /**
+     * Record a committed cell edit in the history.
+     * Calling this discards any redo entries that came after the current pointer.
+     * Called automatically by the grid after every cell commit.
+     */
+    pushEdit(entry: HistoryEntry): void;
+    /** Record a multi-cell edit as one undo/redo step. */
+    pushEditBatch(entries: HistoryEntry[]): void;
+    private pushHistoryItem;
+    /**
+     * Move one step back in history and return the entry to reverse, or `null` if
+     * already at the beginning. The caller is responsible for applying `oldValue`
+     * back to the data source.
+     */
+    undo(): HistoryItem | null;
+    /**
+     * Move one step forward in history and return the entry to re-apply, or `null`
+     * if already at the end. The caller is responsible for applying `newValue` back
+     * to the data source.
+     */
+    redo(): HistoryItem | null;
+    /** Clear the entire undo/redo history. */
+    clearHistory(): void;
+    /**
+     * Reactive map of `field → pixel width`.
+     * Only fields whose width was explicitly overridden are present; the grid falls
+     * back to `ColDef.width` for fields not in this map.
+     */
+    readonly columnWidths: Signal<Record<string, number>>;
+    /**
+     * Reactive map of `field → ColumnFilter`.
+     * Only fields with at least one active filter/sort condition are present.
+     */
+    readonly filters: Signal<Record<string, ColumnFilter>>;
+    /**
+     * Return the effective width for a column, falling back to `defaultWidth`
+     * if no override exists.
+     */
+    getColumnWidth(field: string, defaultWidth: number): number;
+    /**
+     * Set the width for a column. Enforces a minimum of 40 px.
+     * Called by the grid when the user drags a resize handle.
+     */
+    setColumnWidth(field: string, width: number): void;
+    /**
+     * Return the current filter state for a field.
+     * Returns a default (inactive) filter when no state is stored for the field.
+     */
+    getFilter(field: string): ColumnFilter;
+    /**
+     * Set the free-text filter for a column.
+     * An empty string removes the text filter for that column.
+     */
+    setTextFilter(field: string, text: string): void;
+    /**
+     * Set the value-picker selection for a column.
+     * Pass `null` to show all values (clear the value filter).
+     */
+    setSelectedValues(field: string, values: string[] | null): void;
+    /** Ordered list of sorted field names, from highest to lowest priority. */
+    readonly sortOrder: Signal<string[]>;
+    /** Return the 1-based sort priority of a field, or `0` if it is not sorted. */
+    getSortPriority(field: string): number;
+    /**
+     * Set the sort direction for a column, clearing all other sorts.
+     * Pass `null` to remove the sort entirely.
+     * For multi-column sort use {@link addSort}.
+     */
+    setSort(field: string, sort: 'asc' | 'desc' | null): void;
+    /**
+     * Add a column to the multi-sort stack or update its direction.
+     * If the column is already sorted, only its direction is updated (priority unchanged).
+     * If not yet sorted, it is appended as the lowest-priority sort key.
+     */
+    addSort(field: string, sort: 'asc' | 'desc'): void;
+    /**
+     * Remove all active filters and sort for a single column.
+     */
+    clearFilter(field: string): void;
+    /** Remove all active filters and sorts for every column. */
+    clearAllFilters(): void;
+    /**
+     * Return `true` when the given field has any active filter or sort.
+     * Useful for showing a visual indicator on the column header.
+     */
+    hasActiveFilter(field: string): boolean;
+    /** Return `true` when ANY column has an active filter or sort. */
+    hasAnyActiveFilter(): boolean;
+    /** Serialize current state to a plain object suitable for JSON storage. */
+    toJSON(): AgridControlState;
+    /** Restore an `AgridControl` from a previously serialized state. */
+    static fromJSON(state: Partial<AgridControlState>): AgridControl;
+}
+
+/** Built-in locale identifiers supplied by the grid. */
+type AgridLocaleKey = 'en' | 'de';
+/** Complete set of user-facing strings and label factories used by the grid. */
+interface AgridLocaleText {
+    actions: string;
+    addRow: string;
+    aggregate: string;
+    aggregateAvg: string;
+    aggregateCount: string;
+    aggregateMax: string;
+    aggregateMin: string;
+    aggregateSum: string;
+    autosizeColumn: string;
+    blank: string;
+    clearAllFilters: string;
+    clearFilter: string;
+    clearSort: string;
+    close: string;
+    columnMenu: string;
+    columns: string;
+    detail: string;
+    hiddenColumn: string;
+    copyCellValue: string;
+    copyRow: string;
+    deleteRow: string;
+    filterPlaceholder: string;
+    findPlaceholder: string;
+    firstPage: string;
+    grid: string;
+    groupBy: (header: string) => string;
+    hideColumn: string;
+    insertRowAbove: string;
+    insertRowBelow: string;
+    lastPage: string;
+    loading: string;
+    next: string;
+    noRows: string;
+    pagination: string;
+    pinColumn: string;
+    pinColumnRight: string;
+    unpinColumnRight: string;
+    previous: string;
+    resizeColumn: string;
+    rows: (count: number) => string;
+    searchValuesPlaceholder: string;
+    selectAll: string;
+    sortOnlyByThis: string;
+    sortAscending: string;
+    sortDescending: string;
+    ungroup: string;
+    unpinColumn: string;
+    save: string;
+}
+/** Partial locale text supplied to {@link AgridProvider.addLocalization}. */
+type AgridLocaleTextOverrides = Partial<AgridLocaleText>;
+/** Built-in English and German grid translations. */
+declare const AGRID_LOCALE_TEXT: Record<AgridLocaleKey, AgridLocaleText>;
+
+/** Configuration used to create an {@link AgridProvider}. */
+interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptions> {
+    /** Row data source. A new empty data source is created when omitted. */
+    datasource?: AgridDataSource<T>;
+    /** Stateful grid control. A default control is created when omitted. */
+    control?: AgridControl;
+    /** Initial column definitions in display order. */
+    columns?: ColDef<T>[];
+    /** Row height in pixels. Must be fixed for CDK virtual scroll. @default 32 */
+    rowHeight?: number;
+    /** Minimum height of the grid host element (e.g. `'200px'`). */
+    minHeight?: string;
+    /** Maximum height of the grid host element (e.g. `'500px'`). */
+    maxHeight?: string;
+    /** Show a `+ Add row` placeholder at the bottom. */
+    allowAddRows?: boolean;
+    /** Automatically insert a blank row when navigating past the last real row. */
+    autoAddRows?: boolean;
+    /** Show a 24 px control column with a drag handle and right-click context menu. */
+    showControlColumn?: boolean;
+    /** Show the sidebar panel. */
+    showSidebar?: boolean;
+    /** Automatically open the detail panel when a row is selected. */
+    autoOpenDetail?: boolean;
+    /**
+     * Emit filter and sort changes for server processing instead of applying them locally.
+     * The Excel-style value picker is hidden in this mode. @default false
+     */
+    serverSideFiltering?: boolean;
+    /** Delay before emitting server-side text filter changes. Set to `0` to disable. @default 300 */
+    filterDebounceMs?: number;
+    /**
+     * Sorting behavior: one active column, multiple columns, or disabled entirely.
+     * @default 'multi'
+     */
+    sortOption?: 'single' | 'multi' | 'none';
+    /**
+     * Row selection mode.
+     * - `'none'` — no selection (default)
+     * - `'single'` — click to select/deselect
+     * - `'multi'` — Ctrl+click toggles, Shift+click extends range, click+drag sweeps
+     */
+    rowSelection?: 'single' | 'multi' | 'none';
+    /** Returns a short description string shown next to the group label. */
+    groupDescription?: ((label: string) => string) | null;
+    /** Actions shown in the group header's `⋮` menu. */
+    groupActions?: GroupAction[];
+    /**
+     * Extra items appended to the cell right-click context menu.
+     * Pass `null` entries to insert separator lines.
+     */
+    cellMenuItems?: (CellContextMenuItem<T> | null)[];
+    /** Shade every other row slightly for easier reading. @default false */
+    zebraStripes?: boolean;
+    /** Make the entire grid read-only. @default false */
+    readonly?: boolean;
+    /** Restrict editing to the sidebar editor instead of inline cells. */
+    useSidebarEditor?: boolean;
+    /** Show a loading overlay over the grid body. @default false */
+    loading?: boolean;
+    /** Message shown when the grid has no rows to display. */
+    emptyText?: string;
+}
+/**
+ * Bundles a grid's data source, control state, columns, and display options.
+ *
+ * Create one provider per independent grid instance. A provider may be selected
+ * from an array when a component renders multiple grids.
+ */
+declare class AgridProvider<T extends object = any> {
+    /** Mutable row data consumed by the grid. */
+    datasource: AgridDataSource<T>;
+    /** Runtime UI state and imperative grid controls. */
+    control: AgridControl;
+    /** Reactive column definitions in display order. */
+    readonly columns: WritableSignal<ColDef<T>[]>;
+    /** Shared grid options such as locale. */
+    options: AGridOptions;
+    private readonly _localizations;
+    /** Read-only view of registered per-locale text overrides. Used by the grid to resolve locale text. */
+    get localizations(): ReadonlyMap<string, AgridLocaleTextOverrides>;
+    /**
+     * Register locale-specific label overrides. Call multiple times for multiple locales.
+     * When `locale` is `'auto'`, the grid matches the browser language against registered locales
+     * (exact match first, then primary-language match, e.g. `'fr'` matches a browser locale of `'fr-FR'`).
+     *
+     * @example
+     * provider.addLocalization('fr-FR', { addRow: 'Ajouter une ligne', noRows: 'Aucune donnée' });
+     */
+    addLocalization(locale: string, overrides: AgridLocaleTextOverrides): this;
+    /** Fixed virtual-scroll row height in pixels. */
+    rowHeight: number;
+    /** Minimum CSS height of the grid host. */
+    minHeight?: string;
+    /** Maximum CSS height of the grid host. */
+    maxHeight?: string;
+    /** Whether the add-row placeholder is shown. */
+    allowAddRows: boolean;
+    /** Whether the control column is rendered. */
+    showControlColumn: boolean;
+    /** Whether the sidebar is available. */
+    showSidebar: boolean;
+    /** Whether selecting a row automatically opens its detail panel. */
+    autoOpenDetail: boolean;
+    /** Whether filter and sort operations are delegated to the host. */
+    serverSideFiltering: boolean;
+    /** Delay before server-side filter events are emitted. */
+    filterDebounceMs: number;
+    /** Enabled sorting mode. */
+    sortOption: 'single' | 'multi' | 'none';
+    /** Toggle auto-add-rows without recreating the provider. @default signal(false) */
+    readonly autoAddRows: WritableSignal<boolean>;
+    /** Enabled row-selection mode. */
+    rowSelection: 'single' | 'multi' | 'none';
+    /** Optional description shown beside each group heading. */
+    groupDescription: ((label: string) => string) | null;
+    /** Actions available from group headers. */
+    groupActions: GroupAction[];
+    /** Additional cell context-menu entries. */
+    cellMenuItems: (CellContextMenuItem<T> | null)[];
+    /** Whether alternating data rows receive stripe styling. */
+    zebraStripes: boolean;
+    /** Optional empty-state text override. */
+    emptyText?: string;
+    /** Whether edits are restricted to the sidebar editor. */
+    useSidebarEditor: boolean;
+    /** Toggle the loading overlay without recreating the provider. @default signal(false) */
+    readonly loading: WritableSignal<boolean>;
+    /** Toggle readonly mode without recreating the provider. @default signal(false) */
+    readonly readonlyGrid: WritableSignal<boolean>;
+    /** Creates a provider from the supplied data, state, columns, and display options. */
+    constructor(config?: AgridProviderConfig<T>);
+    /** Returns the current reactive row array. */
+    getGridData(): T[];
+}
+
+/** String-valued property names available on a row type. */
+type AgridField<T extends object> = Extract<keyof T, string>;
+/** Global options shared by grid providers. */
+interface AGridOptions {
+    /**
+     * Locale used for built-in labels, date formatting, and comparisons.
+     * Use `'auto'` to resolve the browser locale.
+     */
+    locale: string;
+}
+/**
+ * A single item in the cell right-click context menu.
+ * Pass `null` in the array to render a separator line.
+ */
+interface CellContextMenuItem<T extends object = any> {
+    /** Label shown in the menu. */
+    label: string;
+    /** Called when the item is clicked. */
+    action: (params: {
+        value: T[AgridField<T>];
+        row: T;
+        field: AgridField<T>;
+        originalIndex: number;
+    }) => void;
+    /** Grays out the item and prevents clicks. */
+    disabled?: boolean;
+    /** Renders the item in red (destructive action). */
+    danger?: boolean;
+}
+/**
+ * A structured value option used when the data field stores a raw value (e.g. a numeric ID)
+ * but the cell should display a human-readable label.
+ *
+ * @example
+ * ```ts
+ * values: [
+ *   { value: 1, label: 'Engineering' },
+ *   { value: 2, label: 'Sales' },
+ * ]
+ * ```
+ */
+interface ValueOption<TValue = unknown> {
+    /** Raw value stored in the data source (e.g. `1`, `'ENG'`). */
+    value: TValue;
+    /** Human-readable label shown in the cell, dropdown, and filter menu. */
+    label: string;
+}
+/** Width sentinel that makes a column fill the remaining horizontal space. */
+declare const ColDefAutoSize = -1;
+/** 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. */
+    field: K;
+    /** Text displayed in the column header. */
+    header: string;
+    /**
+     * 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`).
+     */
+    width?: number;
+    /**
+     * Semantic type of the field.
+     * - `'number'` — blank rows initialize this field to `0` instead of `''`.
+     * - `'date'` — uses a native date editor and built-in localized display formatting.
+     */
+    type?: 'text' | 'number' | 'date';
+    /**
+     * Set to `false` to make the column read-only.
+     * Defaults to `true` (editable) when omitted.
+     */
+    editable?: boolean;
+    /**
+     * Fixed list of allowed values shown in a `<select>` dropdown when editing.
+     *
+     * - `string[]` — simple list; the stored value equals the displayed label.
+     * - `ValueOption[]` — structured list; the stored value (`value`) differs from the
+     *   displayed label (`label`). Useful when the dataset stores IDs but should show names.
+     */
+    values?: string[] | ValueOption<T[K]>[];
+    /**
+     * 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.
+     *
+     * @example
+     * ```ts
+     * { field: 'salary', formatter: v => `$${Number(v).toLocaleString()}` }
+     * ```
+     */
+    formatter?: (value: T[K]) => string;
+    /**
+     * Set to `true` to show a filter input and value-picker in the filter row for this column.
+     * At least one filterable column must exist for the filter row to appear.
+     */
+    filterable?: boolean;
+    /**
+     * Set to `true` to allow grouping the grid by this column.
+     * When set, the filter dropdown shows a "Group by" toggle for this column.
+     */
+    groupable?: boolean;
+    /**
+     * Set to `true` to hide this column when the grid first renders.
+     * The column remains in the dataset and can be re-shown via the sidebar column picker
+     * or programmatically via `AgridControl.setColumnVisibility()`.
+     */
+    hidden?: boolean;
+    /**
+     * Pin this column to the left edge of the grid so it stays visible during horizontal scroll.
+     * Can also be toggled at runtime via `AgridControl.setPinned()`.
+     */
+    pinned?: 'left' | 'right';
+    /**
+     * Aggregate function shown in the footer row for this column.
+     * Built-in: `'sum'`, `'avg'`, `'min'`, `'max'`, `'count'`.
+     * Pass a custom function to compute any value from the visible row values.
+     * The footer only appears when at least one column has `aggregate` set.
+     *
+     * @example
+     * ```ts
+     * { field: 'salary', aggregate: 'sum' }
+     * { field: 'score',  aggregate: values => values.filter(v => Number(v) > 90).length }
+     * ```
+     */
+    aggregate?: 'sum' | 'avg' | 'min' | 'max' | 'count' | ((values: unknown[]) => unknown);
+    /**
+     * Return one or more CSS class names to apply to every cell in this column based on the
+     * cell's value and row data. Useful for conditional highlighting without a custom renderer.
+     *
+     * @example
+     * ```ts
+     * { field: 'score', cellClass: ({ value }) => Number(value) < 50 ? 'cell-danger' : '' }
+     * ```
+     */
+    cellClass?: (params: {
+        value: T[K];
+        row: T;
+    }) => string;
+    /**
+     * Set to `true` to prevent the column from being resized, reordered, or autosized.
+     * The column can still be hidden, filtered, and sorted.
+     */
+    locked?: boolean;
+    /**
+     * Custom cell renderer. Returns an HTML string displayed instead of the plain text value.
+     * Angular's built-in HTML sanitization is applied automatically.
+     *
+     * @example
+     * ```ts
+     * { field: 'status', cellRenderer: ({ value }) =>
+     *   `<span class="badge badge-${value}">${value}</span>` }
+     * ```
+     */
+    cellRenderer?: (params: {
+        value: T[K];
+        row: T;
+    }) => string;
+}
+/**
+ * Defines a column whose `field`, formatter value, renderer value, and row are
+ * derived from the supplied row type.
+ */
+type ColDef<T extends object = any, K extends AgridField<T> = AgridField<T>> = K extends AgridField<T> ? ColDefBase<T, K> : never;
+/**
+ * Defines a single action shown in the group header's action menu.
+ * Pass an array of these to `<agrid [groupActions]="...">`.
+ */
+interface GroupAction {
+    /** Label shown in the dropdown. */
+    label: string;
+    /** Called with the group's display label when the item is clicked. */
+    action: (groupLabel: string) => void;
+}
+/**
+ * Internal row item used in the virtual scroll list.
+ * - `{ row, originalIndex }` — a real data row
+ * - `null` — the add-row placeholder
+ * - `'ghost'` — the drop-target ghost inserted while dragging
+ * - `{ groupLabel, count, collapsed }` — group header row when grouping is active
+ */
+type GridItem<T extends object = Record<string, unknown>> = {
+    row: T;
+    originalIndex: number;
+} | null | 'ghost' | {
+    groupLabel: string;
+    count: number;
+    collapsed: boolean;
+};
+/** Zero-based position of a cell inside the grid. */
+interface CellPosition {
+    /** Zero-based row index in the data array. */
+    rowIndex: number;
+    /** Zero-based column index in {@link ColDef} order. */
+    colIndex: number;
+}
+/** Emitted by `(cellEdit)` after the user commits a cell change. */
+type GridEditEvent<T extends object = any> = {
+    [K in AgridField<T>]: {
+        /** Position of the edited cell. */
+        position: CellPosition;
+        /** The `ColDef.field` that was changed. */
+        field: K;
+        /** Previous field value before the edit. */
+        oldValue: T[K];
+        /** New field value after the edit. */
+        newValue: T[K];
+    };
+}[AgridField<T>];
+/**
+ * Emitted asynchronously after an edit changes a row and the data source has been updated.
+ *
+ * Unlike {@link GridEditEvent}, this row-level event identifies the provider and
+ * data source that own the edited record, which is useful when rendering multiple grids.
+ */
+interface RecordEditEvent<T extends object = any> {
+    /** Zero-based index of the edited row in the data source. */
+    index: number;
+    /** Current row data after the edit has been applied. */
+    data: T;
+    /** Exact provider instance that emitted the event. */
+    provider: AgridProvider<T>;
+    /** Exact data source containing the edited row. */
+    datasource: AgridDataSource<T>;
+}
+/**
+ * Compatibility alias for the provider-aware event emitted by `(rowRemoved)`.
+ * @deprecated Use {@link RecordEditEvent}.
+ */
+type RowRemovedEvent<T extends object = any> = RecordEditEvent<T>;
+/**
+ * Emitted by `(rowSelect)` when the selection changes. `null` means all rows were deselected.
+ * In `'single'` mode `rows` always has at most one entry.
+ */
+interface RowSelectEvent<T extends object = any> {
+    /** Selected rows and their original data-source indices. */
+    rows: {
+        row: T;
+        originalIndex: number;
+    }[];
+}
+/** Emitted when the user clicks a data row. */
+interface RowClickEvent<T extends object = any> {
+    /** Snapshot of the clicked row. */
+    row: T;
+    /** Zero-based index of the row in the data source. */
+    originalIndex: number;
+}
+/** Emitted after the user saves a row through the sidebar editor. */
+interface RowUpdateEvent<T extends object = any> {
+    /** 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)`
+ * (or your own equivalent) inside the handler.
+ */
+interface RowReorderEvent<T extends object = any> {
+    /** Snapshot of the row data at drag time. */
+    row: T;
+    /** Index of the row in the data source before the move. */
+    oldIndex: number;
+    /**
+     * Target position in the data source (insert-before semantics).
+     * Pass both `oldIndex` and `newIndex` to {@link AgridDataSource.moveRow}.
+     */
+    newIndex: number;
+}
+/**
+ * Emitted by `(pageChange)` when the user navigates to a different page in server-side
+ * pagination mode (i.e. when `AgridControl.totalRows` is set to a value greater than zero).
+ * The host should fetch the rows for `startRow..endRow` from the server and push them into
+ * the data source — the grid itself does not slice or filter the data in this mode.
+ */
+interface PageChangeEvent {
+    /** New page number (1-based). */
+    page: number;
+    /** Rows per page as configured on `AgridControl`. */
+    pageSize: number;
+    /** Zero-based index of the first row on this page. */
+    startRow: number;
+    /** Zero-based index of the last row on this page (inclusive). */
+    endRow: number;
+}
+/** Emitted when a text filter changes in server-side filtering mode. */
+interface FilterChangeEvent {
+    /** Field name of the filtered column. */
+    field: string;
+    /** Current filter text. An empty string clears the filter. */
+    value: string;
+}
+/** Emitted when a sort changes in server-side filtering mode. */
+interface SortChangeEvent {
+    /** Field name of the sorted column. */
+    field: string;
+    /** Current direction. `null` clears the sort. */
+    direction: 'asc' | 'desc' | null;
+}
+/**
+ * Emitted by `(prepareAddRecord)` when the grid has inserted a blank row.
+ * Use this to populate the new row with real defaults via {@link AgridDataSource.updateRow} or
+ * {@link AgridDataSource.patchRow}.
+ */
+interface NewRecord<T extends object = any> {
+    /** Index at which the blank row was inserted in the data source. */
+    index: number;
+    /** The empty row object the grid created (field values are `''` / `0` by type). */
+    data: T;
+    /** Exact provider instance that emitted this event. Useful when rendering multiple grids. */
+    provider: AgridProvider<T>;
+    /** Exact data source containing the inserted row. */
+    datasource: AgridDataSource<T>;
+}
+
+/** Screen position and row targeted by the row context menu. @internal */
+type AgridRowContextMenu = {
+    x: number;
+    y: number;
+    rowIndex: number;
+};
+/** Screen position and cell data targeted by the cell context menu. @internal */
+type AgridCellContextMenu = {
+    x: number;
+    y: number;
+    rowIndex: number;
+    colIndex: number;
+    field: string;
+    value: unknown;
+    row: Record<string, unknown>;
+};
+
+/** Rectangular selection represented by source row and visible column positions. @internal */
+type CellRange = {
+    anchor: CellPosition;
+    focus: CellPosition;
+};
+
+/** Location of a formatted-value match in source and display coordinates. @internal */
+type AgridFindMatch = {
+    rowIndex: number;
+    displayIndex: number;
+    colIndex: number;
+};
+
+/** Display model for one value-filter option in the column menu. */
+interface AgridColumnMenuValueItem {
+    /** Human-readable value label shown in the menu. */
+    label: string;
+    /** Raw value string used by the filter state. */
+    rawStr: string;
+    /** Whether this value is present in the current cross-filtered row set. */
+    active: boolean;
+    /** Whether this value is currently selected in the value filter. */
+    selected: boolean;
+}
+
+/** Position and target field of the open column menu. @internal */
+type AgridColumnMenuState = {
+    field: string;
+    x: number;
+    y: number;
+};
+
+/** Rectangular bounds in projected row and visible column coordinates. @internal */
+type VisibleCellBounds = {
+    rowStart: number;
+    rowEnd: number;
+    colStart: number;
+    colEnd: number;
+};
+
+/** Dependencies and callbacks required by {@link AgridDragHandler}. @internal */
+interface AgridDragHandlerOptions {
+    dataSource: Signal<AgridDataSource>;
+    filteredItems: () => GridItem[];
+    locale: () => string | undefined;
+    selectedIndices: WritableSignal<Set<number>>;
+    onReorder: (event: RowReorderEvent) => void;
+    onSelectionChange: () => void;
+}
+/**
+ * Handles both row-reorder drag and drag-select. The two share `_getHoveredRow`
+ * and the same pointer-event lifecycle pattern, so they live together.
+ *
+ * Signals exposed here are read by the component's `displayItems` computed
+ * to render the ghost row during a reorder drag.
+ *
+ * @internal
+ */
+declare class AgridDragHandler {
+    private readonly opts;
+    private readonly browser;
+    readonly reorderOriginalIndex: WritableSignal<number | null>;
+    readonly reorderOverIndex: WritableSignal<number | null>;
+    readonly reorderInsertBefore: WritableSignal<boolean>;
+    private _overlayEl;
+    private _offsetX;
+    private _offsetY;
+    private _dragSelAnchor;
+    constructor(opts: AgridDragHandlerOptions, destroyRef: DestroyRef, browser?: AgridBrowserAdapter);
+    /** Starts a row reorder gesture and creates its floating preview. */
+    startReorder(event: PointerEvent, originalIndex: number): void;
+    /** Returns the formatted value shown in a reorder ghost cell. */
+    getGhostDisplay(col: ColDef): string;
+    private readonly _reorderMove;
+    private readonly _reorderUp;
+    private readonly _reorderCancel;
+    private _cleanupReorder;
+    private _removeReorderListeners;
+    private _clearReorder;
+    /** Starts pointer-driven multi-row selection from an anchor row. */
+    startDragSelect(originalIndex: number): void;
+    private readonly _dragSelMove;
+    private readonly _dragSelUp;
+    private readonly _dragSelCancel;
+    private _cancelDragSelect;
+    private _removeDragSelectListeners;
+    private _getHoveredRow;
+}
+
+/** Field edit emitted by the sidebar detail form. @internal */
+interface AgridSidebarEdit {
+    /** Data field being edited. */
+    field: string;
+    /** Column definition controlling value coercion and editability. */
+    col: ColDef;
+    /** Raw string value produced by the form control. */
+    value: string;
+}
+/** Display and edit model for one sidebar detail field. @internal */
+interface AgridSidebarDetailField {
+    /** Human-readable field label. */
+    label: string;
+    /** Formatted read-only display value. */
+    value: string;
+    /** Original value stored in the row. */
+    rawValue: unknown;
+    /** String value supplied to the field editor. */
+    inputValue: string;
+    /** Whether the corresponding grid column is hidden. */
+    hidden: boolean;
+    /** Whether the field can be edited in the current grid state. */
+    editable: boolean;
+    /** Column definition associated with the field. */
+    col: ColDef;
+}
+
+/**
+ * Excel-like data grid for Angular 21.
+ *
+ * ## Minimal setup
+ * ```html
+ * <agrid [provider]="gridProvider" />
+ * ```
+ *
+ * ### Keyboard shortcuts
+ * | Key | Action |
+ * |-----|--------|
+ * | Arrow keys | Move selection |
+ * | Tab / Shift+Tab | Move right / left (wraps rows) |
+ * | Enter / F2 | Enter edit mode |
+ * | Printable key | Enter edit mode with seeded character |
+ * | Escape | Cancel edit |
+ * | Tab / Enter (while editing) | Commit and move right / down |
+ */
+declare class AgridComponent<T extends object = any> {
+    /** Grid provider containing columns, data source, control, and options. */
+    provider: _angular_core.InputSignal<AgridProvider<T>>;
+    readonly rowHeight: Signal<number>;
+    readonly minHeight: Signal<string | undefined>;
+    readonly maxHeight: Signal<string | undefined>;
+    readonly allowAddRows: Signal<boolean>;
+    readonly autoAddRows: Signal<boolean>;
+    readonly showControlColumn: Signal<boolean>;
+    readonly showSidebar: Signal<boolean>;
+    readonly autoOpenDetail: Signal<boolean>;
+    readonly serverSideFiltering: Signal<boolean>;
+    readonly filterDebounceMs: Signal<number>;
+    readonly sortOption: Signal<"single" | "multi" | "none">;
+    readonly rowSelection: Signal<"single" | "multi" | "none">;
+    readonly groupDescription: Signal<((label: string) => string) | null>;
+    readonly groupActions: Signal<GroupAction[]>;
+    readonly cellMenuItems: Signal<(CellContextMenuItem<T> | null)[]>;
+    readonly zebraStripes: Signal<boolean>;
+    readonly readonlyGrid: Signal<boolean>;
+    readonly loading: Signal<boolean>;
+    readonly emptyText: Signal<string | undefined>;
+    readonly useSidebarEditor: Signal<boolean>;
+    /** Column definitions from the active provider. */
+    readonly colDefs: Signal<ColDefBase<any, string>[]>;
+    /** Signal-based data container from the active provider. */
+    readonly dataSource: Signal<AgridDataSource<any>>;
+    /** Grid UI state container from the active provider. */
+    readonly control: Signal<AgridControl | null>;
+    /** Resolved locale code used for date formatting and built-in localization lookup. 'auto' is replaced with navigator.language. */
+    readonly locale: Signal<string>;
+    /** Resolved built-in locale text merged with provider customizations. */
+    readonly localeText: Signal<AgridLocaleText>;
+    /** Effective empty-state label. */
+    readonly emptyTextLabel: Signal<string>;
+    /** Emitted after the user commits a cell edit. */
+    cellEdit: _angular_core.OutputEmitterRef<GridEditEvent<T>>;
+    /**
+     * Emitted after an edit changes a row.
+     * Includes the row index, current data, provider, and data source.
+     */
+    recordEdit: _angular_core.OutputEmitterRef<RecordEditEvent<T>>;
+    /** Emitted after a row is removed, with its former index and captured row data. */
+    rowRemoved: _angular_core.OutputEmitterRef<RecordEditEvent<T>>;
+    /** Emitted when the grid inserts a blank row. Use `dataSource.patchRow()` to populate it. */
+    prepareAddRecord: _angular_core.OutputEmitterRef<NewRecord<T>>;
+    /** Emitted when the user finishes dragging a row. Call `dataSource.moveRow()` to apply. */
+    rowReorder: _angular_core.OutputEmitterRef<RowReorderEvent<T>>;
+    /** Emitted when the row selection changes. `null` = selection cleared. */
+    rowSelect: _angular_core.OutputEmitterRef<RowSelectEvent<T> | null>;
+    rowDoubleClicked: _angular_core.OutputEmitterRef<RowClickEvent<T>>;
+    /** Emitted when the user single-clicks a data row. */
+    rowClick: _angular_core.OutputEmitterRef<RowClickEvent<T>>;
+    /** Emitted when the user has changed and saved a record via the sidebar editor save button */
+    rowChanged: _angular_core.OutputEmitterRef<RowUpdateEvent<T>>;
+    /**
+     * Emitted when the user navigates to a new page in **server-side pagination mode**
+     * (i.e. when `AgridControl.totalRows` is greater than zero).
+     * The host should fetch the indicated row slice and update the data source.
+     */
+    pageChange: _angular_core.OutputEmitterRef<PageChangeEvent>;
+    /** Emitted when a header filter changes in server-side filtering mode. */
+    filterChange: _angular_core.OutputEmitterRef<FilterChangeEvent>;
+    /** Emitted when a column sort changes in server-side filtering mode. */
+    sortChange: _angular_core.OutputEmitterRef<SortChangeEvent>;
+    /** Currently focused cell, or `null`. */
+    readonly selectedCell: _angular_core.WritableSignal<CellPosition | null>;
+    /** Rectangular cell range selected by Shift+arrow or Shift+click. */
+    readonly selectedRange: _angular_core.WritableSignal<CellRange | null>;
+    /** Fill-handle drag preview bounds, in visible row/column coordinates. */
+    get fillPreviewBounds(): _angular_core.WritableSignal<VisibleCellBounds | null>;
+    /** Position of the cell in edit mode, or `null`. */
+    get editingCell(): _angular_core.WritableSignal<CellPosition | null>;
+    /** Draft value while editing — committed on Tab/Enter, discarded on Escape. */
+    get currentDraft(): _angular_core.WritableSignal<unknown>;
+    /** Seed character typed to enter edit mode (e.g. pressing 'A'). */
+    get editSeedChar(): _angular_core.WritableSignal<string>;
+    /** Toggle the sidebar open/closed. */
+    toggleSidebar(): void;
+    /** @internal */
+    onSidebarStripClick(tab: 'columns' | 'detail'): 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;
+    /** @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`. */
+    getCellClass(col: ColDef, value: unknown, row: Record<string, unknown>): string;
+    /** @internal Short symbol shown before the footer aggregate value. */
+    getAggregateLabel(col: ColDef): string;
+    /** @internal Whether a column has a static or control-configured aggregate. */
+    hasAggregate(col: ColDef): boolean;
+    /** @internal Formatted footer value — uses the column formatter when set, otherwise locale number. */
+    getFooterDisplay(col: ColDef, value: unknown): string;
+    private readonly groupController;
+    readonly allowRowReorder: Signal<boolean>;
+    /** `true` when there is a committed edit that can be undone (Ctrl+Z). */
+    readonly canUndo: Signal<boolean>;
+    /** `true` when there is a previously undone edit that can be re-applied (Ctrl+Y / Ctrl+Shift+Z). */
+    readonly canRedo: Signal<boolean>;
+    private readonly columnLayout;
+    /** Columns currently visible after hidden state, ordering, and pinning are applied. */
+    readonly visibleColDefs: Signal<ColDefBase<any, string>[]>;
+    /** Columns currently pinned to the left in display order. */
+    readonly pinnedColDefs: Signal<ColDefBase<any, string>[]>;
+    /** Columns currently pinned to the right in display order. */
+    readonly rightPinnedColDefs: Signal<ColDefBase<any, string>[]>;
+    /** Columns rendered in the horizontally scrollable pane. */
+    readonly scrollableColDefs: Signal<ColDefBase<any, string>[]>;
+    readonly rightGridTemplateColumns: Signal<string>;
+    readonly rightPinnedPaneWidth: Signal<number>;
+    readonly hasRightPinnedPane: Signal<boolean>;
+    readonly hasPinnedPane: Signal<boolean>;
+    readonly hasFilterableColumns: Signal<boolean>;
+    private readonly columnState;
+    private readonly projection;
+    private readonly editController;
+    /** Total filtered row count regardless of current page. */
+    readonly filteredRowCount: Signal<number>;
+    /** Total number of pages given the current filter and page size. */
+    readonly totalPages: Signal<number>;
+    readonly showPagination: Signal<boolean>;
+    /** Number of rendered semantic rows, including the header row. */
+    readonly ariaRowCount: Signal<number>;
+    /** Number of visible semantic columns, including the optional control column. */
+    readonly ariaColCount: Signal<number>;
+    /** True when no rows or group headers are visible (ignores add-row sentinel and ghost). */
+    readonly isEmpty: Signal<boolean>;
+    /**
+     * @internal Effective aggregate for the column menu — string values only.
+     * Custom function aggregates from ColDef can't be represented in the menu so they return null.
+     */
+    getEffectiveAggregate(col: ColDef): 'sum' | 'avg' | 'min' | 'max' | 'count' | null;
+    /** True when at least one visible column has an aggregate function (from ColDef or control). */
+    readonly showFooter: Signal<boolean>;
+    /** Computed aggregate value per column field, over currently filtered rows. */
+    readonly footerValues: Signal<Record<string, unknown>>;
+    readonly gridTemplateColumns: Signal<string>;
+    readonly pinnedGridTemplateColumns: Signal<string>;
+    readonly scrollableGridTemplateColumns: Signal<string>;
+    readonly totalWidth: Signal<number>;
+    readonly pinnedPaneWidth: Signal<number>;
+    readonly scrollableTotalWidth: 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[]>;
+    /** 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>>;
+    readonly displayItems: Signal<GridItem[]>;
+    readonly groupActionsMenu: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+        label: string;
+    } | null>;
+    private readonly viewport;
+    private readonly pinnedViewport;
+    private readonly rightPinnedViewport;
+    private readonly wrapperEl;
+    private readonly horizontalScrollerEl;
+    private readonly destroyRef;
+    private readonly _hostEl;
+    private readonly browser;
+    private readonly rangeController;
+    private readonly columnSizing;
+    private readonly columnMenuController;
+    readonly filterMenu: _angular_core.WritableSignal<AgridColumnMenuState | null>;
+    readonly filterMenuSearch: _angular_core.WritableSignal<string>;
+    readonly filterMenuItems: Signal<{
+        label: string;
+        rawStr: string;
+    }[]>;
+    readonly filterMenuVisibleItems: Signal<{
+        label: string;
+        rawStr: string;
+    }[]>;
+    readonly filterMenuActiveValues: Signal<Set<string>>;
+    readonly columnMenuValueItems: Signal<AgridColumnMenuValueItem[]>;
+    private readonly presentation;
+    private readonly findController;
+    readonly findOpen: _angular_core.WritableSignal<boolean>;
+    readonly findQuery: _angular_core.WritableSignal<string>;
+    readonly findActiveIndex: _angular_core.WritableSignal<number>;
+    readonly findMatches: Signal<AgridFindMatch[]>;
+    private readonly navigationController;
+    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>;
+    private readonly sidebarController;
+    readonly sidebarOpen: _angular_core.WritableSignal<boolean>;
+    readonly sidebarTab: _angular_core.WritableSignal<"columns" | "detail">;
+    readonly sidebarRow: Signal<Record<string, unknown> | null>;
+    readonly sidebarHiddenColumns: Signal<ReadonlySet<string>>;
+    private readonly clipboardHandler;
+    readonly dragHandler: AgridDragHandler;
+    private readonly columnReorder;
+    /** @internal Start a column header drag. */
+    onColHeaderPointerDown(event: PointerEvent, field: string): void;
+    /** @internal Whether the given column header is being dragged. */
+    isColDragging(field: string): boolean;
+    /** @internal Template helper for drop-indicator class. */
+    getColDropSide(field: string): 'before' | 'after' | null;
+    private readonly _seededControls;
+    private emitEditEvents;
+    private emitRecordEdit;
+    private createRecordEvent;
+    constructor();
+    /** @internal */
+    isDataRowItem(item: GridItem): item is {
+        row: Record<string, unknown>;
+        originalIndex: number;
+    };
+    /** @internal */
+    isGroupHeaderItem(item: GridItem): item is {
+        groupLabel: string;
+        count: number;
+        collapsed: boolean;
+    };
+    /** @internal */
+    getItemOriginalIndex(item: GridItem): number | null;
+    /** @internal CDK trackBy — arrow to preserve `this`. */
+    readonly trackByItem: (_di: number, item: GridItem) => string | number;
+    /** @internal */
+    isSelected(originalIndex: number, ci: number): boolean;
+    /** @internal */
+    isEditing(originalIndex: number, ci: number): boolean;
+    /** @internal */
+    getSeedChar(originalIndex: number, ci: number): string;
+    /** @internal */
+    isAddRowSelected(): boolean;
+    /** @internal */
+    isRowSelected(originalIndex: number): boolean;
+    /** @internal Selection class for the separate pinned/control viewport. */
+    isPinnedPaneRowSelected(item: GridItem): boolean;
+    /** @internal */
+    /** @internal 1-based sort priority for a column, 0 if not sorted. */
+    getSortPriority(field: string): number;
+    /** @internal Whether more than one column is currently sorted. */
+    hasMultiSort(): boolean;
+    getTextFilter(field: string): string;
+    /** @internal */
+    getSort(field: string): 'asc' | 'desc' | null;
+    /** @internal */
+    isMenuAllSelected(field: string): boolean;
+    /** @internal */
+    isMenuValueActive(rawStr: string): boolean;
+    /** @internal */
+    isMenuValueSelected(field: string, value: string): boolean;
+    /** @internal */
+    hasActiveFilter(field: string): boolean;
+    /** @internal */
+    getColDef(field: string): ColDef | undefined;
+    /** @internal */
+    getVisibleColIndex(field: string): number;
+    /** @internal Convert a zero-based visible data-column index to a one-based ARIA index. */
+    getAriaColIndex(colIndex: number): number;
+    /** @internal */
+    isColumnHidden(field: string): boolean;
+    /** @internal */
+    isGroupedByField(field: string): boolean;
+    /** @internal */
+    isColumnPinned(field: string): boolean;
+    isColumnPinnedRight(field: string): boolean;
+    /** Returns `'left'`, `'right'`, or `false` — used by the column menu. */
+    getColumnPinState(field: string): 'left' | 'right' | false;
+    isFirstRightPinnedColumn(field: string): boolean;
+    /** @internal Returns `true` for the rightmost pinned column (used to draw the separator shadow). */
+    isLastPinnedColumn(field: string): boolean;
+    /** @internal */
+    onRowPointerDown(event: PointerEvent, originalIndex: number): void;
+    /** @internal Emits rowClick when the user single-clicks a data row outside of a cell editor. */
+    onRowClick(event: MouseEvent, item: {
+        row: Record<string, unknown>;
+        originalIndex: number;
+    }): void;
+    /** @internal */
+    onActivate(originalIndex: number, ci: number, event?: MouseEvent): void;
+    /** @internal */
+    onActivateAddRow(): void;
+    /** @internal */
+    onStartEdit(originalIndex: number, ci: number): void;
+    /** @internal */
+    onDraftChange(value: unknown): void;
+    /** @internal Starts a fill-handle drag from the bottom-right corner of the selection. */
+    onCellPointerDown(event: PointerEvent, originalIndex: number, colIndex: number): void;
+    /** @internal Main keyboard handler delegated from the wrapper div. */
+    onKeyDown(event: KeyboardEvent): void;
+    /** Open the find panel and focus its input. */
+    openFind(): void;
+    /** @internal */
+    closeFind(): void;
+    /** @internal */
+    onFindInput(value: string): void;
+    /** @internal */
+    goToFindMatch(direction: 1 | -1): void;
+    /** @internal Ghost cell display during a reorder drag. */
+    getGhostCellDisplay(col: ColDef): string;
+    /** @internal Delegates to AgridDragHandler. */
+    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 Copy the active range or cell as TSV. */
+    onCopy(event: ClipboardEvent): void;
+    /** @internal Paste TSV/CSV-like plain text into the current cell. */
+    onPaste(event: ClipboardEvent): void;
+    /** @internal Starts pointer-based column resizing. */
+    onResizeStart(event: MouseEvent, col: ColDef): void;
+    /** @internal Resize a column from its keyboard-accessible separator handle. */
+    onResizeKeyDown(event: KeyboardEvent, col: ColDef): void;
+    /** @internal Autosize a column to fit its header and currently visible row values. */
+    onAutosizeColumn(event: MouseEvent, col: ColDef): void;
+    /** @internal */
+    onControlContextMenu(event: MouseEvent, originalIndex: number): void;
+    /** @internal */
+    closeContextMenu(): void;
+    /** @internal */
+    onCellContextMenu(event: MouseEvent, rowIndex: number, colIndex: number, col: ColDef, row: Record<string, unknown>): void;
+    /** @internal */
+    closeCellContextMenu(): void;
+    /** @internal Runs a typed provider context-menu action against erased controller state. */
+    runCellMenuItem(item: CellContextMenuItem<T>, menu: AgridCellContextMenu): void;
+    /** @internal Copy the display value of one cell to the clipboard. */
+    copyCellToClipboard(value: unknown, col: ColDef): void;
+    /** @internal Copy all visible column values of a row as TSV to the clipboard. */
+    copyRowToClipboard(row: Record<string, unknown>): void;
+    /** @internal Insert a blank row at a specific position and emit prepareAddRecord. */
+    insertRowAt(atIndex: number): void;
+    /** Delete the row at `originalIndex`, adjusting stale cell/edit pointers. */
+    deleteRow(originalIndex: number): void;
+    /** @internal */
+    onGroupHeaderClick(label: string): void;
+    /** Expand all groups. No-op when grouping is not active. */
+    expandGroups(): void;
+    /** Collapse all groups. No-op when grouping is not active. */
+    collapseGroups(): void;
+    /** @internal */
+    getGroupDescription(label: string): string;
+    /** @internal */
+    openGroupActionsMenu(event: MouseEvent, label: string): void;
+    /** @internal */
+    closeGroupActionsMenu(): void;
+    /** @internal */
+    onGroupAction(action: GroupAction, label: string): void;
+    /** @internal */
+    onTextFilterChange(event: Event, field: string): void;
+    /** @internal */
+    openFilterMenu(event: MouseEvent, field: string): void;
+    /** @internal */
+    closeFilterMenu(): void;
+    /** @internal */
+    onFilterMenuSearch(value: string): void;
+    /** @internal */
+    onMenuSort(field: string, dir: 'asc' | 'desc'): void;
+    /** @internal */
+    onMenuClearFilter(field: string): void;
+    /** @internal */
+    /** @internal Replace the entire sort stack with a single sort on this column. */
+    onMenuResetSort(field: string, dir: 'asc' | 'desc'): void;
+    onMenuToggleGroupBy(field: string): void;
+    /** @internal */
+    onMenuClearAll(): void;
+    /** @internal */
+    onMenuToggleAll(field: string): void;
+    /** @internal */
+    onMenuToggleValue(field: string, rawStr: string): void;
+    /** @internal */
+    onSidebarToggleColumn(field: string): void;
+    /** @internal Mirrors vertical scrolling from the main viewport into both pinned panes. */
+    onBodyScroll(): void;
+    /** @internal */
+    onRightPinnedBodyScroll(): void;
+    /** @internal */
+    onMenuTogglePin(field: string): void;
+    /** @internal */
+    onMenuTogglePinRight(field: string): void;
+    /** @internal */
+    onMenuAutosizeColumn(field: string): void;
+    /** @internal */
+    onMenuSetAggregate(field: string, agg: 'sum' | 'avg' | 'min' | 'max' | 'count' | null): void;
+    /** @internal */
+    onMenuHideColumn(field: string): void;
+    private findDisplayIndex;
+    private isCellEditable;
+    private enterEdit;
+    private cancelCurrent;
+    /** @internal */
+    isRangeSelected(originalIndex: number, colIndex: number): boolean;
+    /** @internal */
+    isFindMatchCell(originalIndex: number, colIndex: number): boolean;
+    /** @internal */
+    isActiveFindMatchCell(originalIndex: number, colIndex: number): boolean;
+    /** @internal */
+    isFillHandleCell(originalIndex: number, colIndex: number): boolean;
+    /** @internal */
+    isFillPreviewCell(originalIndex: number, colIndex: number): boolean;
+    private scrollToKeepVisible;
+    /** @internal Current rendered width for a column. */
+    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"; "rowChanged": "rowChanged"; "pageChange": "pageChange"; "filterChange": "filterChange"; "sortChange": "sortChange"; }, never, never, true, never>;
+}
+
+export { AGRID_LOCALE_TEXT, AgridComponent, AgridControl, AgridDataSource, AgridProvider, ColDefAutoSize };
+export type { AgridControlState, AgridField, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridProviderConfig, CellContextMenuItem, CellPosition, ColDef, FilterChangeEvent, GridEditEvent, GroupAction, HistoryEntry, HistoryItem, NewRecord, PageChangeEvent, RecordEditEvent, RowClickEvent, RowRemovedEvent, RowReorderEvent, RowSelectEvent, RowUpdateEvent, SortChangeEvent, ValueOption };
+//# sourceMappingURL=thkl-agrid.d.ts.map