@thkl/agrid 0.1.5 → 0.1.9

package/types/thkl-agrid.d.ts

@@ -22,6 +22,8 @@ declare class AgridBrowserAdapter {
     setBodyInteraction(cursor: string, userSelect: string): void;
     /** Returns the viewport width or infinity during server rendering. */
     viewportWidth(): number;
+    /** Returns the viewport height or infinity during server rendering. */
+    viewportHeight(): number;
     /** Returns computed styles when a window is available. */
     computedStyle(element: Element): CSSStyleDeclaration | null;
     /** Creates a 2D canvas context for text measurement. */
@@ -52,6 +54,11 @@ type HistoryItem = HistoryEntry | HistoryEntry[];
  * All three fields are independent — text, value selection, and sort are ANDed together
  * when computing the visible rows.
  */
+/**
+ * Comparison operator for a column condition filter.
+ * For `date` columns `gt`/`lt`/`eq` read as after / before / on.
+ */
+type FilterOperator = 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'between' | 'like' | 'startsWith' | 'endsWith' | 'includes' | 'notIncludes';
 interface ColumnFilter {
     /** Free-text substring filter (case-insensitive). Empty string = no text filter. */
     text: string;
@@ -63,6 +70,15 @@ interface ColumnFilter {
     selectedValues: string[] | null;
     /** Sort direction, or `null` when this column is not sorted. */
     sort: 'asc' | 'desc' | null;
+    /**
+     * Condition operator for text, number, or date columns, or `null`/omitted when none.
+     * Combined with text and value filters using AND semantics.
+     */
+    operator?: FilterOperator | null;
+    /** Primary comparison operand (number as string, or `yyyy-mm-dd`). */
+    operand?: string | null;
+    /** Upper-bound operand used only when {@link operator} is `'between'`. */
+    operand2?: string | null;
 }
 /** Serializable snapshot of the grid's UI state. Used with `toJSON` / `fromJSON`. */
 interface AgridControlState {
@@ -70,6 +86,8 @@ interface AgridControlState {
     columnWidths: Record<string, number>;
     /** Per-field filter and sort state. Fields with default state may be omitted. */
     filters: Record<string, ColumnFilter>;
+    /** Global quick-filter text matched across all visible columns. Empty string when inactive. */
+    quickFilter?: string;
     /** 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. */
@@ -117,6 +135,7 @@ interface AgridControlState {
 declare class AgridControl {
     private readonly _columnWidths;
     private readonly _filters;
+    private readonly _quickFilter;
     private readonly _allowRowReorder;
     private readonly _groupByField;
     private readonly _hiddenColumns;
@@ -147,6 +166,14 @@ declare class AgridControl {
      * Enable grouping by `field`, or pass `null` to turn grouping off.
      */
     setGroupBy(field: string | null): void;
+    /**
+     * Global quick-filter text. When non-empty (and not in server-side filtering mode),
+     * the grid keeps only rows where at least one visible column's display value contains
+     * this text (case-insensitive).
+     */
+    readonly quickFilter: Signal<string>;
+    /** Set the global quick-filter text. Pass an empty string to clear it. */
+    setQuickFilter(text: string): void;
     /**
      * Reactive set of field names that are currently hidden.
      * An empty set means all columns are visible.
@@ -290,6 +317,13 @@ declare class AgridControl {
      * Pass `null` to show all values (clear the value filter).
      */
     setSelectedValues(field: string, values: string[] | null): void;
+    /**
+     * Set a column condition filter. Text columns support string operators while number/date
+     * columns support comparison operators.
+     * Pass `operator: null` (or an empty `operand`) to clear it. `operand2` is only used
+     * by the `'between'` operator.
+     */
+    setRangeFilter(field: string, operator: FilterOperator | null, operand: string | null, operand2?: 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. */
@@ -310,14 +344,14 @@ declare class AgridControl {
      * Remove all active filters and sort for a single column.
      */
     clearFilter(field: string): void;
-    /** Remove all active filters and sorts for every column. */
+    /** Remove all active filters and sorts for every column, including the quick filter. */
     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. */
+    /** Return `true` when the quick filter or ANY column has an active filter or sort. */
     hasAnyActiveFilter(): boolean;
     /** Serialize current state to a plain object suitable for JSON storage. */
     toJSON(): AgridControlState;
@@ -436,7 +470,27 @@ interface AgridLocaleText {
     columnMenu: string;
     columns: string;
     detail: string;
+    toggleDetail: string;
     hiddenColumn: string;
+    filterCondition: string;
+    filterConditionMenu: string;
+    filterValue: string;
+    filterNoCondition: string;
+    filterOpEquals: string;
+    filterOpNotEquals: string;
+    filterOpGreater: string;
+    filterOpGreaterEqual: string;
+    filterOpLess: string;
+    filterOpLessEqual: string;
+    filterOpBetween: string;
+    filterOpBefore: string;
+    filterOpAfter: string;
+    filterOpOn: string;
+    filterOpLike: string;
+    filterOpStartsWith: string;
+    filterOpEndsWith: string;
+    filterOpIncludes: string;
+    filterOpNotIncludes: string;
     copyCellValue: string;
     copyRow: string;
     confirmDeleteRow: string;
@@ -460,9 +514,13 @@ interface AgridLocaleText {
     pinColumn: string;
     pinColumnRight: string;
     unpinColumnRight: string;
+    pinRowTop: string;
+    pinRowBottom: string;
+    unpinRow: string;
     previous: string;
     resizeColumn: string;
     rows: (count: number) => string;
+    quickFilterPlaceholder: string;
     searchValuesPlaceholder: string;
     selectAll: string;
     sortOnlyByThis: string;
@@ -518,6 +576,17 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     serverSideFiltering?: boolean;
     /** Delay before emitting server-side text filter changes. Set to `0` to disable. @default 300 */
     filterDebounceMs?: number;
+    /**
+     * Show the global quick-filter box above the grid. In client mode it filters rows whose
+     * visible columns contain the text; in `serverSideFiltering` mode it emits `(quickFilterChange)`
+     * instead of filtering locally. @default false
+     */
+    enableQuickFilter?: boolean;
+    /**
+     * Optional command bar rendered above the column headers. Buttons and dropdown items emit
+     * their id through the grid's single `(menuBarAction)` output.
+     */
+    menuBarItems?: AgridMenuBarItem<T>[];
     /**
      * Sorting behavior: one active column, multiple columns, or disabled entirely.
      * @default 'multi'
@@ -530,6 +599,14 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
      * - `'multi'` — Ctrl+click toggles, Shift+click extends range, click+drag sweeps
      */
     rowSelection?: 'single' | 'multi' | 'none';
+    /**
+     * Behavior after pressing Enter while an inline cell editor is active.
+     * - `'nothing'` — commit and keep the current cell selected
+     * - `'nextColumn'` — commit and move to the next column in the same row
+     * - `'nextRow'` — commit and move to the same column one row down
+     * @default 'nextRow'
+     */
+    enterEditAction?: AgridEnterEditAction;
     /** Returns a short description string shown next to the group label. */
     groupDescription?: ((label: string) => string) | null;
     /** Actions shown in the group header's `⋮` menu. */
@@ -553,6 +630,52 @@ interface AgridProviderConfig<T extends object = any> extends Partial<AGridOptio
     loading?: boolean;
     /** Message shown when the grid has no rows to display. */
     emptyText?: string;
+    /**
+     * Return one or more CSS class names applied to a whole data row, based on its data and index.
+     * Complements the per-cell {@link ColDef.cellClass}.
+     *
+     * @example
+     * ```ts
+     * getRowClass: ({ row }) => row.status === 'overdue' ? 'row-danger' : ''
+     * ```
+     */
+    getRowClass?: (params: {
+        row: T;
+        index: number;
+    }) => string;
+    /**
+     * Designate rows to pin to the top or bottom of the grid body. Pinned rows stay visible during
+     * vertical scroll and are excluded from grouping and pagination, but remain fully interactive
+     * (editable/selectable) because they keep their real data-source index.
+     *
+     * Return `'top'`, `'bottom'`, or `undefined` (a normal scrolling row).
+     *
+     * @example
+     * ```ts
+     * pinRow: row => row.isSummary ? 'bottom' : undefined
+     * ```
+     */
+    pinRow?: (row: T, index: number) => 'top' | 'bottom' | undefined;
+    /**
+     * Enable master/detail rows: each flat data row, or each leaf row in tree mode, can expand to
+     * reveal a detail panel rendered beneath it. Requires {@link detailRenderer}. Grouped mode is
+     * not supported. @default false
+     */
+    masterDetail?: boolean;
+    /**
+     * Returns the HTML shown inside an expanded detail panel. Angular's built-in HTML sanitization
+     * is applied automatically (same as {@link ColDef.cellRenderer}).
+     *
+     * @example
+     * ```ts
+     * detailRenderer: ({ row }) => `<div class="detail">${row.notes}</div>`
+     * ```
+     */
+    detailRenderer?: (params: {
+        row: T;
+    }) => string;
+    /** Fixed height in pixels of an expanded detail panel row. @default 200 */
+    detailRowHeight?: number;
 }
 /**
  * Bundles a grid's data source, control state, columns, and display options.
@@ -605,12 +728,18 @@ declare class AgridProvider<T extends object = any> {
     serverSideFiltering: boolean;
     /** Delay before server-side filter events are emitted. */
     filterDebounceMs: number;
+    /** Whether the global quick-filter box is shown above the grid. */
+    enableQuickFilter: boolean;
+    /** Commands rendered in the optional menu bar above the column headers. */
+    menuBarItems: AgridMenuBarItem<T>[];
     /** 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';
+    /** Behavior after pressing Enter while an inline cell editor is active. */
+    enterEditAction: AgridEnterEditAction;
     /** Optional description shown beside each group heading. */
     groupDescription: ((label: string) => string) | null;
     /** Actions available from group headers. */
@@ -627,6 +756,21 @@ declare class AgridProvider<T extends object = any> {
     emptyText?: string;
     /** Whether edits are restricted to the sidebar editor. */
     useSidebarEditor: boolean;
+    /** Optional callback returning CSS classes for a whole data row. */
+    getRowClass?: (params: {
+        row: T;
+        index: number;
+    }) => string;
+    /** Optional callback designating rows pinned to the top or bottom of the body. */
+    pinRow?: (row: T, index: number) => 'top' | 'bottom' | undefined;
+    /** Whether master/detail expandable detail rows are enabled. */
+    masterDetail: boolean;
+    /** Returns the sanitized HTML rendered inside an expanded detail panel. */
+    detailRenderer?: (params: {
+        row: T;
+    }) => string;
+    /** Fixed height in pixels of an expanded detail panel row. */
+    detailRowHeight: number;
     /** 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) */
@@ -639,6 +783,19 @@ declare class AgridProvider<T extends object = any> {
 
 /** String-valued property names available on a row type. */
 type AgridField<T extends object> = Extract<keyof T, string>;
+/** Behavior after pressing Enter while an inline cell editor is active. */
+type AgridEnterEditAction = 'nothing' | 'nextColumn' | 'nextRow';
+/** Parameters passed to a row-aware cell readonly resolver. */
+interface CellReadonlyParams<T extends object = any, K extends AgridField<T> = AgridField<T>> {
+    /** Datasource row containing the cell. */
+    row: T;
+    /** Current raw field value. */
+    value: T[K];
+    /** Column definition for the cell. */
+    column: ColDef<T, K>;
+    /** Zero-based index of the row in the datasource. */
+    originalIndex: number;
+}
 /** Global options shared by grid providers. */
 interface AGridOptions {
     /**
@@ -666,6 +823,44 @@ interface CellContextMenuItem<T extends object = any> {
     /** Renders the item in red (destructive action). */
     danger?: boolean;
 }
+/** Current grid state supplied to menu-bar visibility, active, and disabled resolvers. */
+interface AgridMenuBarContext<T extends object = any> {
+    /** Current datasource rows. */
+    rows: readonly T[];
+    /** Currently selected rows with their original datasource indices. */
+    selectedRows: readonly {
+        row: T;
+        originalIndex: number;
+    }[];
+    /** Currently selected cell, or `null`. */
+    selectedCell: CellPosition | null;
+    /** Provider that owns the menu bar. */
+    provider: AgridProvider<T>;
+    /** Datasource that owns the current rows. */
+    datasource: AgridDataSource<T>;
+}
+/** Static or runtime-resolved menu-bar state. */
+type AgridMenuBarState<T extends object = any> = boolean | ((context: AgridMenuBarContext<T>) => boolean);
+/** Shared configuration for menu-bar buttons and dropdown items. */
+interface AgridMenuBarMenuItem<T extends object = any> {
+    /** Stable command id emitted through `(menuBarAction)`. */
+    id: string;
+    /** Visible command label. */
+    label: string;
+    /** Optional compact icon or glyph shown before the label. */
+    icon?: string;
+    /** Whether the command is rendered. Defaults to `true`. */
+    visible?: AgridMenuBarState<T>;
+    /** Whether the command receives active styling. Defaults to `false`. */
+    active?: AgridMenuBarState<T>;
+    /** Whether the command is disabled. Defaults to `false`. */
+    disabled?: AgridMenuBarState<T>;
+}
+/** Top-level menu-bar button with optional additional dropdown commands. */
+interface AgridMenuBarItem<T extends object = any> extends AgridMenuBarMenuItem<T> {
+    /** Additional commands opened from the button's dropdown chevron. */
+    items?: AgridMenuBarMenuItem<T>[];
+}
 /**
  * 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.
@@ -708,15 +903,29 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
     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.
+     * - `'number'` — blank rows initialize this field to `0` instead of `''`; enables numeric
+     *   range filters (`>`, `<`, `between`, …) in the column menu.
+     * - `'date'` — uses a native date editor and built-in localized display formatting; enables
+     *   date range filters (before / after / between) in the column menu.
+     * - `'boolean'` — renders an inline checkbox that toggles the value on click (no edit mode).
      */
-    type?: 'text' | 'number' | 'date';
+    type?: 'text' | 'number' | 'date' | 'boolean';
     /**
      * Set to `false` to make the column read-only.
      * Defaults to `true` (editable) when omitted.
      */
     editable?: boolean;
+    /**
+     * Return `true` to make this specific cell read-only at runtime.
+     * Runs with the current row, value, column definition, and original datasource index.
+     * `editable: false` still makes the whole column read-only before this callback is checked.
+     *
+     * @example
+     * ```ts
+     * { field: 'approval', cellReadonly: ({ row }) => row.status !== 'Draft' }
+     * ```
+     */
+    cellReadonly?: (params: CellReadonlyParams<T, K>) => boolean;
     /**
      * Fixed list of allowed values shown in a `<select>` dropdown when editing.
      *
@@ -735,6 +944,25 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * ```
      */
     formatter?: (value: T[K]) => string;
+    /**
+     * Resolve an input mask for this specific string cell. The callback receives the current
+     * row, cell value, and column definition, so different rows in one column can use different
+     * regular expressions. Return `null` or `undefined` to leave the cell unrestricted.
+     *
+     * The expression is matched against the complete proposed editor value. It should accept
+     * partial values so the user can build the final value one character at a time.
+     *
+     * @example
+     * ```ts
+     * {
+     *   field: 'reference',
+     *   inputMask: ({ row }) => row.numeric
+     *     ? /\d{0,3}(?:-\d{0,5}(?:-\d{0,5})?)?/
+     *     : /[a-z0-9]{0,3}(?: [a-z0-9]{0,3}(?: [a-z0-9]{0,5})?)?/i,
+     * }
+     * ```
+     */
+    inputMask?: (params: InputMaskParams<T, K>) => RegExp | null | undefined;
     /**
      * 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.
@@ -787,6 +1015,17 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
      * The column can still be hidden, filtered, and sorted.
      */
     locked?: boolean;
+    /**
+     * Validate a committed value before it is written to the row. Return an error message to
+     * reject the edit (the value is not written and the message is shown), or `null`/`undefined`
+     * to accept it. Runs on inline commit, boolean-checkbox toggle, and sidebar save.
+     *
+     * @example
+     * ```ts
+     * { field: 'email', validate: v => /@/.test(String(v)) ? null : 'Invalid email' }
+     * ```
+     */
+    validate?: (value: T[K], row: T) => string | null | undefined;
     /**
      * Custom cell renderer. Returns an HTML string displayed instead of the plain text value.
      * Angular's built-in HTML sanitization is applied automatically.
@@ -801,12 +1040,26 @@ interface ColDefBase<T extends object, K extends AgridField<T>> {
         value: T[K];
         row: T;
     }) => string;
+    /**
+     * Show a right-aligned info button in this column's cells.
+     * Pass a predicate to show it only for selected rows or values.
+     */
+    infoIcon?: boolean | ((params: {
+        value: T[K];
+        row: T;
+    }) => boolean);
 }
 /**
  * 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;
+/** Parameters passed to a row-aware {@link ColDefBase.inputMask} resolver. */
+interface InputMaskParams<T extends object = any, K extends AgridField<T> = AgridField<T>> {
+    row: T;
+    value: T[K];
+    column: ColDef<T, K>;
+}
 /**
  * Defines a single action shown in the group header's action menu.
  * Pass an array of these to `<agrid [groupActions]="...">`.
@@ -822,7 +1075,8 @@ interface GroupAction {
  * - `{ 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
+ * - `{ groupLabel, count, collapsed, aggregates? }` — group header row when grouping is active
+ *   (`aggregates` holds per-group subtotals when aggregated columns exist)
  * - `{ row, originalIndex, level, expandable, expanded }` — a tree row when tree mode is active
  */
 type GridItem<T extends object = Record<string, unknown>> = {
@@ -832,7 +1086,36 @@ type GridItem<T extends object = Record<string, unknown>> = {
     groupLabel: string;
     count: number;
     collapsed: boolean;
-} | TreeRowItem<T>;
+    aggregates?: Record<string, unknown>;
+} | TreeRowItem<T> | PathTreeNodeItem | DetailRowItem<T>;
+/** A generated, display-only branch node produced by path-based tree data. */
+interface PathTreeNodeItem {
+    /** Stable UUID for this generated branch node. */
+    uuid: string;
+    /** Stable expansion id derived from the complete path to this node. */
+    pathNodeId: string;
+    /** Segment label shown for this branch. */
+    pathLabel: string;
+    /** Zero-based depth in the generated tree. */
+    level: number;
+    /** Path branch nodes always have descendants. */
+    expandable: true;
+    /** Whether the branch's descendants are currently visible. */
+    expanded: boolean;
+}
+/**
+ * A master/detail panel row rendered immediately beneath its expanded parent data row.
+ *
+ * Carries the parent's `originalIndex` (so the panel can be re-collapsed and tracked) and the
+ * parent `row` (passed to `detailRenderer`). It is intentionally *not* a data-row item — selection,
+ * editing, and cell rendering skip it.
+ */
+interface DetailRowItem<T extends object = Record<string, unknown>> {
+    /** Original index of the parent data row this detail panel belongs to. */
+    detailFor: number;
+    /** The parent row's data, passed to `detailRenderer`. */
+    row: T;
+}
 /**
  * A data row rendered inside a hierarchical tree.
  *
@@ -851,14 +1134,15 @@ interface TreeRowItem<T extends object = Record<string, unknown>> {
     expandable: boolean;
     /** `true` when this row is expandable and currently expanded (its children are visible). */
     expanded: boolean;
+    /** Optional display-only label for the tree cell, used by path-based trees. */
+    treeLabel?: string;
 }
 /**
  * Host-supplied configuration that turns the grid into a tree.
  *
- * Hierarchy is expressed over the existing flat row array: every row exposes a stable id and a
- * parent id, so no nested `children` arrays are required and `originalIndex`-based selection and
- * editing keep working unchanged. A row whose `getParentId` is `null`/`undefined` — or whose
- * parent id is not present in the data — is treated as a root.
+ * Hierarchy is expressed over the existing flat row array using either stable id/parent-id
+ * accessors or a path accessor. Path mode creates display-only branch nodes while leaves retain
+ * their original datasource indices, so selection, editing, and persistence remain row-based.
  *
  * @example
  * ```ts
@@ -867,13 +1151,15 @@ interface TreeRowItem<T extends object = Record<string, unknown>> {
  *   getParentId: row => row.managerId,
  *   treeField: 'name',
  * }
+ *
+ * // Or derive branches from a delimited field:
+ * treeConfig: {
+ *   getPath: row => row.oz.split('.'),
+ *   treeField: 'oz',
+ * }
  * ```
  */
-interface AgridTreeConfig<T extends object = any> {
-    /** Return a stable, unique id for a row. Used as the expansion key and for parent lookups. */
-    getId: (row: T) => string | number;
-    /** Return the id of a row's parent, or `null`/`undefined` for a root row. */
-    getParentId: (row: T) => string | number | null | undefined;
+interface AgridTreeConfigBase<T extends object> {
     /** Field whose cell shows the indentation and expand/collapse twisty. */
     treeField: AgridField<T>;
     /** Expand all nodes when the tree first renders. Defaults to `false` (all collapsed). */
@@ -884,6 +1170,66 @@ interface AgridTreeConfig<T extends object = any> {
      */
     keepAncestorsOnFilter?: boolean;
 }
+/** Tree configuration for rows that already expose stable id and parent-id values. */
+interface AgridParentTreeConfig<T extends object = any> extends AgridTreeConfigBase<T> {
+    /** Return a stable, unique id for a row. Used as the expansion key and for parent lookups. */
+    getId: (row: T) => string | number;
+    /** Return the id of a row's parent, or `null`/`undefined` for a root row. */
+    getParentId: (row: T) => string | number | null | undefined;
+    getPath?: never;
+}
+/** Values supplied when formatting one path-tree segment for display. */
+interface AgridPathSegmentParams<T extends object = any> {
+    /** Datasource row that produced this path. Shared branches use the first matching row. */
+    row: T;
+    /** Raw segment returned by `getPath`. */
+    segment: string | number;
+    /** Zero-based position of the segment in the path. */
+    level: number;
+    /** Raw path prefix ending at this segment. */
+    path: readonly (string | number)[];
+    /** Whether this segment represents the datasource-backed leaf row. */
+    leaf: boolean;
+}
+/** Tree configuration that derives display-only branch nodes from each row's path segments. */
+interface AgridPathTreeConfig<T extends object = any> extends AgridTreeConfigBase<T> {
+    /** Return ordered path segments, for example `['01', '01', '0001']`. */
+    getPath: (row: T) => readonly (string | number)[];
+    /**
+     * Return a stable UUID for generated branch nodes created from this row.
+     * Shared branches use the first matching row, matching {@link formatPathSegment}.
+     */
+    nodeUuid?: (row: T) => string | number;
+    /**
+     * Return a stable UUID for generated branch nodes created from this row.
+     * @deprecated Use {@link nodeUuid}. Kept as a compatibility alias for the original typo.
+     */
+    nodeUUid?: (row: T) => string | number;
+    /** Format a segment for display without changing its identity, grouping, or sort order. */
+    formatPathSegment?: (params: AgridPathSegmentParams<T>) => string;
+    getId?: never;
+    getParentId?: never;
+}
+/** Supported tree data modes: explicit parent links or generated path segments. */
+type AgridTreeConfig<T extends object = any> = AgridParentTreeConfig<T> | AgridPathTreeConfig<T>;
+/** Selection behavior for the standalone tree control. */
+type AgridTreeSelectionMode = 'none' | 'single' | 'multi';
+/** Normalized row or generated-branch event emitted by the standalone tree control. */
+interface AgridTreeNodeEvent<T extends object = any> {
+    kind: 'row' | 'branch';
+    id: string | number;
+    uuid?: string;
+    label: string;
+    level: number;
+    expandable: boolean;
+    expanded: boolean;
+    row?: T;
+    originalIndex?: number;
+}
+/** Current standalone-tree selection after a user interaction. */
+interface AgridTreeSelectionEvent<T extends object = any> {
+    nodes: AgridTreeNodeEvent<T>[];
+}
 /** Zero-based position of a cell inside the grid. */
 interface CellPosition {
     /** Zero-based row index in the data array. */
@@ -891,6 +1237,22 @@ interface CellPosition {
     /** Zero-based column index in {@link ColDef} order. */
     colIndex: number;
 }
+/**
+ * Emitted by `(validationFailed)` when a {@link ColDefBase.validate} hook rejects a committed
+ * value. The value is not written to the row.
+ */
+interface ValidationFailedEvent<T extends object = any> {
+    /** Zero-based index of the row whose edit was rejected. */
+    rowIndex: number;
+    /** Field that failed validation. */
+    field: AgridField<T>;
+    /** The rejected value. */
+    value: unknown;
+    /** Message returned by the `validate` hook. */
+    message: string;
+    /** Which editing surface produced the rejected edit. */
+    source: 'inline' | 'sidebar';
+}
 /** Emitted by `(cellEdit)` after the user commits a cell change. */
 type GridEditEvent<T extends object = any> = {
     [K in AgridField<T>]: {
@@ -904,6 +1266,21 @@ type GridEditEvent<T extends object = any> = {
         newValue: T[K];
     };
 }[AgridField<T>];
+/** Emitted when the optional info button inside a cell is clicked. */
+type CellInfoEvent<T extends object = any> = {
+    [K in AgridField<T>]: {
+        /** Datasource row containing the clicked cell. */
+        row: T;
+        /** Column field containing the clicked info button. */
+        field: K;
+        /** Current raw field value. */
+        value: T[K];
+        /** Zero-based index of the row in the datasource. */
+        originalIndex: number;
+        /** Column definition for the clicked cell. */
+        column: ColDef<T, K>;
+    };
+}[AgridField<T>];
 /**
  * Emitted asynchronously after an edit changes a row and the data source has been updated.
  *
@@ -943,6 +1320,21 @@ interface RowClickEvent<T extends object = any> {
     /** Zero-based index of the row in the data source. */
     originalIndex: number;
 }
+/** Emitted when the user clicks or double-clicks a generated path-tree branch node. */
+interface TreeNodeClickEvent {
+    /** Stable UUID for the generated branch node. */
+    uuid: string;
+    /** Stable expansion id derived from the complete path to this node. */
+    pathNodeId: string;
+    /** Segment label shown for this branch. */
+    pathLabel: string;
+    /** Zero-based depth in the generated tree. */
+    level: number;
+    /** Whether the branch's descendants are currently visible. */
+    expanded: boolean;
+    /** Snapshot of the generated branch node. */
+    node: PathTreeNodeItem;
+}
 /**
  * Emitted after an inline-edited row is left, or after the user saves through the sidebar editor.
  */
@@ -984,12 +1376,22 @@ interface PageChangeEvent {
     /** Zero-based index of the last row on this page (inclusive). */
     endRow: number;
 }
-/** Emitted when a text filter changes in server-side filtering mode. */
+/** Emitted when a header text filter or column-menu condition changes server-side. */
 interface FilterChangeEvent {
     /** Field name of the filtered column. */
     field: string;
-    /** Current filter text. An empty string clears the filter. */
+    /** Current free-text filter value. An empty string clears the text filter. */
     value: string;
+    /**
+     * Text, number, or date condition operator from the column-menu UI.
+     * `null` clears the condition.
+     * When set, `value` is empty and the operands live in {@link operand} / {@link operand2}.
+     */
+    operator?: FilterOperator | null;
+    /** Primary condition operand. Present with {@link operator}. */
+    operand?: string | null;
+    /** Upper-bound operand, present only when {@link operator} is `'between'`. */
+    operand2?: string | null;
 }
 /** Emitted when a sort changes in server-side filtering mode. */
 interface SortChangeEvent {
@@ -1048,10 +1450,9 @@ type CellRange = {
     focus: CellPosition;
 };
 
-/** Location of a formatted-value match in source and display coordinates. @internal */
+/** Location of a formatted-value match in source coordinates. @internal */
 type AgridFindMatch = {
     rowIndex: number;
-    displayIndex: number;
     colIndex: number;
 };
 
@@ -1207,10 +1608,12 @@ interface AgridSidebarDetailField {
  * |-----|--------|
  * | Arrow keys | Move selection |
  * | Tab / Shift+Tab | Move right / left (wraps rows) |
- * | Enter / F2 | Enter edit mode |
+ * | Enter | Enter edit mode |
+ * | Ctrl/Cmd+Enter | Toggle an expandable tree node |
+ * | F2 | Enter edit mode |
  * | Printable key | Enter edit mode with seeded character |
- * | Escape | Cancel edit |
- * | Tab / Enter (while editing) | Commit and move right / down |
+ * | 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> {
     /** Grid provider containing columns, data source, control, and options. */
@@ -1227,8 +1630,12 @@ declare class AgridComponent<T extends object = any> {
     readonly autoOpenDetail: Signal<boolean>;
     readonly serverSideFiltering: Signal<boolean>;
     readonly filterDebounceMs: Signal<number>;
+    readonly enableQuickFilter: Signal<boolean>;
+    readonly menuBarItems: Signal<AgridMenuBarItem<T>[]>;
+    readonly quickFilterValue: Signal<string>;
     readonly sortOption: Signal<"single" | "multi" | "none">;
     readonly rowSelection: Signal<"single" | "multi" | "none">;
+    readonly enterEditAction: Signal<_thkl_agrid.AgridEnterEditAction>;
     readonly groupDescription: Signal<((label: string) => string) | null>;
     readonly groupActions: Signal<GroupAction[]>;
     readonly cellMenuItems: Signal<(CellContextMenuItem<T> | null)[]>;
@@ -1241,10 +1648,28 @@ declare class AgridComponent<T extends object = any> {
     readonly loading: Signal<boolean>;
     readonly emptyText: Signal<string | undefined>;
     readonly useSidebarEditor: Signal<boolean>;
+    /** Host callback for per-row CSS classes, or `undefined`. */
+    readonly rowClassFn: Signal<((params: {
+        row: Record<string, unknown>;
+        index: number;
+    }) => string) | undefined>;
+    /** Host callback designating pinned rows, or `undefined`. */
+    readonly pinRowFn: Signal<((row: Record<string, unknown>, index: number) => "top" | "bottom" | undefined) | undefined>;
+    /**
+     * Effective pin resolver fed to the projection: a runtime UI override wins (including an explicit
+     * `null` unpin), otherwise the provider `pinRow` predicate decides. Returns `undefined` when
+     * neither pinning source is active, so the projection's pinning path stays off.
+     */
+    readonly effectivePinRow: Signal<((row: Record<string, unknown>, index: number) => "top" | "bottom" | undefined) | undefined>;
+    /** Whether master/detail is enabled and applicable (flat rows or tree leaves; not grouped). */
+    readonly masterDetail: Signal<boolean>;
+    /** Fixed detail-panel height in pixels. */
+    readonly detailRowHeight: Signal<number>;
     /** 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>>;
+    private readonly treeParentIds;
     /** 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. */
@@ -1271,6 +1696,10 @@ declare class AgridComponent<T extends object = any> {
     rowDoubleClicked: _angular_core.OutputEmitterRef<RowClickEvent<T>>;
     /** Emitted when the user single-clicks a data row. */
     rowClick: _angular_core.OutputEmitterRef<RowClickEvent<T>>;
+    /** Emitted when the user single-clicks a generated path-tree branch node. */
+    treeNodeClick: _angular_core.OutputEmitterRef<TreeNodeClickEvent>;
+    /** Emitted when the user double-clicks a generated path-tree branch node. */
+    treeNodeDoubleClicked: _angular_core.OutputEmitterRef<TreeNodeClickEvent>;
     /**
      * Emitted once after a changed row is left during inline editing, or when the sidebar editor
      * save button is used.
@@ -1286,10 +1715,30 @@ declare class AgridComponent<T extends object = any> {
     filterChange: _angular_core.OutputEmitterRef<FilterChangeEvent>;
     /** Emitted when a column sort changes in server-side filtering mode. */
     sortChange: _angular_core.OutputEmitterRef<SortChangeEvent>;
+    /**
+     * Emitted (debounced) when the global quick-filter text changes in server-side filtering mode.
+     * The host should refetch rows matching the text. Not emitted in client mode, where the grid
+     * filters locally.
+     */
+    quickFilterChange: _angular_core.OutputEmitterRef<string>;
+    /** Emitted when a `ColDef.validate` hook rejects a committed value (inline or sidebar). */
+    validationFailed: _angular_core.OutputEmitterRef<ValidationFailedEvent<any>>;
+    /** Emitted when a column's optional cell information button is clicked. */
+    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>;
     /** 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;
+    /**
+     * Runtime per-row pin overrides set through the UI (keyed by original index). A `null` value
+     * explicitly unpins a row that the `pinRow` predicate would otherwise pin. Merged with the
+     * provider predicate by {@link effectivePinRow}.
+     */
+    private readonly _pinnedRows;
     private readonly markedIndices;
     /** Original datasource indices marked for inclusion in copy operations. */
     readonly markedRowIndices: Signal<ReadonlySet<number>>;
@@ -1299,6 +1748,8 @@ declare class AgridComponent<T extends object = any> {
     readonly deleteConfirmationWidth: _angular_core.WritableSignal<number>;
     /** 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. */
+    readonly isCellEditableForRow: (col: ColDef, originalIndex: number) => boolean;
     /** 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`. */
@@ -1307,6 +1758,8 @@ declare class AgridComponent<T extends object = any> {
     get currentDraft(): _angular_core.WritableSignal<unknown>;
     /** Seed character typed to enter edit mode (e.g. pressing 'A'). */
     get editSeedChar(): _angular_core.WritableSignal<string>;
+    /** Whether the active text editor should select all text when it opens. */
+    get selectTextOnEdit(): _angular_core.WritableSignal<boolean>;
     /** Toggle the sidebar open/closed. */
     toggleSidebar(): void;
     /** @internal */
@@ -1382,7 +1835,7 @@ declare class AgridComponent<T extends object = any> {
     readonly showPagination: Signal<boolean>;
     /** Number of semantic header rows currently rendered. */
     readonly headerRowCount: Signal<1 | 2>;
-    /** Number of rendered semantic rows, including header rows. */
+    /** Number of rendered semantic rows, including header and pinned rows. */
     readonly ariaRowCount: Signal<number>;
     /** Number of visible semantic columns, including the optional control column. */
     readonly ariaColCount: Signal<number>;
@@ -1412,6 +1865,26 @@ declare class AgridComponent<T extends object = any> {
     /** 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[]>;
+    /** Rows pinned to the top of the body (rendered in a fixed container, outside virtual scroll). */
+    readonly pinnedTopItems: Signal<{
+        row: Record<string, unknown>;
+        originalIndex: number;
+    }[]>;
+    /** Rows pinned to the bottom of the body (rendered in a fixed container, outside virtual scroll). */
+    readonly pinnedBottomItems: Signal<{
+        row: Record<string, unknown>;
+        originalIndex: number;
+    }[]>;
+    /** Whether any top-pinned rows are present. */
+    readonly hasPinnedTopRows: Signal<boolean>;
+    /** Whether any bottom-pinned rows are present. */
+    readonly hasPinnedBottomRows: Signal<boolean>;
+    /**
+     * Per-item heights fed to the variable-size virtual-scroll strategy: a detail panel uses the
+     * configured detail height, every other row uses the standard row height. With no detail rows
+     * open the array is uniform, so scrolling matches the fixed-size strategy.
+     */
+    readonly itemSizes: Signal<number[]>;
     readonly groupActionsMenu: _angular_core.WritableSignal<{
         x: number;
         y: number;
@@ -1452,8 +1925,16 @@ declare class AgridComponent<T extends object = any> {
     readonly selectedRowIndex: Signal<number | null>;
     readonly contextMenu: _angular_core.WritableSignal<AgridRowContextMenu | null>;
     readonly cellContextMenuState: _angular_core.WritableSignal<AgridCellContextMenu | null>;
+    /** 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>>;
+    /** Menu-bar buttons currently allowed by their visibility resolvers. */
+    readonly visibleMenuBarItems: Signal<AgridMenuBarItem<T>[]>;
     private readonly sidebarController;
     readonly sidebarOpen: _angular_core.WritableSignal<boolean>;
+    /** @internal Per-field sidebar validation messages. */
+    readonly sidebarValidationErrors: _angular_core.WritableSignal<Record<string, string>>;
     readonly sidebarTab: _angular_core.WritableSignal<"columns" | "detail">;
     readonly sidebarRow: Signal<Record<string, unknown> | null>;
     readonly sidebarHiddenColumns: Signal<ReadonlySet<string>>;
@@ -1475,6 +1956,7 @@ declare class AgridComponent<T extends object = any> {
     getColDropSide(field: string): 'before' | 'after' | null;
     /** @internal Horizontal animation offset for a header during column reordering. */
     getColReorderOffset(field: string): number;
+    hasContextMenuEntries(): boolean;
     private readonly _seededControls;
     private readonly dirtyInlineRows;
     private dirtyRowsDataSource;
@@ -1505,7 +1987,34 @@ declare class AgridComponent<T extends object = any> {
         collapsed: boolean;
     };
     /** @internal */
+    isPathTreeNodeItem(item: GridItem): boolean;
+    /** @internal */
     getItemOriginalIndex(item: GridItem): number | null;
+    /** @internal True when the item is a master/detail panel row. */
+    isDetailRowItem(item: GridItem): item is DetailRowItem;
+    /** @internal Rendered pixel height of a virtual-scroll item (detail panels are taller). */
+    rowPx(item: GridItem): number;
+    /** @internal Resolved HTML for an expanded detail panel (auto-sanitized by `[innerHTML]`). */
+    detailHtml(item: GridItem): string;
+    /** @internal 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. */
+    isDetailExpanded(originalIndex: number): boolean;
+    /** @internal Whether a data row may show a master/detail panel. */
+    canToggleDetail(item: GridItem): boolean;
+    /** Toggle the master/detail panel for a row by its original (data-source) index. */
+    toggleDetail(originalIndex: number): void;
+    /** @internal Template handler for the detail expander chevron. */
+    onDetailToggle(originalIndex: number): void;
+    /** Effective pin position of a row (`'top'`, `'bottom'`, or `undefined`). */
+    rowPinState(originalIndex: number): 'top' | 'bottom' | undefined;
+    /**
+     * Pin a row to the top or bottom of the body, or unpin it with `null`.
+     * Keyed by the row's original (data-source) index; the pinned row stays fully interactive.
+     */
+    pinRowTo(originalIndex: number, position: 'top' | 'bottom' | null): void;
+    /** @internal Template handler for the pin/unpin context-menu items; closes the open menus. */
+    onPinRow(originalIndex: number, position: 'top' | 'bottom' | null): void;
     /** @internal True when `col` is the configured tree column. */
     isTreeCell(col: ColDef): boolean;
     /** @internal Tree depth of a row item (0 when not a tree row). */
@@ -1514,8 +2023,22 @@ declare class AgridComponent<T extends object = any> {
     treeRowExpandable(item: GridItem): boolean;
     /** @internal Whether a tree row is currently expanded. */
     treeRowExpanded(item: GridItem): boolean;
+    /** @internal Display-only final path segment for a datasource-backed path-tree leaf. */
+    treeCellDisplayOverride(item: GridItem, col: ColDef): string | null;
+    /** @internal Whether the configured info action is visible for this cell. */
+    showCellInfoIcon(col: ColDef, row: Record<string, unknown>): boolean;
+    /** @internal Emits the typed cell information action. */
+    onCellInfo(originalIndex: number, col: ColDef, row: Record<string, unknown>): void;
+    /** @internal Label of a generated path-tree branch. */
+    pathTreeLabel(item: GridItem): string;
     /** @internal Toggle the expand/collapse state of a tree row from its twisty. */
     onTreeToggle(item: GridItem): void;
+    /** @internal Emits the generated path-tree branch click event. */
+    onTreeNodeClick(item: GridItem): void;
+    /** @internal Emits the generated path-tree branch double-click event. */
+    onTreeNodeDoubleClick(item: GridItem): void;
+    private toTreeNodeClickEvent;
+    private toggleTreeCell;
     /** Expand every expandable node in the tree. No-op when not in tree mode. */
     expandAllNodes(): void;
     /** Collapse every node in the tree. No-op when not in tree mode. */
@@ -1540,6 +2063,22 @@ declare class AgridComponent<T extends object = any> {
     /** @internal Whether more than one column is currently sorted. */
     hasMultiSort(): boolean;
     getTextFilter(field: string): string;
+    /** @internal Condition input type for a column, or `null` when unsupported. */
+    getMenuFilterType(field: string): 'text' | 'number' | 'date' | null;
+    /** @internal Short label for an active header condition. */
+    getConditionButtonLabel(field: string): string;
+    /** @internal */
+    getMenuOperator(field: string): FilterOperator | null;
+    /** @internal */
+    getMenuOperand(field: string): string;
+    /** @internal */
+    getMenuOperand2(field: string): string;
+    /** @internal */
+    onMenuOperatorChange(field: string, operator: FilterOperator | null): void;
+    /** @internal */
+    onMenuOperandChange(field: string, value: string): void;
+    /** @internal */
+    onMenuOperand2Change(field: string, value: string): void;
     /** @internal */
     getSort(field: string): 'asc' | 'desc' | null;
     /** @internal */
@@ -1583,6 +2122,18 @@ declare class AgridComponent<T extends object = any> {
     onStartEdit(originalIndex: number, ci: number): void;
     /** @internal */
     onDraftChange(value: unknown): void;
+    private quickFilterTimer;
+    /**
+     * @internal Quick-filter input handler. Stores the text on the control (drives the bound value
+     * and client-side filtering) and, in server mode, emits a debounced `quickFilterChange` instead.
+     */
+    onQuickFilterInput(event: Event): void;
+    /** @internal Whether a column is editable in the current grid state (drives boolean checkboxes). */
+    isColEditable(col: ColDef, originalIndex?: number): boolean;
+    /** @internal Inline validation message for a cell, or `null` when the cell has no active error. */
+    cellValidationError(originalIndex: number, ci: number): string | null;
+    /** @internal Commit a boolean-column checkbox toggle directly to the data source. */
+    onBooleanToggle(originalIndex: number, ci: number, value: boolean): 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. */
@@ -1597,6 +2148,7 @@ declare class AgridComponent<T extends object = any> {
     onFindInput(value: string): void;
     /** @internal */
     goToFindMatch(direction: 1 | -1): void;
+    private revealFindMatch;
     /** @internal Ghost cell display during a reorder drag. */
     getGhostCellDisplay(col: ColDef): string;
     /** @internal Delegates to AgridDragHandler. */
@@ -1627,6 +2179,30 @@ declare class AgridComponent<T extends object = any> {
     onCellContextMenu(event: MouseEvent, rowIndex: number, colIndex: number, col: ColDef, row: Record<string, unknown>): void;
     /** @internal */
     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 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. */
@@ -1723,9 +2299,136 @@ 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"; "rowChanged": "rowChanged"; "pageChange": "pageChange"; "filterChange": "filterChange"; "sortChange": "sortChange"; }, 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"; "rowDoubleClicked": "rowDoubleClicked"; "rowClick": "rowClick"; "treeNodeClick": "treeNodeClick"; "treeNodeDoubleClicked": "treeNodeDoubleClicked"; "rowChanged": "rowChanged"; "pageChange": "pageChange"; "filterChange": "filterChange"; "sortChange": "sortChange"; "quickFilterChange": "quickFilterChange"; "validationFailed": "validationFailed"; "cellInfo": "cellInfo"; "menuBarAction": "menuBarAction"; }, never, never, true, never>;
+}
+
+/** Identifier supported by the standalone page selector. */
+type AgridPageId = string | number;
+/** One selectable page. IDs must be unique within the item list. */
+interface AgridPageItem<TId extends AgridPageId = AgridPageId> {
+    id: string;
+    pageNumber: TId;
+    label: string;
+}
+/** Compact previous/input/dropdown/next control for navigating a labeled page list. */
+declare class AgridPageSelectorComponent<TId extends AgridPageId = AgridPageId> {
+    private readonly elementRef;
+    readonly listboxId: string;
+    items: _angular_core.InputSignal<readonly AgridPageItem<TId>[]>;
+    selectedId: _angular_core.InputSignal<string | null>;
+    selectedPageNumber: _angular_core.InputSignal<TId | null>;
+    disabled: _angular_core.InputSignal<boolean>;
+    previousLabel: _angular_core.InputSignal<string>;
+    nextLabel: _angular_core.InputSignal<string>;
+    inputLabel: _angular_core.InputSignal<string>;
+    menuLabel: _angular_core.InputSignal<string>;
+    emptyText: _angular_core.InputSignal<string>;
+    selectPage: _angular_core.OutputEmitterRef<AgridPageItem<TId>>;
+    readonly menuOpen: _angular_core.WritableSignal<boolean>;
+    readonly draft: _angular_core.WritableSignal<string>;
+    readonly invalid: _angular_core.WritableSignal<boolean>;
+    readonly activeId: _angular_core.WritableSignal<string | null>;
+    readonly focusedOptionIndex: _angular_core.WritableSignal<number>;
+    readonly activeIndex: _angular_core.Signal<number>;
+    readonly hasPrevious: _angular_core.Signal<boolean>;
+    readonly hasNext: _angular_core.Signal<boolean>;
+    constructor();
+    previous(): void;
+    next(): void;
+    toggleMenu(event: Event): void;
+    openMenu(): void;
+    closeMenu(): void;
+    onInput(event: Event): void;
+    onInputKeydown(event: KeyboardEvent): void;
+    choose(item: AgridPageItem<TId>): void;
+    optionId(index: number): string;
+    isSelected(item: AgridPageItem<TId>): boolean;
+    onDocumentPointerDown(event: PointerEvent): void;
+    private selectDraft;
+    private resetDraft;
+    private moveOption;
+    private scrollFocusedOptionIntoView;
+    private idsEqual;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AgridPageSelectorComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AgridPageSelectorComponent<any>, "agrid-page-selector", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "selectedId": { "alias": "selectedId"; "required": false; "isSignal": true; }; "selectedPageNumber": { "alias": "selectedPageNumber"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "previousLabel": { "alias": "previousLabel"; "required": false; "isSignal": true; }; "nextLabel": { "alias": "nextLabel"; "required": false; "isSignal": true; }; "inputLabel": { "alias": "inputLabel"; "required": false; "isSignal": true; }; "menuLabel": { "alias": "menuLabel"; "required": false; "isSignal": true; }; "emptyText": { "alias": "emptyText"; "required": false; "isSignal": true; }; }, { "selectPage": "selectPage"; }, never, never, true, never>;
+}
+
+/** Configuration accepted by {@link AgridTreeProvider}. */
+interface AgridTreeProviderConfig<T extends object> {
+    datasource: AgridDataSource<T>;
+    treeConfig: AgridTreeConfig<T>;
+    /** Label for parent-linked rows. Defaults to the configured `treeField` value. */
+    getLabel?: (row: T) => string;
+    /** Optional secondary text shown beneath a row label. */
+    getDescription?: (row: T) => string | undefined;
+    /** Selection behavior. Defaults to `single`. */
+    selection?: AgridTreeSelectionMode;
+    /** Fixed node height in pixels. Defaults to `36`. */
+    rowHeight?: number;
+    /** Accessible name for the tree. Defaults to `Tree`. */
+    ariaLabel?: string;
+    /** Text shown when the datasource is empty. */
+    emptyText?: string;
+}
+/** Provider-style configuration and datasource container for `<agrid-tree>`. */
+declare class AgridTreeProvider<T extends object = any> {
+    readonly datasource: AgridDataSource<T>;
+    readonly treeConfig: AgridTreeConfig<T>;
+    readonly getLabel?: (row: T) => string;
+    readonly getDescription?: (row: T) => string | undefined;
+    readonly selection: AgridTreeSelectionMode;
+    readonly rowHeight: number;
+    readonly ariaLabel: string;
+    readonly emptyText: string;
+    constructor(config: AgridTreeProviderConfig<T>);
+}
+
+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>>;
+    nodeClick: _angular_core.OutputEmitterRef<AgridTreeNodeEvent<T>>;
+    nodeDoubleClicked: _angular_core.OutputEmitterRef<AgridTreeNodeEvent<T>>;
+    selectionChange: _angular_core.OutputEmitterRef<AgridTreeSelectionEvent<T>>;
+    private readonly treeController;
+    private readonly treeElement;
+    private initializedProvider;
+    readonly focusedIndex: _angular_core.WritableSignal<number>;
+    readonly selectedKeys: _angular_core.WritableSignal<Set<string>>;
+    readonly expandedIds: _angular_core.WritableSignal<Set<string | number>>;
+    readonly items: _angular_core.Signal<StandaloneTreeItem<T>[]>;
+    constructor();
+    /** Expands every branch currently represented by the datasource. */
+    expandAllNodes(): void;
+    /** Collapses every branch. */
+    collapseAllNodes(): void;
+    /** Toggles one expandable node. */
+    toggleNode(item: StandaloneTreeItem<T>): void;
+    /** @internal */
+    label(item: StandaloneTreeItem<T>): string;
+    /** @internal */
+    description(item: StandaloneTreeItem<T>): string | undefined;
+    /** @internal */
+    isSelected(item: StandaloneTreeItem<T>): boolean;
+    /** @internal */
+    onNodeClick(event: MouseEvent, item: StandaloneTreeItem<T>, index: number): void;
+    /** @internal */
+    onNodeDoubleClick(event: MouseEvent, item: StandaloneTreeItem<T>): void;
+    /** @internal */
+    onKeydown(event: KeyboardEvent, item: StandaloneTreeItem<T>, index: number): void;
+    /** @internal */
+    trackItem(_index: number, item: StandaloneTreeItem<T>): string;
+    private select;
+    private toEvent;
+    private expansionId;
+    private selectionKey;
+    private moveFocus;
+    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>;
 }
 
-export { AGRID_LOCALE_TEXT, AgridComponent, AgridControl, AgridDataSource, AgridProvider, ColDefAutoSize };
-export type { AgridControlState, AgridField, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridProviderConfig, AgridTreeConfig, CellContextMenuItem, CellPosition, ColDef, FilterChangeEvent, GridEditEvent, GroupAction, HeaderGroup, HistoryEntry, HistoryItem, NewRecord, PageChangeEvent, RecordEditEvent, RowClickEvent, RowRemovedEvent, RowReorderEvent, RowSelectEvent, RowUpdateEvent, SortChangeEvent, TreeRowItem, ValueOption };
+export { AGRID_LOCALE_TEXT, AgridComponent, AgridControl, AgridDataSource, AgridPageSelectorComponent, AgridProvider, AgridTreeComponent, AgridTreeProvider, ColDefAutoSize };
+export type { AgridControlState, AgridEnterEditAction, AgridField, AgridLocaleKey, AgridLocaleText, AgridLocaleTextOverrides, AgridMenuBarContext, AgridMenuBarItem, AgridMenuBarMenuItem, AgridMenuBarState, AgridPageId, AgridPageItem, AgridParentTreeConfig, AgridPathSegmentParams, AgridPathTreeConfig, AgridProviderConfig, AgridTreeConfig, AgridTreeNodeEvent, AgridTreeProviderConfig, AgridTreeSelectionEvent, AgridTreeSelectionMode, CellContextMenuItem, CellInfoEvent, CellPosition, CellReadonlyParams, ColDef, ColumnFilter, DetailRowItem, FilterChangeEvent, FilterOperator, GridEditEvent, GroupAction, HeaderGroup, HistoryEntry, HistoryItem, InputMaskParams, NewRecord, PageChangeEvent, PathTreeNodeItem, RecordEditEvent, RowClickEvent, RowRemovedEvent, RowReorderEvent, RowSelectEvent, RowUpdateEvent, SortChangeEvent, TreeNodeClickEvent, TreeRowItem, ValidationFailedEvent, ValueOption };
 //# sourceMappingURL=thkl-agrid.d.ts.map