@toolbox-web/grid-angular 1.9.1 → 2.0.0-beta.1

package/types/toolbox-web-grid-angular.d.ts

@@ -1,10 +1,9 @@
 import * as _angular_core from '@angular/core';
-import { Type, EnvironmentInjector, ApplicationRef, ViewContainerRef, ComponentRef, TemplateRef, EmbeddedViewRef, InjectionToken, EnvironmentProviders, Signal, ElementRef, OnInit, OnDestroy, AfterContentInit } from '@angular/core';
-import { GridConfig as GridConfig$1, ColumnConfig as ColumnConfig$1, TypeDefault as TypeDefault$1, FrameworkAdapter, ColumnViewRenderer, ColumnEditorSpec, GridIcons, DataGridElement, FeatureConfig, ExpandCollapseAnimation, FitMode, ColumnInferenceMode, CellClickDetail, RowClickDetail, CellActivateDetail, CellChangeDetail, SortChangeDetail, ColumnResizeDetail, GridColumnState, TbwScrollDetail, DataGridEventMap } from '@toolbox-web/grid';
+import { Type, EnvironmentInjector, ApplicationRef, ViewContainerRef, ComponentRef, TemplateRef, EmbeddedViewRef, InjectionToken, EnvironmentProviders, Signal, OnInit, AfterContentInit, OnDestroy } from '@angular/core';
+import { GridConfig as GridConfig$1, ColumnConfig as ColumnConfig$1, ColumnEditorSpec, TypeDefault as TypeDefault$1, FrameworkAdapter, ColumnViewRenderer, GridIcons, DataGridElement, FeatureConfig, ColumnShorthand, FitMode, ColumnInferenceMode, CellClickDetail, RowClickDetail, CellActivateDetail, CellChangeDetail, SortChangeDetail, ColumnResizeDetail, GridColumnState, TbwScrollDetail, DataGridEventMap } from '@toolbox-web/grid';
+export { ColumnShorthand, applyColumnDefaults, hasColumnShorthands, normalizeColumns, parseColumnShorthand } from '@toolbox-web/grid';
 import { FilterPanelRenderer, FilterPanelParams } from '@toolbox-web/grid/plugins/filtering';
-import { AbstractControl, ControlValueAccessor, FormArray, FormGroup } from '@angular/forms';
-import { EditingConfig, CellCancelDetail, EditOpenDetail, BeforeEditCloseDetail, EditCloseDetail, DirtyChangeDetail, ChangedRowsResetDetail } from '@toolbox-web/grid/plugins/editing';
-import { SelectionConfig, ClipboardConfig, ContextMenuConfig, MultiSortConfig, FilterConfig, ReorderConfig, VisibilityConfig, GroupingColumnsConfig, ColumnVirtualizationConfig, RowReorderConfig, RowDragDropConfig, GroupingRowsConfig, PinnedRowsConfig, TreeConfig, MasterDetailConfig, ResponsivePluginConfig, UndoRedoConfig, ExportConfig, PrintConfig, PivotConfig, ServerSideConfig, TooltipConfig, DataChangeDetail, FilterChangeDetail, ColumnResizeResetDetail, ColumnMoveDetail, ColumnVisibilityDetail, SelectionChangeDetail, RowMoveDetail, RowDragStartDetail, RowDragEndDetail, RowDropDetail, RowTransferDetail, GroupToggleDetail, GroupExpandDetail, GroupCollapseDetail, TreeExpandDetail, DetailExpandDetail, ResponsiveChangeDetail, ContextMenuOpenDetail, CopyDetail, PasteDetail, UndoRedoDetail, ExportCompleteDetail, PrintStartDetail, PrintCompleteDetail, RenderDetail } from '@toolbox-web/grid/all';
+import { DataChangeDetail, ColumnResizeResetDetail, RenderDetail } from '@toolbox-web/grid/all';
 export { PluginFactory, clearFeatureRegistry, createPluginFromFeature, getFeatureFactory, getRegisteredFeatures, isFeatureRegistered, registerFeature } from '@toolbox-web/grid/features/registry';
 
 /**
@@ -356,6 +355,26 @@ type RowRendererBridge = <TRow = unknown>(gridElement: HTMLElement, adapter: Gri
  * @since 1.4.0
  */
 type FilterPanelTypeDefaultBridge = (rendererValue: unknown, adapter: GridAdapter) => NonNullable<TypeDefault$1['filterPanelRenderer']> | undefined;
+/**
+ * Installer signature for the template-based cell editor. Given a column/editor
+ * light-DOM element + adapter, returns the `ColumnEditorSpec` the grid should
+ * use, or undefined if no Angular editor template (`*tbwEditor` /
+ * `<tbw-grid-column-editor>`) is registered for that element. Installed by
+ * `@toolbox-web/grid-angular/features/editing`; without it, template-based
+ * editors are not resolved (component-class editors are unaffected).
+ * @internal
+ * @since 3.0.0
+ */
+type EditorSpecBridge = <TRow = unknown, TValue = unknown>(element: HTMLElement, adapter: GridAdapter) => ColumnEditorSpec<TRow, TValue> | undefined;
+/**
+ * Installer signature for the tool-panel renderer. Given a tool-panel
+ * light-DOM element + adapter, returns the imperative renderer the grid should
+ * use, or undefined if no Angular tool-panel template is registered. Installed
+ * by `@toolbox-web/grid-angular/features/shell`.
+ * @internal
+ * @since 3.0.0
+ */
+type ToolPanelRendererBridge = (element: HTMLElement, adapter: GridAdapter) => ((container: HTMLElement) => void | (() => void)) | undefined;
 /**
  * Install the master-detail row-renderer bridge. Called once on import by
  * `@toolbox-web/grid-angular/features/master-detail`.
@@ -379,6 +398,20 @@ declare function registerResponsiveCardRendererBridge(bridge: RowRendererBridge)
  * @since 1.4.0
  */
 declare function registerFilterPanelTypeDefaultBridge(bridge: FilterPanelTypeDefaultBridge): void;
+/**
+ * Install the template-based editor bridge. Called once on import by
+ * `@toolbox-web/grid-angular/features/editing`.
+ * @internal Plugin API
+ * @since 3.0.0
+ */
+declare function registerEditorSpecBridge(bridge: EditorSpecBridge): void;
+/**
+ * Install the tool-panel renderer bridge. Called once on import by
+ * `@toolbox-web/grid-angular/features/shell`.
+ * @internal Plugin API
+ * @since 3.0.0
+ */
+declare function registerToolPanelRendererBridge(bridge: ToolPanelRendererBridge): void;
 
 /** @since 0.11.0 */
 declare class GridAdapter implements FrameworkAdapter {
@@ -454,7 +487,8 @@ declare class GridAdapter implements FrameworkAdapter {
     processColumn<TRow = unknown>(column: ColumnConfig<TRow>): ColumnConfig$1<TRow>;
     /**
      * Determines if this adapter can handle the given element.
-     * Checks if a template is registered for this element (structural or nested).
+     * Checks if a template is registered for this element (structural or nested
+     * view template, or a template-based editor resolved by the editing feature).
      */
     canHandle(element: HTMLElement): boolean;
     /**
@@ -507,8 +541,10 @@ declare class GridAdapter implements FrameworkAdapter {
      */
     parseResponsiveCardElement<TRow = unknown>(cardElement: Element): ((row: TRow, rowIndex: number) => HTMLElement) | undefined;
     /**
-     * Creates a tool panel renderer from a light DOM element.
-     * The renderer creates an Angular template-based panel content.
+     * Creates a tool panel renderer from a light DOM element. Tool-panel
+     * templates are owned by `@toolbox-web/grid-angular/features/shell`; delegate
+     * to its bridge, which returns undefined when the feature is not imported or
+     * no tool-panel template is registered for this element.
      */
     createToolPanelRenderer(element: HTMLElement): ((container: HTMLElement) => void | (() => void)) | undefined;
     /**
@@ -610,6 +646,30 @@ declare class GridAdapter implements FrameworkAdapter {
      * @internal
      */
     createTrackedEmbeddedView<TCtx>(template: TemplateRef<TCtx>, context: TCtx): EmbeddedViewRef<TCtx>;
+    /**
+     * Create an editor embedded view from a `TemplateRef`: tracks it in the
+     * per-cell editor pool (swept by `releaseCell()` when the grid recycles the
+     * cell), wraps its root nodes in a stable `display:contents` span, and runs
+     * the registered editor-mount hooks against that span. Public so the editing
+     * feature secondary entry can mount `*tbwEditor` / `<tbw-grid-column-editor>`
+     * templates without reaching into the adapter's private view pools or
+     * mount-hook fan-out.
+     * @internal
+     * @since 3.0.0
+     */
+    createEditorTemplateView<TCtx>(template: TemplateRef<TCtx>, context: TCtx): {
+        container: HTMLElement;
+        viewRef: EmbeddedViewRef<TCtx>;
+    };
+    /**
+     * Re-sync an editor embedded view's root nodes into its `display:contents`
+     * container after an external `detectChanges()` (Angular control flow may
+     * have added/removed nodes). Public for the editing feature's external
+     * value-change handler.
+     * @internal
+     * @since 3.0.0
+     */
+    syncEditorTemplateView(viewRef: EmbeddedViewRef<unknown>, container: HTMLElement): void;
     /**
      * Processes a GroupingColumnsConfig. Delegates to the feature config
      * preprocessor installed by `@toolbox-web/grid-angular/features/grouping-columns`,
@@ -1057,3037 +1117,588 @@ declare function injectGrid<TRow = unknown>(selector?: string): InjectGridReturn
  *
  * @since 0.6.0
  */
-type FeatureName = Exclude<keyof FeatureConfig, '__brand'>;
+type DerivedFeatureName = Exclude<keyof FeatureConfig, '__brand'>;
+type FeatureName = [DerivedFeatureName] extends [never] ? string : DerivedFeatureName;
 
 /**
- * Base class for Angular filter panel components.
+ * Context object passed to the cell renderer template.
+ * Contains the cell value, row data, and column configuration.
+ * @since 0.1.0
+ */
+interface GridCellContext<TValue = unknown, TRow = unknown> {
+    /** The cell value for this column */
+    $implicit: TValue;
+    /** The cell value (explicit binding) */
+    value: TValue;
+    /** The full row data object */
+    row: TRow;
+    /** The column configuration */
+    column: unknown;
+}
+/**
+ * Directive that captures an `<ng-template>` for use as a cell renderer.
  *
- * Provides a ready-made `params` input and common lifecycle helpers
- * (`applyAndClose`, `clearAndClose`) so consumers only need to implement
- * their filter logic in `applyFilter()`.
+ * This enables declarative Angular component usage with proper input bindings
+ * that satisfy Angular's AOT compiler.
  *
  * ## Usage
  *
- * ```typescript
- * import { Component, viewChild, ElementRef } from '@angular/core';
- * import { BaseFilterPanel } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-text-filter',
- *   template: `
- *     <input #input (keydown.enter)="applyAndClose()" />
- *     <button (click)="applyAndClose()">Apply</button>
- *     <button (click)="clearAndClose()">Clear</button>
- *   `
- * })
- * export class TextFilterComponent extends BaseFilterPanel {
- *   input = viewChild.required<ElementRef<HTMLInputElement>>('input');
- *
- *   applyFilter(): void {
- *     this.params().applyTextFilter('contains', this.input().nativeElement.value);
- *   }
- * }
+ * ```html
+ * <tbw-grid-column field="status">
+ *   <tbw-grid-column-view>
+ *     <ng-template let-value let-row="row">
+ *       <app-status-badge [value]="value" [row]="row" />
+ *     </ng-template>
+ *   </tbw-grid-column-view>
+ * </tbw-grid-column>
  * ```
  *
- * ## Template Syntax
+ * The template context provides:
+ * - `$implicit` / `value`: The cell value
+ * - `row`: The full row data object
+ * - `column`: The column configuration
  *
- * The grid's filtering plugin will mount this component and provide `params`
- * automatically. No manual wiring is required:
+ * Import the directive in your component:
  *
  * ```typescript
- * gridConfig = {
- *   columns: [
- *     { field: 'name', filterable: true, filterPanel: TextFilterComponent },
- *   ],
- * };
- * ```
+ * import { GridColumnView } from '@toolbox-web/grid-angular';
  *
- * @typeParam TRow - The row data type (available via `params().column`)
+ * @Component({
+ *   imports: [GridColumnView],
+ *   // ...
+ * })
+ * ```
  *
- * MOVE-IN-V2: this class will physically move into
- * `@toolbox-web/grid-angular/features/filtering` in v2.0.0; the deprecated
- * re-export from the main `@toolbox-web/grid-angular` entry will be removed at
- * the same time. Consumers should already be importing from the feature entry.
- * @since 0.13.0
+ * @category Directive
+ * @since 0.1.0
  */
-declare abstract class BaseFilterPanel implements FilterPanel {
-    /**
-     * Filter panel parameters injected by the grid's filtering plugin.
-     *
-     * Provides access to:
-     * - `field` — the column field name
-     * - `column` — full column configuration
-     * - `uniqueValues` — distinct values in the column
-     * - `excludedValues` — currently excluded values (set filter)
-     * - `searchText` — current search text
-     * - `applySetFilter(excluded)` — apply a set-based (include/exclude) filter
-     * - `applyTextFilter(operator, value, valueTo?)` — apply a text/number filter
-     * - `clearFilter()` — clear the filter for this column
-     * - `closePanel()` — close the filter panel
-     */
-    readonly params: _angular_core.InputSignal<FilterPanelParams>;
-    /**
-     * Implement this to apply your filter logic.
-     *
-     * Called by {@link applyAndClose} before closing the panel.
-     * Use `this.params()` to access the filter API.
-     *
-     * @example
-     * ```typescript
-     * applyFilter(): void {
-     *   this.params().applyTextFilter('contains', this.searchText);
-     * }
-     * ```
-     */
-    abstract applyFilter(): void;
+declare class GridColumnView {
+    private elementRef;
     /**
-     * Apply the filter then close the panel.
-     *
-     * Calls {@link applyFilter} followed by `params().closePanel()`.
-     * Bind this to your "Apply" button or Enter key handler.
+     * Query for the ng-template content child.
      */
-    applyAndClose(): void;
+    template: _angular_core.Signal<TemplateRef<any> | undefined>;
+    /** Effect that triggers when the template is available */
+    private onTemplateReceived;
     /**
-     * Clear the filter then close the panel.
-     *
-     * Calls `params().clearFilter()` followed by `params().closePanel()`.
-     * Bind this to your "Clear" / "Reset" button.
+     * Static type guard for template context.
+     * Enables type inference in templates.
      */
-    clearAndClose(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseFilterPanel, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseFilterPanel, never, never, { "params": { "alias": "params"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+    static ngTemplateContextGuard(dir: GridColumnView, ctx: unknown): ctx is GridCellContext;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridColumnView, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridColumnView, "tbw-grid-column-view", never, {}, {}, ["template"], never, true, never>;
 }
 
 /**
- * Base class for grid cell editors.
+ * Directive that registers `<tbw-grid-column>` as a known Angular element.
  *
- * Provides common functionality for Angular cell editors:
- * - Automatic value resolution from FormControl or value input
- * - Common inputs (value, row, column, control)
- * - Common outputs (commit, cancel)
- * - Validation state helpers
+ * This directive exists so that Angular's template compiler recognises
+ * `<tbw-grid-column>` without requiring `CUSTOM_ELEMENTS_SCHEMA`.
+ * The underlying web component reads its attributes (`field`, `header`,
+ * `type`, `width`, etc.) directly from the DOM, so no `@Input()` forwarding
+ * is needed — Angular's standard property/attribute binding handles it.
  *
  * ## Usage
  *
  * ```typescript
  * import { Component } from '@angular/core';
- * import { BaseGridEditor } from '@toolbox-web/grid-angular';
+ * import { Grid, TbwGridColumn, TbwRenderer } from '@toolbox-web/grid-angular';
  *
  * @Component({
- *   selector: 'app-my-editor',
- *   template: \`
- *     <input
- *       [value]="currentValue()"
- *       [class.is-invalid]="isInvalid()"
- *       (input)="commitValue($event.target.value)"
- *       (keydown.escape)="cancelEdit()"
- *     />
- *     @if (hasErrors()) {
- *       <div class="error">{{ firstErrorMessage() }}</div>
- *     }
- *   \`
+ *   imports: [Grid, TbwGridColumn, TbwRenderer],
+ *   template: `
+ *     <tbw-grid [rows]="rows" [gridConfig]="config">
+ *       <tbw-grid-column field="status">
+ *         <app-status-badge *tbwRenderer="let value" [value]="value" />
+ *       </tbw-grid-column>
+ *     </tbw-grid>
+ *   `
  * })
- * export class MyEditorComponent extends BaseGridEditor<MyRow, string> {
- *   // Override to customize error messages
- *   protected override getErrorMessage(errorKey: string): string {
- *     if (errorKey === 'required') return 'This field is required';
- *     if (errorKey === 'minlength') return 'Too short';
- *     return super.getErrorMessage(errorKey);
- *   }
- * }
- * ```
- *
- * ## Template Syntax
- *
- * When using the base class, you only need to pass the control:
- *
- * ```html
- * <tbw-grid-column field="name">
- *   <app-my-editor *tbwEditor="let _; control as control" [control]="control" />
- * </tbw-grid-column>
- * ```
- *
- * Or without FormArray binding (fallback to value):
- *
- * ```html
- * <tbw-grid-column field="name">
- *   <app-my-editor *tbwEditor="let value" [value]="value" />
- * </tbw-grid-column>
+ * export class MyComponent { }
  * ```
  *
- * @typeParam TRow - The row data type
- * @typeParam TValue - The cell value type
- *
- * MOVE-IN-V2: this class will physically move into
- * `@toolbox-web/grid-angular/features/editing` in v2.0.0; the deprecated
- * re-export from the main `@toolbox-web/grid-angular` entry will be removed at
- * the same time. Consumers should already be importing from the feature entry.
- * @since 0.5.0
+ * @category Directive
+ * @since 0.13.0
  */
-declare abstract class BaseGridEditor<TRow = unknown, TValue = unknown> {
-    protected readonly elementRef: ElementRef<any>;
-    private readonly _destroyRef;
-    /** Cleanup function for the edit-close listener */
-    private _editCloseCleanup;
-    /**
-     * The cell value. Used when FormControl is not available.
-     * When a FormControl is provided, value is derived from control.value instead.
-     */
-    readonly value: _angular_core.InputSignal<TValue | undefined>;
-    /**
-     * The full row data object.
-     */
-    readonly row: _angular_core.InputSignal<TRow | undefined>;
-    /**
-     * The column configuration.
-     */
-    readonly column: _angular_core.InputSignal<ColumnConfig$1<TRow> | undefined>;
-    /**
-     * The FormControl for this cell, if the grid is bound to a FormArray.
-     * When provided, the editor uses control.value instead of the value input.
-     */
-    readonly control: _angular_core.InputSignal<AbstractControl<any, any, any> | undefined>;
-    /**
-     * Emits when the user commits a new value.
-     * Emits `null` when a nullable field is cleared.
-     */
-    readonly commit: _angular_core.OutputEmitterRef<TValue | null>;
-    /**
-     * Emits when the user cancels editing.
-     */
-    readonly cancel: _angular_core.OutputEmitterRef<void>;
-    /**
-     * The current value, derived from FormControl if available, otherwise from value input.
-     * This is the recommended way to get the current value in your editor template.
-     */
-    readonly currentValue: _angular_core.Signal<TValue | undefined>;
-    /**
-     * Whether the control is invalid (has validation errors).
-     * Returns false if no FormControl is available.
-     */
-    readonly isInvalid: _angular_core.Signal<boolean>;
-    /**
-     * Whether the control is dirty (has been modified).
-     * Returns false if no FormControl is available.
-     */
-    readonly isDirty: _angular_core.Signal<boolean>;
-    /**
-     * Whether the control has been touched.
-     * Returns false if no FormControl is available.
-     */
-    readonly isTouched: _angular_core.Signal<boolean>;
-    /**
-     * Whether the control has any validation errors.
-     */
-    readonly hasErrors: _angular_core.Signal<boolean>;
-    /**
-     * The first error message from the control's validation errors.
-     * Returns an empty string if no errors.
-     */
-    readonly firstErrorMessage: _angular_core.Signal<string>;
-    /**
-     * All error messages from the control's validation errors.
-     */
-    readonly allErrorMessages: _angular_core.Signal<string[]>;
-    constructor();
-    private _initEditCloseListener;
-    /**
-     * Whether this editor's cell is the currently focused cell.
-     *
-     * In row editing mode the grid creates editors for every editable cell
-     * in the row simultaneously. Use this to conditionally auto-focus inputs
-     * or open panels only in the active cell.
-     *
-     * Performs a synchronous DOM check — safe to call from `ngAfterViewInit`.
-     */
-    protected isCellFocused(): boolean;
-    /**
-     * Called **before** the grid clears editing state and destroys editor DOM.
-     *
-     * At this point the commit callback is still active, so subclasses can
-     * call {@link commitValue} to flush any pending/deferred values.
-     *
-     * This fires only on the **commit** path (not on revert/cancel).
-     * Use {@link onEditClose} for cleanup that should happen on both paths.
-     */
-    protected onBeforeEditClose(): void;
-    /**
-     * Called when the grid ends the editing session for this cell.
-     *
-     * Override to perform cleanup such as closing overlay panels, autocomplete
-     * dropdowns, or other floating UI that lives at `<body>` level and would
-     * otherwise persist after the editor DOM is removed.
-     *
-     * The listener is set up automatically via `afterNextRender` — no manual
-     * wiring required.
-     */
-    protected onEditClose(): void;
-    /**
-     * Called by the grid adapter when the cell value changes externally
-     * (e.g., via `updateRow()` cascade or undo/redo).
-     *
-     * Override in subclasses to reset internal state (search text, selection
-     * flags, etc.) so the editor displays the updated value.
-     *
-     * This runs **synchronously** before the value input is updated, giving
-     * the editor a chance to clear stale state before the next change-detection
-     * pass re-reads the template.
-     *
-     * @param _newVal The new cell value being pushed from the grid
-     */
-    onExternalValueChange(_newVal: TValue): void;
-    /**
-     * Commit a new value. Emits the commit output AND dispatches a DOM event.
-     * The DOM event enables the grid's auto-wiring to catch the commit.
-     * Call this when the user confirms their edit.
-     */
-    commitValue(newValue: TValue | null): void;
-    /**
-     * Cancel editing. Emits the cancel output AND dispatches a DOM event.
-     * Call this when the user cancels (e.g., presses Escape).
-     */
-    cancelEdit(): void;
-    /**
-     * Get a human-readable error message for a validation error.
-     * Override this method to customize error messages for your editor.
-     *
-     * @param errorKey - The validation error key (e.g., 'required', 'minlength')
-     * @param errorValue - The error value (e.g., { requiredLength: 5, actualLength: 3 })
-     * @returns A human-readable error message
-     */
-    protected getErrorMessage(errorKey: string, errorValue?: unknown): string;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseGridEditor<any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseGridEditor<any, any>, never, never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "row": { "alias": "row"; "required": false; "isSignal": true; }; "column": { "alias": "column"; "required": false; "isSignal": true; }; "control": { "alias": "control"; "required": false; "isSignal": true; }; }, { "commit": "commit"; "cancel": "cancel"; }, never, never, true, never>;
+declare class TbwGridColumn {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwGridColumn, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwGridColumn, "tbw-grid-column", never, {}, {}, never, never, true, never>;
 }
 
 /**
- * Base class for grid editors that also work as Angular form controls.
- *
- * Combines `BaseGridEditor` with `ControlValueAccessor` so the same component
- * can be used inside a `<tbw-grid>` **and** in a standalone `<form>`.
- *
- * ## What it provides
+ * Directive that registers `<tbw-grid-header>` as a known Angular element.
  *
- * | Member | Purpose |
- * |--------|---------|
- * | `cvaValue` | Signal holding the value written by the form control |
- * | `disabledState` | Signal tracking `setDisabledState` calls |
- * | `displayValue` | Computed that prefers grid value (`currentValue`) and falls back to `cvaValue` |
- * | `commitBoth(v)` | Commits via both CVA `onChange` and grid `commitValue` |
- * | `writeValue` / `registerOn*` / `setDisabledState` | Full CVA implementation |
+ * This directive exists so that Angular's template compiler recognises
+ * `<tbw-grid-header>` without requiring `CUSTOM_ELEMENTS_SCHEMA`.
+ * The grid's `config-manager` reads attributes like `title` directly
+ * from the DOM element.
  *
  * ## Usage
  *
  * ```typescript
- * import { Component, forwardRef } from '@angular/core';
- * import { NG_VALUE_ACCESSOR } from '@angular/forms';
- * import { BaseGridEditorCVA } from '@toolbox-web/grid-angular';
+ * import { Component } from '@angular/core';
+ * import { Grid, TbwGridHeader } from '@toolbox-web/grid-angular';
  *
  * @Component({
- *   selector: 'app-date-picker',
- *   providers: [{
- *     provide: NG_VALUE_ACCESSOR,
- *     useExisting: forwardRef(() => DatePickerComponent),
- *     multi: true,
- *   }],
+ *   imports: [Grid, TbwGridHeader],
  *   template: `
- *     <input
- *       type="date"
- *       [value]="displayValue()"
- *       [disabled]="disabledState()"
- *       (change)="commitBoth($event.target.value)"
- *       (keydown.escape)="cancelEdit()"
- *     />
+ *     <tbw-grid [rows]="rows" [gridConfig]="config">
+ *       <tbw-grid-header title="My Grid Title"></tbw-grid-header>
+ *     </tbw-grid>
  *   `
  * })
- * export class DatePickerComponent extends BaseGridEditorCVA<MyRow, string> {}
+ * export class MyComponent { }
  * ```
  *
- * > **Note:** Subclasses must still provide `NG_VALUE_ACCESSOR` themselves
- * > because `forwardRef(() => ConcreteClass)` must reference the concrete
- * > component — this is an Angular limitation.
- *
- * @typeParam TRow - The row data type
- * @typeParam TValue - The cell/control value type
- *
- * MOVE-IN-V2: this class will physically move into
- * `@toolbox-web/grid-angular/features/editing` in v2.0.0; the deprecated
- * re-export from the main `@toolbox-web/grid-angular` entry will be removed at
- * the same time. Consumers should already be importing from the feature entry.
+ * @category Directive
  * @since 0.13.0
  */
-declare abstract class BaseGridEditorCVA<TRow = unknown, TValue = unknown> extends BaseGridEditor<TRow, TValue> implements ControlValueAccessor {
-    /** Internal onChange callback registered by the form control. */
-    private _onChange;
-    /** Internal onTouched callback registered by the form control. */
-    private _onTouched;
-    /**
-     * Signal holding the value written by the form control via `writeValue()`.
-     * Updated when the form control pushes a new value (e.g. `patchValue`, `setValue`).
-     */
-    protected readonly cvaValue: _angular_core.WritableSignal<TValue | null>;
-    /**
-     * Signal tracking the disabled state set by the form control.
-     * Updated when `setDisabledState()` is called by Angular's forms module.
-     */
-    readonly disabledState: _angular_core.WritableSignal<boolean>;
-    /**
-     * Resolved display value.
-     *
-     * Prefers `currentValue()` (grid context — from `control.value` or `value` input)
-     * and falls back to `cvaValue()` (standalone form context — from `writeValue`).
-     *
-     * Use this in your template instead of reading `currentValue()` directly
-     * so the component works in both grid and standalone form contexts.
-     */
-    readonly displayValue: _angular_core.Signal<TValue | null>;
-    /**
-     * Called by Angular forms when the form control value changes programmatically.
-     */
-    writeValue(value: TValue | null): void;
-    /**
-     * Called by Angular forms to register a change callback.
-     */
-    registerOnChange(fn: (value: TValue | null) => void): void;
-    /**
-     * Called by Angular forms to register a touched callback.
-     */
-    registerOnTouched(fn: () => void): void;
-    /**
-     * Called by Angular forms to set the disabled state.
-     */
-    setDisabledState(isDisabled: boolean): void;
-    /**
-     * Commit a value through both the CVA (form control) and the grid.
-     *
-     * - Calls the CVA `onChange` callback (updates the form control)
-     * - Marks the control as touched
-     * - Calls `commitValue()` (emits grid commit event + DOM `CustomEvent`)
-     *
-     * Use this instead of `commitValue()` when your editor doubles as a form control.
-     *
-     * @param value - The new value to commit
-     */
-    protected commitBoth(value: TValue | null): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseGridEditorCVA<any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseGridEditorCVA<any, any>, never, never, {}, {}, never, never, true, never>;
+declare class TbwGridHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwGridHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwGridHeader, "tbw-grid-header", never, {}, {}, never, never, true, never>;
 }
 
 /**
- * Position of the overlay panel relative to its anchor cell.
- *
- * - `'below'` — panel appears below the cell, left-aligned (default)
- * - `'above'` — panel appears above the cell, left-aligned
- * - `'below-right'` — panel appears below the cell, right-aligned
- * - `'over-top-left'` — panel top-left corner aligns with cell top-left corner (opens downward)
- * - `'over-bottom-left'` — panel bottom-left corner aligns with cell bottom-left corner (opens upward)
- * @since 0.13.0
- */
-type OverlayPosition = 'below' | 'above' | 'below-right' | 'over-top-left' | 'over-bottom-left';
-/**
- * Base class for grid editors that display a floating overlay panel.
+ * Directive that registers `<tbw-grid-tool-buttons>` as a known Angular element.
  *
- * Provides infrastructure for:
- * - **Overlay positioning** — CSS Anchor Positioning with JS fallback
- * - **Focus gating** — in row editing mode, the panel only opens for the focused cell
- * - **Click-outside detection** — closes the panel when clicking outside
- * - **MutationObserver** — detects cell focus changes (row editing mode)
- * - **Escape handling** — closes the panel and returns focus to the inline input
- * - **Synthetic Tab dispatch** — advances grid focus after overlay close
- * - **Automatic teardown** — removes the panel from `<body>` and cleans up listeners
- * - **External focus registration** — auto-registers the panel via `grid.registerExternalFocusContainer()` so the grid keeps `data-has-focus` and editors stay open while the overlay has focus
+ * This directive exists so that Angular's template compiler recognises
+ * `<tbw-grid-tool-buttons>` without requiring `CUSTOM_ELEMENTS_SCHEMA`.
+ * The grid's shell reads toolbar buttons directly from the DOM.
  *
  * ## Usage
  *
  * ```typescript
- * import { Component, viewChild, ElementRef, effect } from '@angular/core';
- * import { BaseOverlayEditor } from '@toolbox-web/grid-angular';
+ * import { Component } from '@angular/core';
+ * import { Grid, TbwGridToolButtons } from '@toolbox-web/grid-angular';
  *
  * @Component({
- *   selector: 'app-date-editor',
+ *   imports: [Grid, TbwGridToolButtons],
  *   template: `
- *     <input
- *       #inlineInput
- *       readonly
- *       [value]="currentValue()"
- *       (click)="onInlineClick()"
- *       (keydown)="onInlineKeydown($event)"
- *     />
- *     <div #panel class="tbw-overlay-panel" style="width: 280px;">
- *       <!-- your date picker UI here -->
- *       <div class="actions">
- *         <button (click)="selectAndClose(selectedDate)">OK</button>
- *         <button (click)="hideOverlay()">Cancel</button>
- *       </div>
- *     </div>
+ *     <tbw-grid [rows]="rows" [gridConfig]="config">
+ *       <tbw-grid-tool-buttons>
+ *         <button (click)="doSomething()">Action</button>
+ *       </tbw-grid-tool-buttons>
+ *     </tbw-grid>
  *   `
  * })
- * export class DateEditorComponent extends BaseOverlayEditor<MyRow, string> {
- *   panelRef = viewChild.required<ElementRef<HTMLElement>>('panel');
- *   inputRef = viewChild.required<ElementRef<HTMLInputElement>>('inlineInput');
- *
- *   protected override overlayPosition = 'below' as const;
+ * export class MyComponent { }
+ * ```
  *
- *   constructor() {
- *     super();
- *     effect(() => {
- *       const panel = this.panelRef().nativeElement;
- *       this.initOverlay(panel);
- *       if (this.isCellFocused()) this.showOverlay();
- *     });
- *   }
+ * @category Directive
+ * @since 0.13.0
+ */
+declare class TbwGridToolButtons {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwGridToolButtons, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwGridToolButtons, "tbw-grid-tool-buttons", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that registers `<tbw-grid-type>` as a known Angular element.
  *
- *   protected getInlineInput(): HTMLInputElement | null {
- *     return this.inputRef()?.nativeElement ?? null;
- *   }
+ * This keeps Angular template compilation happy without requiring
+ * `CUSTOM_ELEMENTS_SCHEMA` and mirrors the existing `TbwGridColumn` directive.
  *
- *   protected onOverlayOutsideClick(): void {
- *     this.hideOverlay();
- *   }
- *
- *   selectAndClose(date: string): void {
- *     this.commitValue(date);
- *     this.hideOverlay();
- *   }
- * }
- * ```
- *
- * @example
- * ```typescript
- * @Component({
- *   template: `
- *     <input #inlineInput readonly [value]="currentValue()"
- *       (click)="onInlineClick()" (keydown)="onInlineKeydown($event)" />
- *     <div #panel style="width: 280px">
- *       <!-- overlay content -->
- *     </div>
- *   `
- * })
- * export class MyEditor extends BaseOverlayEditor<MyRow, string> {
- *   panelRef = viewChild.required<ElementRef<HTMLElement>>('panel');
- *   inputRef = viewChild.required<ElementRef<HTMLInputElement>>('inlineInput');
- *
- *   constructor() {
- *     super();
- *     effect(() => this.initOverlay(this.panelRef().nativeElement));
- *   }
- *
- *   protected getInlineInput() { return this.inputRef()?.nativeElement ?? null; }
- *   protected onOverlayOutsideClick() { this.hideOverlay(); }
- * }
- * ```
- *
- * @typeParam TRow - The row data type
- * @typeParam TValue - The cell value type
- *
- * MOVE-IN-V2: this class (and its companion `OverlayPosition` type) will
- * physically move into `@toolbox-web/grid-angular/features/editing` in v2.0.0;
- * the deprecated re-export from the main `@toolbox-web/grid-angular` entry
- * will be removed at the same time. Consumers should already be importing
- * from the feature entry.
- * @since 0.13.0
+ * @category Directive
+ * @since 2.0.0
  */
-declare abstract class BaseOverlayEditor<TRow = unknown, TValue = unknown> extends BaseGridEditor<TRow, TValue> {
-    private readonly _elementRef;
-    private readonly _overlayDestroyRef;
-    /**
-     * Position of the overlay panel relative to the anchor cell.
-     * Override in subclasses to change the default position.
-     *
-     * @default 'below'
-     */
-    protected overlayPosition: OverlayPosition;
-    /** The overlay panel element (set via `initOverlay()`). */
-    private _panel;
-    /** Whether the overlay is currently visible. */
-    protected _isOpen: boolean;
-    /** Unique anchor ID for CSS Anchor Positioning. */
-    private _anchorId;
-    /** Whether the browser supports CSS Anchor Positioning. */
-    private _supportsAnchor;
-    /** AbortController for all overlay-related listeners. */
-    private _abortCtrl;
-    /** MutationObserver watching cell focus class changes. */
-    protected _focusObserver: MutationObserver | null;
-    constructor();
-    /**
-     * Initialise the overlay with the panel element.
-     *
-     * Call this in an `effect()` or `afterNextRender()` with your `viewChild` panel reference.
-     * The panel is moved to `<body>` and hidden until {@link showOverlay} is called.
-     *
-     * @param panel - The overlay panel DOM element
-     */
-    protected initOverlay(panel: HTMLElement): void;
-    /**
-     * Show the overlay panel.
-     *
-     * If CSS Anchor Positioning is not supported, falls back to JS-based
-     * positioning using `getBoundingClientRect()`.
-     */
-    protected showOverlay(): void;
-    /**
-     * Hide the overlay panel.
-     *
-     * @param suppressTabAdvance - When `true`, skip synthetic Tab dispatch
-     *   (useful when hiding is triggered by an external focus change).
-     */
-    protected hideOverlay(suppressTabAdvance?: boolean): void;
-    /**
-     * Close and immediately re-open the overlay.
-     * Useful after the panel content changes size and needs repositioning.
-     */
-    protected reopenOverlay(): void;
-    /**
-     * Remove the overlay from the DOM and clean up all listeners.
-     *
-     * Called automatically on `DestroyRef.onDestroy`. Can also be called
-     * manually if the editor needs early cleanup.
-     */
-    protected teardownOverlay(): void;
-    /**
-     * Override in `edit-close` handler to also hide the overlay.
-     * This is called automatically by `BaseGridEditor` when the grid
-     * ends the editing session.
-     */
-    protected onEditClose(): void;
-    /**
-     * Keydown handler for the inline readonly input.
-     *
-     * - **Enter / Space / ArrowDown / F2** → open overlay
-     * - **Escape** → calls {@link handleEscape}
-     *
-     * Bind this to `(keydown)` on your inline input element.
-     */
-    onInlineKeydown(event: KeyboardEvent): void;
-    /**
-     * Click handler for the inline input.
-     * Opens the overlay and calls {@link onOverlayOpened}.
-     *
-     * Bind this to `(click)` on your inline input element.
-     */
-    onInlineClick(): void;
-    /**
-     * Handle Escape key press.
-     *
-     * If the overlay is open, closes it and returns focus to the inline input.
-     * If the overlay is already closed, cancels the edit entirely.
-     */
-    protected handleEscape(event: Event): void;
-    /**
-     * Dispatch a synthetic Tab key event to advance grid focus.
-     *
-     * Call this after committing a value and closing the overlay so the
-     * grid moves focus to the next cell.
-     *
-     * @param backward - When `true`, dispatch Shift+Tab to move backwards.
-     */
-    protected advanceGridFocus(backward?: boolean): void;
-    /**
-     * Return the inline input element, if any.
-     *
-     * Used by overlay infrastructure to return focus after hiding.
-     * Return `null` if there is no inline input.
-     */
-    protected abstract getInlineInput(): HTMLInputElement | null;
-    /**
-     * Called when a pointerdown event occurs outside the overlay panel
-     * and outside the editor's host element.
-     *
-     * Typically, subclasses call `hideOverlay()` here.
-     */
-    protected abstract onOverlayOutsideClick(): void;
-    /**
-     * Called after the overlay is shown.
-     *
-     * Override to focus an element inside the panel, start animations, etc.
-     * Default implementation is a no-op.
-     */
-    protected onOverlayOpened(): void;
-    /** Find the parent cell element for this editor. */
-    private _getCell;
-    /** Find the parent `<tbw-grid>` element for this editor. */
-    private _getGridElement;
-    /**
-     * JS fallback positioning for browsers without CSS Anchor Positioning.
-     * Uses `getBoundingClientRect()` with viewport overflow detection.
-     */
-    private _positionWithJs;
-    /**
-     * Document pointerdown handler for click-outside detection.
-     * Fires `onOverlayOutsideClick()` if the click is outside the panel
-     * and outside the editor's host element.
-     */
-    private _onDocumentPointerDown;
-    /**
-     * Handle the grid's `tbw-scroll` CustomEvent while the overlay is open.
-     *
-     * When the viewport scrolls, the anchored overlay would otherwise float
-     * over content that no longer corresponds to the edited cell (or the
-     * cell may be virtualized out entirely). Treat scroll as a dismissal
-     * signal equivalent to clicking outside so subclasses' overlay-outside
-     * handler drives the appropriate commit/cancel path.
-     */
-    private _onGridScroll;
-    /**
-     * Set up a MutationObserver on the parent cell to watch for
-     * `cell-focus` class changes. This handles row-editing mode where
-     * all editors exist simultaneously but only the focused cell's
-     * editor should have its overlay visible.
-     *
-     * A `justOpened` flash guard suppresses the observer from
-     * immediately closing the overlay when `beginBulkEdit()` moves
-     * focus to the first editable column. Without this guard,
-     * double-click triggers a "flash open then close" effect.
-     */
-    protected _setupFocusObserver(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseOverlayEditor<any, any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<BaseOverlayEditor<any, any>, never, never, {}, {}, never, never, true, never>;
+declare class TbwGridType {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwGridType, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwGridType, "tbw-grid-type", never, {}, {}, never, never, true, never>;
 }
 
 /**
- * Context object passed to the cell editor template.
- * Contains the cell value, row data, column configuration, and commit/cancel functions.
- * @since 0.1.0
+ * Event detail for cell commit events.
+ * @since 0.1.1
  */
-interface GridEditorContext<TValue = unknown, TRow = unknown> {
-    /** The cell value for this column */
-    $implicit: TValue;
-    /** The cell value (explicit binding) */
-    value: TValue;
-    /** The full row data object */
+interface CellCommitEvent<TRow = unknown, TValue = unknown> {
+    /** The row data object */
     row: TRow;
-    /** Field name being edited */
+    /** The field name of the edited column */
     field: string;
-    /** The column configuration */
-    column: unknown;
-    /** Stable row identifier (from `getRowId`). Empty string if no `getRowId` is configured. */
-    rowId: string;
-    /**
-     * Callback function to commit the edited value.
-     * Use with Angular event binding: `(commit)="onCommit($event)"`
-     */
-    onCommit: (value: TValue) => void;
-    /**
-     * Callback function to cancel editing.
-     * Use with Angular event binding: `(cancel)="onCancel()"`
-     */
-    onCancel: () => void;
-    /**
-     * Update other fields in this row while the editor is open.
-     * Changes trigger `cell-change` events with source `'cascade'`.
-     */
-    updateRow: (changes: Partial<TRow>) => void;
-    /**
-     * Register a callback to receive value updates when the cell is modified
-     * externally (e.g., via `updateRow()` from another cell's commit).
-     *
-     * The framework adapter auto-patches `value`/`$implicit` for template editors,
-     * but custom components may use this for additional reactivity.
-     */
-    onValueChange?: (callback: (newValue: TValue) => void) => void;
-    /**
-     * The FormControl for this cell, if the grid is bound to a FormArray with FormGroups.
-     *
-     * This allows custom editors to bind directly to the control for validation display:
-     * ```html
-     * <input *tbwEditor="let value; control as ctrl"
-     *        [formControl]="ctrl"
-     *        [class.is-invalid]="ctrl?.invalid && ctrl?.touched" />
-     * ```
-     *
-     * Returns `undefined` if:
-     * - The grid is not bound to a FormArray
-     * - The FormArray doesn't contain FormGroups
-     * - The field doesn't exist in the FormGroup
-     */
-    control?: AbstractControl;
+    /** The new value after edit */
+    value: TValue;
+    /** The row index in the data array */
+    rowIndex: number;
+    /** Array of all rows that have been modified */
+    changedRows: TRow[];
+    /** Set of row indices that have been modified */
+    changedRowIndices: Set<number>;
+    /** Whether this is the first modification to this row */
+    firstTimeForRow: boolean;
+}
+/**
+ * Event detail for row commit events (bulk editing).
+ * @since 0.1.1
+ */
+interface RowCommitEvent<TRow = unknown> {
+    /** The row data object */
+    row: TRow;
+    /** The row index in the data array */
+    rowIndex: number;
+    /** Array of all rows that have been modified */
+    changedRows: TRow[];
+    /** Set of row indices that have been modified */
+    changedRowIndices: Set<number>;
+    /** Whether this is the first modification to this row */
+    firstTimeForRow: boolean;
 }
 /**
- * Directive that captures an `<ng-template>` for use as a cell editor.
+ * Directive that automatically registers the Angular adapter with tbw-grid elements.
  *
- * This enables declarative Angular component usage with proper input bindings
- * that satisfy Angular's AOT compiler.
+ * This directive eliminates the need to manually register the adapter in your component
+ * constructor. Simply import this directive and it will handle adapter registration.
  *
  * ## Usage
  *
- * ```html
- * <tbw-grid-column field="status" editable>
- *   <tbw-grid-column-editor>
- *     <ng-template let-value let-row="row" let-onCommit="onCommit" let-onCancel="onCancel">
- *       <app-status-select
- *         [value]="value"
- *         [row]="row"
- *         (commit)="onCommit($event)"
- *         (cancel)="onCancel()"
- *       />
- *     </ng-template>
- *   </tbw-grid-column-editor>
- * </tbw-grid-column>
- * ```
- *
- * The template context provides:
- * - `$implicit` / `value`: The cell value
- * - `row`: The full row data object
- * - `column`: The column configuration
- * - `onCommit`: Callback function to commit the new value
- * - `onCancel`: Callback function to cancel editing
- *
- * Import the directive in your component:
- *
  * ```typescript
- * import { GridColumnEditor } from '@toolbox-web/grid-angular';
+ * import { Component } from '@angular/core';
+ * import { Grid } from '@toolbox-web/grid-angular';
  *
  * @Component({
- *   imports: [GridColumnEditor],
- *   // ...
+ *   selector: 'app-root',
+ *   imports: [Grid],
+ *   template: `
+ *     <tbw-grid [rows]="rows" [gridConfig]="config" [customStyles]="myStyles">
+ *       <!-- column templates -->
+ *     </tbw-grid>
+ *   `
  * })
+ * export class AppComponent {
+ *   rows = [...];
+ *   config = {...};
+ *   myStyles = `.my-class { color: red; }`;
+ * }
  * ```
  *
- * @category Directive
- *
- * MOVE-IN-V2: this directive (and its companion `GridEditorContext` type and
- * `getEditorTemplate` helper) will physically move into
- * `@toolbox-web/grid-angular/features/editing` in v2.0.0; the deprecated
- * re-exports from the main `@toolbox-web/grid-angular` entry will be removed
- * at the same time. Consumers should already be importing from the feature
- * entry.
- * @since 0.1.0
- */
-declare class GridColumnEditor {
-    private elementRef;
-    /**
-     * Query for the ng-template content child.
-     */
-    template: _angular_core.Signal<TemplateRef<any> | undefined>;
-    /** Effect that triggers when the template is available */
-    private onTemplateReceived;
-    /**
-     * Static type guard for template context.
-     * Enables type inference in templates.
-     */
-    static ngTemplateContextGuard(dir: GridColumnEditor, ctx: unknown): ctx is GridEditorContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridColumnEditor, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridColumnEditor, "tbw-grid-column-editor", never, {}, {}, ["template"], never, true, never>;
-}
-
-/**
- * Context object passed to the cell renderer template.
- * Contains the cell value, row data, and column configuration.
- * @since 0.1.0
- */
-interface GridCellContext<TValue = unknown, TRow = unknown> {
-    /** The cell value for this column */
-    $implicit: TValue;
-    /** The cell value (explicit binding) */
-    value: TValue;
-    /** The full row data object */
-    row: TRow;
-    /** The column configuration */
-    column: unknown;
-}
-/**
- * Directive that captures an `<ng-template>` for use as a cell renderer.
+ * The directive automatically:
+ * - Creates a GridAdapter instance
+ * - Registers it with the GridElement
+ * - Injects custom styles into the grid
+ * - Handles cleanup on destruction
  *
- * This enables declarative Angular component usage with proper input bindings
- * that satisfy Angular's AOT compiler.
+ * ## Multi-version coexistence
  *
- * ## Usage
+ * In single-version apps the directive matches the bare `<tbw-grid>` tag. When
+ * two different grid versions share a page, the second-loaded bundle registers
+ * under a version-suffixed tag (e.g. `<tbw-grid-v2-15-0>`). Because Angular
+ * matches selectors at compile time, a runtime-only tag cannot be matched by
+ * tag name. The directive therefore also matches the stable `[data-tbw-grid]`
+ * attribute, so a suffixed grid can opt in by adding it literally:
  *
  * ```html
- * <tbw-grid-column field="status">
- *   <tbw-grid-column-view>
- *     <ng-template let-value let-row="row">
- *       <app-status-badge [value]="value" [row]="row" />
- *     </ng-template>
- *   </tbw-grid-column-view>
- * </tbw-grid-column>
+ * <tbw-grid-v2-15-0 data-tbw-grid [rows]="rows" [gridConfig]="config"></tbw-grid-v2-15-0>
  * ```
  *
- * The template context provides:
- * - `$implicit` / `value`: The cell value
- * - `row`: The full row data object
- * - `column`: The column configuration
- *
- * Import the directive in your component:
- *
- * ```typescript
- * import { GridColumnView } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [GridColumnView],
- *   // ...
- * })
- * ```
+ * Read the concrete tag from `DataGridElement.activeTag` of the bundle you
+ * imported. See the multi-version coexistence guide.
  *
  * @category Directive
  * @since 0.1.0
  */
-declare class GridColumnView {
+declare class Grid implements OnInit, AfterContentInit, OnDestroy {
     private elementRef;
+    private injector;
+    private appRef;
+    private viewContainerRef;
+    private iconRegistry;
+    private adapter;
+    constructor();
     /**
-     * Query for the ng-template content child.
-     */
-    template: _angular_core.Signal<TemplateRef<any> | undefined>;
-    /** Effect that triggers when the template is available */
-    private onTemplateReceived;
-    /**
-     * Static type guard for template context.
-     * Enables type inference in templates.
-     */
-    static ngTemplateContextGuard(dir: GridColumnView, ctx: unknown): ctx is GridCellContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridColumnView, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridColumnView, "tbw-grid-column-view", never, {}, {}, ["template"], never, true, never>;
-}
-
-/**
- * Directive that registers `<tbw-grid-column>` as a known Angular element.
- *
- * This directive exists so that Angular's template compiler recognises
- * `<tbw-grid-column>` without requiring `CUSTOM_ELEMENTS_SCHEMA`.
- * The underlying web component reads its attributes (`field`, `header`,
- * `type`, `width`, etc.) directly from the DOM, so no `@Input()` forwarding
- * is needed — Angular's standard property/attribute binding handles it.
- *
- * ## Usage
- *
- * ```typescript
- * import { Component } from '@angular/core';
- * import { Grid, TbwGridColumn, TbwRenderer } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [Grid, TbwGridColumn, TbwRenderer],
- *   template: `
- *     <tbw-grid [rows]="rows" [gridConfig]="config">
- *       <tbw-grid-column field="status">
- *         <app-status-badge *tbwRenderer="let value" [value]="value" />
- *       </tbw-grid-column>
- *     </tbw-grid>
- *   `
- * })
- * export class MyComponent { }
- * ```
- *
- * @category Directive
- * @since 0.13.0
- */
-declare class TbwGridColumn {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwGridColumn, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwGridColumn, "tbw-grid-column", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Context object passed to the detail renderer template.
- * Contains the row data for the expanded detail view.
- * @since 0.1.0
- */
-interface GridDetailContext<TRow = unknown> {
-    /** The row data (implicit binding for let-row) */
-    $implicit: TRow;
-    /** The row data (explicit binding) */
-    row: TRow;
-}
-/**
- * Gets the detail template registered for a given grid element.
- * Used by AngularGridAdapter to retrieve templates at render time.
- * @since 0.1.0
- */
-declare function getDetailTemplate(gridElement: HTMLElement): TemplateRef<GridDetailContext> | undefined;
-/**
- * Directive that captures an `<ng-template>` for use as a master-detail row renderer.
- *
- * This enables declarative Angular component usage for expandable detail rows
- * that appear below the main row when expanded.
- *
- * ## Usage
- *
- * ```html
- * <tbw-grid [rows]="rows" [gridConfig]="config">
- *   <tbw-grid-detail [showExpandColumn]="true" animation="slide">
- *     <ng-template let-row>
- *       <app-detail-panel [employee]="row" />
- *     </ng-template>
- *   </tbw-grid-detail>
- * </tbw-grid>
- * ```
- *
- * The template context provides:
- * - `$implicit` / `row`: The full row data object
- *
- * Import the directive from the master-detail feature entry:
- *
- * ```typescript
- * import { GridDetailView } from '@toolbox-web/grid-angular/features/master-detail';
- *
- * @Component({
- *   imports: [GridDetailView],
- *   // ...
- * })
- * ```
- *
- * > Note: `GridDetailView` is also re-exported from `@toolbox-web/grid-angular`
- * > for backwards compatibility, but that re-export is deprecated and will be
- * > removed in v2.0.0. Always import from the feature entry.
- *
- * @example
- * ```html
- * <tbw-grid [rows]="rows" [gridConfig]="config">
- *   <tbw-grid-detail [showExpandColumn]="true" animation="slide">
- *     <ng-template let-row>
- *       <app-detail-panel [employee]="row" />
- *     </ng-template>
- *   </tbw-grid-detail>
- * </tbw-grid>
- * ```
- *
- * @category Directive
- * @since 0.1.0
- */
-declare class GridDetailView {
-    private elementRef;
-    /** Whether to show the expand/collapse column. Default: true */
-    showExpandColumn: _angular_core.InputSignal<boolean>;
-    /** Animation style for expand/collapse. Default: 'slide' */
-    animation: _angular_core.InputSignal<ExpandCollapseAnimation>;
-    /**
-     * Query for the ng-template content child.
-     */
-    template: _angular_core.Signal<TemplateRef<any> | undefined>;
-    /** Effect that triggers when the template is available */
-    private onTemplateReceived;
-    /**
-     * Static type guard for template context.
-     * Enables type inference in templates.
-     */
-    static ngTemplateContextGuard(dir: GridDetailView, ctx: unknown): ctx is GridDetailContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridDetailView, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridDetailView, "tbw-grid-detail", never, { "showExpandColumn": { "alias": "showExpandColumn"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; }, {}, ["template"], never, true, never>;
-}
-
-/**
- * Context provided to the grid containing form-related information.
- * This can be accessed by other directives to get form controls.
- * @since 0.5.0
- */
-interface FormArrayContext {
-    /** Get the row data at a specific index */
-    getRow<T = unknown>(rowIndex: number): T | null;
-    /** Update a field value at a specific row */
-    updateField(rowIndex: number, field: string, value: unknown): void;
-    /** Get the current form value (all rows) */
-    getValue<T = unknown>(): T[];
-    /**
-     * Get the FormControl for a specific cell.
-     * Only available when using FormArray with FormGroup rows.
-     *
-     * @param rowIndex - The row index
-     * @param field - The field name
-     * @returns The AbstractControl for the cell, or undefined if not available
-     */
-    getControl(rowIndex: number, field: string): AbstractControl | undefined;
-    /**
-     * Whether the grid is backed by a FormArray of FormGroups.
-     * When true, `getControl()` will return cell-level controls.
-     */
-    hasFormGroups: boolean;
-    /**
-     * Get the FormGroup for a specific row.
-     * Only available when using FormArray with FormGroup rows.
-     *
-     * @param rowIndex - The row index
-     * @returns The FormGroup for the row, or undefined if not available
-     */
-    getRowFormGroup(rowIndex: number): FormGroup | undefined;
-    /**
-     * Check if a row is valid (all controls in the FormGroup are valid).
-     * Returns true if not using FormArray or if the row doesn't exist.
-     *
-     * @param rowIndex - The row index
-     * @returns true if the row is valid, false if any control is invalid
-     */
-    isRowValid(rowIndex: number): boolean;
-    /**
-     * Check if a row has been touched (any control in the FormGroup is touched).
-     * Returns false if not using FormArray or if the row doesn't exist.
-     *
-     * @param rowIndex - The row index
-     * @returns true if any control in the row is touched
-     */
-    isRowTouched(rowIndex: number): boolean;
-    /**
-     * Check if a row is dirty (any control in the FormGroup is dirty).
-     * Returns false if not using FormArray or if the row doesn't exist.
-     *
-     * @param rowIndex - The row index
-     * @returns true if any control in the row is dirty
-     */
-    isRowDirty(rowIndex: number): boolean;
-    /**
-     * Get validation errors for a specific row.
-     * Aggregates errors from all controls in the FormGroup.
-     *
-     * @param rowIndex - The row index
-     * @returns Object with field names as keys and their errors, or null if no errors
-     */
-    getRowErrors(rowIndex: number): Record<string, unknown> | null;
-}
-/**
- * Gets the FormArrayContext from a grid element, if present.
- * @internal
- * @since 0.5.0
- */
-declare function getFormArrayContext(gridElement: HTMLElement): FormArrayContext | undefined;
-/**
- * Directive that binds a FormArray directly to the grid.
- *
- * This is the recommended way to integrate tbw-grid with Angular Reactive Forms.
- * Use a FormArray of FormGroups for row-level validation and cell-level control access.
- *
- * ## Usage
- *
- * ```typescript
- * import { Component, inject } from '@angular/core';
- * import { FormBuilder, ReactiveFormsModule } from '@angular/forms';
- * import { Grid, GridFormArray } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [Grid, GridFormArray, ReactiveFormsModule],
- *   template: \`
- *     <form [formGroup]="form">
- *       <tbw-grid [formArray]="form.controls.rows" [columns]="columns" />
- *     </form>
- *   \`
- * })
- * export class MyComponent {
- *   private fb = inject(FormBuilder);
- *
- *   form = this.fb.group({
- *     rows: this.fb.array([
- *       this.fb.group({ name: 'Alice', age: 30 }),
- *       this.fb.group({ name: 'Bob', age: 25 }),
- *     ])
- *   });
- *
- *   columns = [
- *     { field: 'name', header: 'Name', editable: true },
- *     { field: 'age', header: 'Age', editable: true }
- *   ];
- * }
- * ```
- *
- * ## How It Works
- *
- * - **FormArray → Grid**: The grid displays the FormArray's value as rows
- * - **Grid → FormArray**: When a cell is edited, the corresponding FormControl is updated
- * - FormArrayContext is available for accessing cell-level controls
- *
- * ## Features
- *
- * - Works naturally with FormArray inside a FormGroup
- * - Provides cell-level FormControl access for validation
- * - Supports row-level validation state aggregation
- * - Automatically syncs FormArray changes to the grid
- *
- * @example
- * ```html
- * <form [formGroup]="form">
- *   <tbw-grid [formArray]="form.controls.rows" [columns]="columns" />
- * </form>
- * ```
- *
- * @category Directive
- *
- * MOVE-IN-V2: this directive (and its `FormArrayContext` type and
- * `getFormArrayContext` helper) will physically move into
- * `@toolbox-web/grid-angular/features/editing` in v2.0.0; the deprecated
- * re-exports from the main `@toolbox-web/grid-angular` entry will be removed
- * at the same time. Consumers should already be importing from the feature
- * entry.
- * @since 0.5.0
- */
-declare class GridFormArray implements OnInit, OnDestroy {
-    #private;
-    private readonly destroyRef;
-    private elementRef;
-    private cellCommitUnsub;
-    private cellCancelUnsub;
-    private rowCommitUnsub;
-    private touchListener;
-    private valueChangesSubscription;
-    private statusChangesSubscriptions;
-    /**
-     * The FormArray to bind to the grid.
-     */
-    readonly formArray: _angular_core.InputSignal<FormArray<any>>;
-    /**
-     * Whether to automatically sync Angular validation state to grid's visual invalid styling.
-     *
-     * When enabled:
-     * - After a cell commit, if the FormControl is invalid, the cell is marked with `setInvalid()`
-     * - When a FormControl becomes valid, `clearInvalid()` is called
-     * - On `row-commit`, if the row's FormGroup has invalid controls, the commit is prevented
-     * - In grid mode: validation state is synced on initial render and updated reactively
-     *
-     * @default true
-     */
-    readonly syncValidation: _angular_core.InputSignal<boolean>;
-    /**
-     * Effect that sets up valueChanges subscription when FormArray changes.
-     * This handles both initial binding and when the FormArray reference changes.
-     */
-    private syncFormArrayToGrid;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridFormArray, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridFormArray, "tbw-grid[formArray]", never, { "formArray": { "alias": "formArray"; "required": true; "isSignal": true; }; "syncValidation": { "alias": "syncValidation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-/**
- * Context object passed to the header content template.
- * @since 1.7.0
- */
-interface GridHeaderContentContext {
-    /** The grid element (implicit binding for `let-grid`). */
-    $implicit: DataGridElement;
-    /** The grid element. */
-    grid: DataGridElement;
-}
-/**
- * Declarative wrapper around the grid's imperative
- * {@link ShellPlugin.registerHeaderContent} API.
- *
- * Captures an `<ng-template>` and mounts it as an Angular embedded view into
- * the slot the grid provides for header content. Must be a child of
- * `<tbw-grid>`.
- *
- * ## Usage
- *
- * ```html
- * <tbw-grid [rows]="rows" [gridConfig]="config">
- *   <tbw-grid-header-content id="calendar-nav" [order]="0">
- *     <ng-template let-grid>
- *       <app-header-nav [year]="year()" (yearChange)="setYear($event)" />
- *     </ng-template>
- *   </tbw-grid-header-content>
- * </tbw-grid>
- * ```
- *
- * @category Directive
- * @since 1.7.0
- */
-declare class GridHeaderContent {
-    private elementRef;
-    private viewContainerRef;
-    private destroyRef;
-    /** Unique identifier for this header content entry. Optional — defaults to a stable generated id. */
-    id: _angular_core.InputSignal<string | undefined>;
-    /** Render order priority. Lower values appear first. @default 100 */
-    order: _angular_core.InputSignal<number>;
-    /** The template to mount into the grid's header content slot. */
-    template: _angular_core.Signal<TemplateRef<any> | undefined>;
-    private viewRef;
-    private registeredId;
-    private resolvedId;
-    private destroyed;
-    constructor();
-    private lastOrder;
-    private register;
-    private unregister;
-    private findGrid;
-    /** Type guard for template context inference. */
-    static ngTemplateContextGuard(_dir: GridHeaderContent, ctx: unknown): ctx is GridHeaderContentContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridHeaderContent, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridHeaderContent, "tbw-grid-header-content", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "order": { "alias": "order"; "required": false; "isSignal": true; }; }, {}, ["template"], never, true, never>;
-}
-
-/**
- * Directive that registers `<tbw-grid-header>` as a known Angular element.
- *
- * This directive exists so that Angular's template compiler recognises
- * `<tbw-grid-header>` without requiring `CUSTOM_ELEMENTS_SCHEMA`.
- * The grid's `config-manager` reads attributes like `title` directly
- * from the DOM element.
- *
- * ## Usage
- *
- * ```typescript
- * import { Component } from '@angular/core';
- * import { Grid, TbwGridHeader } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [Grid, TbwGridHeader],
- *   template: `
- *     <tbw-grid [rows]="rows" [gridConfig]="config">
- *       <tbw-grid-header title="My Grid Title"></tbw-grid-header>
- *     </tbw-grid>
- *   `
- * })
- * export class MyComponent { }
- * ```
- *
- * @category Directive
- * @since 0.13.0
- */
-declare class TbwGridHeader {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwGridHeader, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwGridHeader, "tbw-grid-header", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Gets the FormArrayContext from a grid element, if present.
- * @internal
- * @since 0.11.0
- */
-declare function getLazyFormContext(gridElement: HTMLElement): FormArrayContext | undefined;
-/**
- * Factory function type for creating FormGroups lazily.
- * Called when a row enters edit mode for the first time.
- *
- * @template TRow The row data type
- * @param row The row data object
- * @param rowIndex The row index in the grid
- * @returns A FormGroup for the row (only include editable fields)
- * @since 0.11.0
- */
-type LazyFormFactory<TRow = unknown> = (row: TRow, rowIndex: number) => FormGroup;
-/**
- * Event emitted when a row's form values have changed.
- * @since 0.11.0
- */
-interface RowFormChangeEvent<TRow = unknown> {
-    /** The row index */
-    rowIndex: number;
-    /** The row ID (if available) */
-    rowId?: string;
-    /** The original row data */
-    row: TRow;
-    /** The FormGroup for this row */
-    formGroup: FormGroup;
-    /** The current form values */
-    values: Partial<TRow>;
-    /** Whether the form is valid */
-    valid: boolean;
-    /** Whether the form is dirty */
-    dirty: boolean;
-}
-/**
- * Directive that provides lazy FormGroup creation for grid editing.
- *
- * Unlike `GridFormArray` which creates all FormGroups upfront, this directive
- * creates FormGroups on-demand only when a row enters edit mode. This provides
- * much better performance for large datasets while still enabling full
- * Angular Reactive Forms integration.
- *
- * ## Key Benefits
- *
- * - **Performance**: Only creates FormGroups for rows being edited (20-100x fewer controls)
- * - **Same DX**: Editors still receive `control` in their context for validation
- * - **Memory efficient**: FormGroups are cleaned up when rows exit edit mode
- *
- * ## Usage
- *
- * ```typescript
- * import { Component, inject, signal } from '@angular/core';
- * import { FormBuilder, Validators, ReactiveFormsModule } from '@angular/forms';
- * import { Grid, GridLazyForm, TbwEditor } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [Grid, GridLazyForm, TbwEditor, ReactiveFormsModule],
- *   template: \`
- *     <tbw-grid
- *       [rows]="employees()"
- *       [lazyForm]="createRowForm"
- *       [gridConfig]="config">
- *
- *       <tbw-grid-column field="firstName">
- *         <input *tbwEditor="let _; control as ctrl"
- *                [formControl]="ctrl"
- *                [class.is-invalid]="ctrl?.invalid && ctrl?.touched" />
- *       </tbw-grid-column>
- *     </tbw-grid>
- *   \`
- * })
- * export class MyComponent {
- *   private fb = inject(FormBuilder);
- *   employees = signal(generateEmployees(1000));
- *
- *   // Factory called when editing starts - only include editable fields!
- *   createRowForm = (row: Employee): FormGroup => this.fb.group({
- *     firstName: [row.firstName, Validators.required],
- *     lastName: [row.lastName, Validators.minLength(2)],
- *     salary: [row.salary, [Validators.required, Validators.min(0)]],
- *   });
- *
- *   gridConfig = { columns: [...] };
- * }
- * ```
- *
- * ## How It Works
- *
- * 1. Rows come from `[rows]` input (plain data array)
- * 2. When a cell enters edit mode, the FormGroup is created lazily
- * 3. Editors receive the FormControl in their template context
- * 4. On commit, FormGroup values are synced back to the row
- * 5. FormGroup is cleaned up when the row exits edit mode (configurable)
- *
- * ## Performance Comparison
- *
- * | Rows | GridFormArray (20 fields) | GridLazyForm |
- * |------|---------------------------|--------------|
- * | 100  | 2,000 controls           | ~20 controls |
- * | 500  | 10,000 controls          | ~20 controls |
- * | 1000 | 20,000 controls          | ~20 controls |
- *
- * @example
- * ```html
- * <tbw-grid [rows]="employees()" [lazyForm]="createRowForm" [gridConfig]="gridConfig" />
- * ```
- *
- * @see GridFormArray For small datasets with full upfront validation
- * @category Directive
- *
- * MOVE-IN-V2: this directive (and its `LazyFormFactory`, `RowFormChangeEvent`
- * types and `getLazyFormContext` helper) will physically move into
- * `@toolbox-web/grid-angular/features/editing` in v2.0.0; the deprecated
- * re-exports from the main `@toolbox-web/grid-angular` entry will be removed
- * at the same time. Consumers should already be importing from the feature
- * entry.
- * @since 0.11.0
- */
-declare class GridLazyForm<TRow = unknown> implements OnInit, OnDestroy {
-    #private;
-    private elementRef;
-    private formGroupCache;
-    private rowIndexMap;
-    private editingRowIndex;
-    private cellCommitUnsub;
-    private rowCommitUnsub;
-    private rowsChangeUnsub;
-    /**
-     * Factory function to create a FormGroup for a row.
-     * Called lazily when the row first enters edit mode.
-     *
-     * @example
-     * ```typescript
-     * createRowForm = (row: Employee): FormGroup => this.fb.group({
-     *   firstName: [row.firstName, Validators.required],
-     *   lastName: [row.lastName],
-     *   salary: [row.salary, [Validators.min(0)]],
-     * });
-     * ```
-     */
-    readonly lazyForm: _angular_core.InputSignal<LazyFormFactory<TRow>>;
-    /**
-     * Whether to automatically sync Angular validation state to grid's visual invalid styling.
-     *
-     * When enabled:
-     * - After a cell commit, if the FormControl is invalid, the cell is marked with `setInvalid()`
-     * - When a FormControl becomes valid, `clearInvalid()` is called
-     * - On `row-commit`, if the row's FormGroup has invalid controls, the commit is prevented
-     *
-     * @default true
-     */
-    readonly syncValidation: _angular_core.InputSignal<boolean>;
-    /**
-     * Whether to keep FormGroups cached after a row exits edit mode.
-     *
-     * - `true`: FormGroups are kept, preserving dirty/touched state across edit sessions
-     * - `false`: FormGroups are disposed when the row exits edit mode (default)
-     *
-     * @default false
-     */
-    readonly keepFormGroups: _angular_core.InputSignal<boolean>;
-    /**
-     * Emitted when a row's form values change.
-     * Useful for auto-save, validation display, or syncing to external state.
-     */
-    readonly rowFormChange: _angular_core.OutputEmitterRef<RowFormChangeEvent<TRow>>;
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /**
-     * Gets the FormGroup for a row, if it exists.
-     * Unlike the context methods, this does NOT create a FormGroup lazily.
-     *
-     * @param rowIndex The row index
-     * @returns The FormGroup or undefined
-     */
-    getFormGroup(rowIndex: number): FormGroup | undefined;
-    /**
-     * Gets all cached FormGroups.
-     * Useful for bulk validation or inspection.
-     *
-     * @returns Map of row objects to their FormGroups
-     */
-    getAllFormGroups(): ReadonlyMap<TRow, FormGroup>;
-    /**
-     * Clears all cached FormGroups.
-     * Useful when the underlying data changes significantly.
-     */
-    clearAllFormGroups(): void;
-    /**
-     * Validates all currently cached FormGroups.
-     *
-     * @returns true if all FormGroups are valid, false otherwise
-     */
-    validateAll(): boolean;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridLazyForm<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridLazyForm<any>, "tbw-grid[lazyForm]", never, { "lazyForm": { "alias": "lazyForm"; "required": true; "isSignal": true; }; "syncValidation": { "alias": "syncValidation"; "required": false; "isSignal": true; }; "keepFormGroups": { "alias": "keepFormGroups"; "required": false; "isSignal": true; }; }, { "rowFormChange": "rowFormChange"; }, never, never, true, never>;
-}
-
-/**
- * Context object passed to the responsive card template.
- *
- * @template TRow - The type of row data
- *
- * @example
- * ```html
- * <tbw-grid-responsive-card>
- *   <ng-template let-row let-index="index">
- *     <div class="card-content">
- *       <span>{{ row.name }}</span>
- *       <span>Row #{{ index }}</span>
- *     </div>
- *   </ng-template>
- * </tbw-grid-responsive-card>
- * ```
- * @since 0.4.0
- */
-interface GridResponsiveCardContext<TRow = unknown> {
-    /**
-     * The row data (available as `let-row` or `let-myVar`).
-     */
-    $implicit: TRow;
-    /**
-     * The row data (explicit access via `let-row="row"`).
-     */
-    row: TRow;
-    /**
-     * The row index (zero-based).
-     */
-    index: number;
-}
-/**
- * Retrieves the responsive card template for a grid element.
- *
- * @param gridElement - The grid element to look up
- * @returns The template reference or undefined if not found
- * @since 0.4.0
- */
-declare function getResponsiveCardTemplate(gridElement: HTMLElement): TemplateRef<GridResponsiveCardContext> | undefined;
-/**
- * Directive for providing custom Angular templates for responsive card layout.
- *
- * Use this directive to define how each row should render when the grid
- * is in responsive/mobile mode. The template receives the row data and index.
- *
- * ## Usage
- *
- * ```html
- * <tbw-grid [rows]="employees">
- *   <tbw-grid-responsive-card>
- *     <ng-template let-employee let-idx="index">
- *       <div class="employee-card">
- *         <img [src]="employee.avatar" alt="">
- *         <div class="info">
- *           <strong>{{ employee.name }}</strong>
- *           <span>{{ employee.department }}</span>
- *         </div>
- *       </div>
- *     </ng-template>
- *   </tbw-grid-responsive-card>
- * </tbw-grid>
- * ```
- *
- * ## Important Notes
- *
- * - The ResponsivePlugin must be added to your grid config
- * - The Grid directive will automatically configure the plugin's cardRenderer
- * - Template context provides `$implicit` (row), `row`, and `index`
- *
- * @see ResponsivePlugin
- * @category Directive
- * @since 0.4.0
- */
-declare class GridResponsiveCard<TRow = unknown> {
-    private elementRef;
-    /**
-     * Card row height in pixels. Use `'auto'` for dynamic height based on content.
-     *
-     * Mirrors to the `card-row-height` attribute on the underlying
-     * `<tbw-grid-responsive-card>` element which the ResponsivePlugin reads.
-     *
-     * @default 'auto'
-     */
-    cardRowHeight: _angular_core.InputSignal<number | "auto" | undefined>;
-    /**
-     * The ng-template containing the card content.
-     */
-    template: _angular_core.Signal<TemplateRef<any> | undefined>;
-    /**
-     * Effect that registers the template when it becomes available.
-     */
-    private onTemplateReceived;
-    /**
-     * Effect that mirrors the `cardRowHeight` input to the kebab-cased attribute
-     * read by the ResponsivePlugin.
-     */
-    private onCardRowHeightChange;
-    /**
-     * Type guard for template context inference.
-     */
-    static ngTemplateContextGuard<T>(_directive: GridResponsiveCard<T>, context: unknown): context is GridResponsiveCardContext<T>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridResponsiveCard<any>, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridResponsiveCard<any>, "tbw-grid-responsive-card", never, { "cardRowHeight": { "alias": "cardRowHeight"; "required": false; "isSignal": true; }; }, {}, ["template"], never, true, never>;
-}
-
-/**
- * Directive that registers `<tbw-grid-tool-buttons>` as a known Angular element.
- *
- * This directive exists so that Angular's template compiler recognises
- * `<tbw-grid-tool-buttons>` without requiring `CUSTOM_ELEMENTS_SCHEMA`.
- * The grid's shell reads toolbar buttons directly from the DOM.
- *
- * ## Usage
- *
- * ```typescript
- * import { Component } from '@angular/core';
- * import { Grid, TbwGridToolButtons } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [Grid, TbwGridToolButtons],
- *   template: `
- *     <tbw-grid [rows]="rows" [gridConfig]="config">
- *       <tbw-grid-tool-buttons>
- *         <button (click)="doSomething()">Action</button>
- *       </tbw-grid-tool-buttons>
- *     </tbw-grid>
- *   `
- * })
- * export class MyComponent { }
- * ```
- *
- * @category Directive
- * @since 0.13.0
- */
-declare class TbwGridToolButtons {
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwGridToolButtons, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwGridToolButtons, "tbw-grid-tool-buttons", never, {}, {}, never, never, true, never>;
-}
-
-/**
- * Context object passed to the tool panel template.
- * Provides access to grid-related information for the panel content.
- * @since 0.1.0
- */
-interface GridToolPanelContext {
-    /** The grid element (implicit binding) */
-    $implicit: HTMLElement;
-    /** The grid element */
-    grid: HTMLElement;
-}
-/**
- * Directive that captures an `<ng-template>` for use as a custom tool panel.
- *
- * This enables declarative Angular component usage for tool panels
- * that appear in the grid's side panel.
- *
- * ## Usage
- *
- * ```html
- * <tbw-grid [rows]="rows" [gridConfig]="config">
- *   <tbw-grid-tool-panel
- *     id="quick-filters"
- *     title="Quick Filters"
- *     icon="🔍"
- *     tooltip="Apply quick filters"
- *     [order]="10"
- *   >
- *     <ng-template let-grid>
- *       <app-quick-filters [grid]="grid" />
- *     </ng-template>
- *   </tbw-grid-tool-panel>
- * </tbw-grid>
- * ```
- *
- * The template context provides:
- * - `$implicit` / `grid`: The grid element reference
- *
- * ### Attributes
- *
- * - `id` (required): Unique identifier for the panel
- * - `title` (required): Panel title shown in accordion header
- * - `icon`: Icon for accordion section header (emoji or text)
- * - `tooltip`: Tooltip for accordion section header
- * - `order`: Panel order priority (lower = first, default: 100)
- *
- * Import the directive in your component:
- *
- * ```typescript
- * import { GridToolPanel } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [GridToolPanel],
- *   // ...
- * })
- * ```
- *
- * @example
- * ```html
- * <tbw-grid [rows]="rows">
- *   <tbw-grid-tool-panel id="quick-filters" title="Quick Filters" icon="\uD83D\uDD0D">
- *     <ng-template let-grid>
- *       <app-quick-filters [grid]="grid" />
- *     </ng-template>
- *   </tbw-grid-tool-panel>
- * </tbw-grid>
- * ```
- *
- * @category Directive
- * @since 0.1.0
- */
-declare class GridToolPanel {
-    private elementRef;
-    /** Unique panel identifier (required) */
-    id: _angular_core.InputSignal<string>;
-    /** Panel title shown in accordion header (required) */
-    title: _angular_core.InputSignal<string>;
-    /** Icon for accordion section header (emoji or text) */
-    icon: _angular_core.InputSignal<string | undefined>;
-    /** Tooltip for accordion section header */
-    tooltip: _angular_core.InputSignal<string | undefined>;
-    /** Panel order priority (lower = first, default: 100) */
-    order: _angular_core.InputSignal<number>;
-    /**
-     * Query for the ng-template content child.
-     */
-    template: _angular_core.Signal<TemplateRef<any> | undefined>;
-    /** Effect that triggers when the template is available */
-    private onTemplateReceived;
-    /**
-     * Static type guard for template context.
-     * Enables type inference in templates.
-     */
-    static ngTemplateContextGuard(dir: GridToolPanel, ctx: unknown): ctx is GridToolPanelContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridToolPanel, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridToolPanel, "tbw-grid-tool-panel", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "order": { "alias": "order"; "required": false; "isSignal": true; }; }, {}, ["template"], never, true, never>;
-}
-
-/**
- * Context object passed to the toolbar content template.
- * @since 1.7.0
- */
-interface GridToolbarContentContext {
-    /** The grid element (implicit binding for `let-grid`). */
-    $implicit: DataGridElement;
-    /** The grid element. */
-    grid: DataGridElement;
-}
-/**
- * Declarative wrapper around the grid's imperative
- * {@link ShellPlugin.registerToolbarContent} API.
- *
- * Captures an `<ng-template>` and mounts it as an Angular embedded view into
- * the slot the grid provides for toolbar content. Must be a child of
- * `<tbw-grid>`.
- *
- * Prefer this over `<tbw-grid-tool-buttons>` (light DOM) when you need
- * Angular template bindings to component state. Use the light-DOM form for
- * static markup that should be moved verbatim into the toolbar.
- *
- * ## Usage
- *
- * ```html
- * <tbw-grid [rows]="rows" [gridConfig]="config">
- *   <tbw-grid-toolbar-content id="calendar-nav" [order]="0">
- *     <ng-template let-grid>
- *       <app-toolbar-nav (prev)="prev()" (today)="today()" (next)="next()" />
- *     </ng-template>
- *   </tbw-grid-toolbar-content>
- * </tbw-grid>
- * ```
- *
- * @category Directive
- * @since 1.7.0
- */
-declare class GridToolbarContent {
-    private elementRef;
-    private viewContainerRef;
-    private destroyRef;
-    id: _angular_core.InputSignal<string | undefined>;
-    order: _angular_core.InputSignal<number>;
-    template: _angular_core.Signal<TemplateRef<any> | undefined>;
-    private viewRef;
-    private registeredId;
-    private resolvedId;
-    private lastOrder;
-    private destroyed;
-    constructor();
-    private register;
-    private unregister;
-    private findGrid;
-    static ngTemplateContextGuard(_dir: GridToolbarContent, ctx: unknown): ctx is GridToolbarContentContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridToolbarContent, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridToolbarContent, "tbw-grid-toolbar-content", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "order": { "alias": "order"; "required": false; "isSignal": true; }; }, {}, ["template"], never, true, never>;
-}
-
-/**
- * Column shorthand parsing for `@toolbox-web/grid-angular`.
- *
- * Intentionally duplicated across the React, Vue, and Angular adapters so each
- * adapter has zero shared-runtime dependency. Do not extract into a shared
- * package: the helpers are tiny (~100 lines), the duplication keeps each
- * adapter independently tree-shakeable, and a shared package would force
- * consumers to install an extra dep just to import shorthand support.
- *
- * If you change behavior here, mirror the change in `grid-react` and
- * `grid-vue`. The three implementations are kept byte-equivalent.
- */
-
-/**
- * Type for column shorthand notation.
- *
- * Supports:
- * - Simple string: `'name'` → `{ field: 'name', header: 'Name' }`
- * - With type: `'salary:number'` → `{ field: 'salary', header: 'Salary', type: 'number' }`
- * - Full config object: `{ field: 'id', header: 'ID', width: 80 }` (passed through)
- *
- * @example
- * ```typescript
- * // All equivalent:
- * const cols1 = ['id', 'name', 'email'];
- * const cols2 = ['id:number', 'name:string', 'email'];
- * const cols3 = [{ field: 'id' }, { field: 'name' }, { field: 'email' }];
- * ```
- * @since 1.4.0
- */
-type ColumnShorthand<TRow = unknown> = string | ColumnConfig$1<TRow>;
-/**
- * Parse a column shorthand string into a ColumnConfig.
- *
- * Supports formats:
- * - `'fieldName'` → `{ field: 'fieldName', header: 'Field Name' }`
- * - `'fieldName:type'` → `{ field: 'fieldName', header: 'Field Name', type: 'type' }`
- *
- * @param shorthand - The shorthand string (e.g., 'name', 'salary:number')
- * @returns A ColumnConfig object
- * @since 1.4.0
- */
-declare function parseColumnShorthand<TRow = unknown>(shorthand: string): ColumnConfig$1<TRow>;
-/**
- * Normalize an array of column shorthands to ColumnConfig objects.
- *
- * @param columns - Array of column shorthands (strings or ColumnConfig objects)
- * @returns Array of ColumnConfig objects
- * @since 1.4.0
- */
-declare function normalizeColumns<TRow = unknown>(columns: ColumnShorthand<TRow>[]): ColumnConfig$1<TRow>[];
-/**
- * Apply column defaults to a list of columns. Individual column properties
- * override defaults.
- * @since 1.4.0
- */
-declare function applyColumnDefaults<TRow = unknown>(columns: ColumnConfig$1<TRow>[], defaults: Partial<ColumnConfig$1<TRow>> | undefined): ColumnConfig$1<TRow>[];
-/** Check if an array of columns contains any shorthand strings. * @since 1.4.0
- */
-declare function hasColumnShorthands<TRow>(columns: ColumnShorthand<TRow>[]): boolean;
-
-/**
- * Event detail for cell commit events.
- * @since 0.1.1
- */
-interface CellCommitEvent<TRow = unknown, TValue = unknown> {
-    /** The row data object */
-    row: TRow;
-    /** The field name of the edited column */
-    field: string;
-    /** The new value after edit */
-    value: TValue;
-    /** The row index in the data array */
-    rowIndex: number;
-    /** Array of all rows that have been modified */
-    changedRows: TRow[];
-    /** Set of row indices that have been modified */
-    changedRowIndices: Set<number>;
-    /** Whether this is the first modification to this row */
-    firstTimeForRow: boolean;
-}
-/**
- * Event detail for row commit events (bulk editing).
- * @since 0.1.1
- */
-interface RowCommitEvent<TRow = unknown> {
-    /** The row data object */
-    row: TRow;
-    /** The row index in the data array */
-    rowIndex: number;
-    /** Array of all rows that have been modified */
-    changedRows: TRow[];
-    /** Set of row indices that have been modified */
-    changedRowIndices: Set<number>;
-    /** Whether this is the first modification to this row */
-    firstTimeForRow: boolean;
-}
-/**
- * Directive that automatically registers the Angular adapter with tbw-grid elements.
- *
- * This directive eliminates the need to manually register the adapter in your component
- * constructor. Simply import this directive and it will handle adapter registration.
- *
- * ## Usage
- *
- * ```typescript
- * import { Component } from '@angular/core';
- * import { Grid } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   selector: 'app-root',
- *   imports: [Grid],
- *   template: `
- *     <tbw-grid [rows]="rows" [gridConfig]="config" [customStyles]="myStyles">
- *       <!-- column templates -->
- *     </tbw-grid>
- *   `
- * })
- * export class AppComponent {
- *   rows = [...];
- *   config = {...};
- *   myStyles = `.my-class { color: red; }`;
- * }
- * ```
- *
- * The directive automatically:
- * - Creates a GridAdapter instance
- * - Registers it with the GridElement
- * - Injects custom styles into the grid
- * - Handles cleanup on destruction
- *
- * ## Multi-version coexistence
- *
- * In single-version apps the directive matches the bare `<tbw-grid>` tag. When
- * two different grid versions share a page, the second-loaded bundle registers
- * under a version-suffixed tag (e.g. `<tbw-grid-v2-15-0>`). Because Angular
- * matches selectors at compile time, a runtime-only tag cannot be matched by
- * tag name. The directive therefore also matches the stable `[data-tbw-grid]`
- * attribute, so a suffixed grid can opt in by adding it literally:
- *
- * ```html
- * <tbw-grid-v2-15-0 data-tbw-grid [rows]="rows" [gridConfig]="config"></tbw-grid-v2-15-0>
- * ```
- *
- * Read the concrete tag from `DataGridElement.activeTag` of the bundle you
- * imported. See the multi-version coexistence guide.
- *
- * @category Directive
- * @since 0.1.0
- */
-declare class Grid implements OnInit, AfterContentInit, OnDestroy {
-    private elementRef;
-    private injector;
-    private appRef;
-    private viewContainerRef;
-    private iconRegistry;
-    private adapter;
-    constructor();
-    /**
-     * Custom CSS styles to inject into the grid.
-     * Use this to style custom cell renderers, editors, or detail panels.
-     *
-     * @example
-     * ```typescript
-     * // In your component
-     * customStyles = `
-     *   .my-detail-panel { padding: 16px; }
-     *   .my-status-badge { border-radius: 4px; }
-     * `;
-     * ```
-     *
-     * ```html
-     * <tbw-grid [customStyles]="customStyles">...</tbw-grid>
-     * ```
-     */
-    customStyles: _angular_core.InputSignal<string | undefined>;
-    /**
-     * Grid-wide sorting toggle.
-     * When false, disables sorting for all columns regardless of their individual `sortable` setting.
-     * When true (default), columns with `sortable: true` can be sorted.
-     *
-     * This is a core grid config property, not a plugin feature.
-     * For multi-column sorting, also add the `[multiSort]` feature.
-     *
-     * @default true
-     *
-     * @example
-     * ```html
-     * <!-- Disable all sorting -->
-     * <tbw-grid [sortable]="false" />
-     *
-     * <!-- Enable sorting (default) - columns still need sortable: true -->
-     * <tbw-grid [sortable]="true" />
-     *
-     * <!-- Enable multi-column sorting -->
-     * <tbw-grid [sortable]="true" [multiSort]="true" />
-     * ```
-     */
-    sortable: _angular_core.InputSignal<boolean | undefined>;
-    /**
-     * Grid-wide filtering toggle.
-     * When false, disables filtering for all columns regardless of their individual `filterable` setting.
-     * When true (default), columns with `filterable: true` can be filtered.
-     *
-     * Requires the FilteringPlugin to be loaded.
-     *
-     * @default true
-     *
-     * @example
-     * ```html
-     * <!-- Disable all filtering -->
-     * <tbw-grid [filterable]="false" [filtering]="true" />
-     *
-     * <!-- Enable filtering (default) -->
-     * <tbw-grid [filterable]="true" [filtering]="true" />
-     * ```
-     */
-    filterable: _angular_core.InputSignal<boolean | undefined>;
-    /**
-     * Grid-wide selection toggle.
-     * When false, disables selection for all rows/cells.
-     * When true (default), selection is enabled based on plugin mode.
-     *
-     * Requires the SelectionPlugin to be loaded.
-     *
-     * @default true
-     *
-     * @example
-     * ```html
-     * <!-- Disable all selection -->
-     * <tbw-grid [selectable]="false" [selection]="'range'" />
-     *
-     * <!-- Enable selection (default) -->
-     * <tbw-grid [selectable]="true" [selection]="'range'" />
-     * ```
-     */
-    selectable: _angular_core.InputSignal<boolean | undefined>;
-    /**
-     * Show a loading overlay on the grid.
-     * Use this during initial data fetch or refresh operations.
-     *
-     * For row/cell loading states, access the grid element directly:
-     * - `grid.setRowLoading(rowId, true/false)`
-     * - `grid.setCellLoading(rowId, field, true/false)`
-     *
-     * @default false
-     *
-     * @example
-     * ```html
-     * <!-- Show loading during data fetch -->
-     * <tbw-grid [loading]="isLoading" [rows]="rows" />
-     * ```
-     *
-     * ```typescript
-     * isLoading = true;
-     *
-     * ngOnInit() {
-     *   this.dataService.fetchData().subscribe(data => {
-     *     this.rows = data;
-     *     this.isLoading = false;
-     *   });
-     * }
-     * ```
-     */
-    loading: _angular_core.InputSignal<boolean | undefined>;
-    /**
-     * The data rows to display in the grid.
-     *
-     * Accepts an array of data objects. Each object represents one row.
-     * The grid reads property values for each column's `field` from these objects.
-     *
-     * @example
-     * ```html
-     * <tbw-grid [rows]="employees()" [gridConfig]="config" />
-     * ```
-     */
-    rows: _angular_core.InputSignal<any[] | undefined>;
-    /**
-     * Column configuration array.
-     *
-     * Accepts either full `ColumnConfig` objects or shorthand strings such as
-     * `'name'` or `'salary:number'`. Shorthands auto-generate human-readable
-     * headers from the field name.
-     *
-     * Shorthand for setting columns without wrapping them in a full `gridConfig`.
-     * If both `columns` and `gridConfig.columns` are set, `columns` takes precedence
-     * (see configuration precedence system).
-     *
-     * @example
-     * ```html
-     * <tbw-grid [rows]="data" [columns]="['id:number', 'name', { field: 'status', editable: true }]" />
-     * ```
-     */
-    columns: _angular_core.InputSignal<ColumnShorthand<any>[] | undefined>;
-    /**
-     * Default column properties applied to every column in `columns`.
-     * Individual column properties override these defaults.
-     *
-     * @example
-     * ```html
-     * <tbw-grid
-     *   [columnDefaults]="{ sortable: true, resizable: true }"
-     *   [columns]="[{ field: 'id', sortable: false }, { field: 'name' }]"
-     * />
-     * ```
-     */
-    columnDefaults: _angular_core.InputSignal<Partial<ColumnConfig<any>> | undefined>;
-    /**
-     * Column sizing strategy.
-     *
-     * - `'stretch'` (default) — columns stretch to fill available width
-     * - `'fixed'` — columns use their declared widths; enables horizontal scrolling
-     * - `'auto-fit'` — columns auto-size to content, then stretch to fill
-     *
-     * @default 'stretch'
-     *
-     * @example
-     * ```html
-     * <tbw-grid [rows]="data" fitMode="fixed" />
-     * <tbw-grid [rows]="data" [fitMode]="dynamicMode()" />
-     * ```
-     */
-    fitMode: _angular_core.InputSignal<FitMode | undefined>;
-    /**
-     * How automatic column inference combines with explicitly provided columns.
-     *
-     * - `'auto'` (default): infer only when no columns are provided.
-     * - `'merge'`: always infer from data, then overlay provided columns by `field`.
-     *
-     * @example
-     * ```html
-     * <tbw-grid [rows]="data" columnInference="merge" />
-     * <tbw-grid [rows]="data" [columnInference]="mode()" />
-     * ```
-     */
-    columnInference: _angular_core.InputSignal<ColumnInferenceMode | undefined>;
-    /**
-     * Grid configuration object with optional Angular-specific extensions.
-     *
-     * Accepts Angular-augmented `GridConfig` from `@toolbox-web/grid-angular`.
-     * You can specify Angular component classes directly for renderers and editors.
-     *
-     * Component classes must implement the appropriate interfaces:
-     * - Renderers: `CellRenderer<TRow, TValue>` - requires `value()` and `row()` signal inputs
-     * - Editors: `CellEditor<TRow, TValue>` - adds `commit` and `cancel` outputs
-     *
-     * @example
-     * ```typescript
-     * // Simple config with plain renderers
-     * config: GridConfig = {
-     *   columns: [
-     *     { field: 'name', header: 'Name' },
-     *     { field: 'active', type: 'boolean' }
-     *   ],
-     *   typeDefaults: {
-     *     boolean: { renderer: (ctx) => ctx.value ? '✓' : '✗' }
-     *   }
-     * };
-     *
-     * // Config with component classes
-     * config: GridConfig<Employee> = {
-     *   columns: [
-     *     { field: 'name', header: 'Name' },
-     *     { field: 'bonus', header: 'Bonus', editable: true, editor: BonusEditorComponent }
-     *   ]
-     * };
-     * ```
-     *
-     * ```html
-     * <tbw-grid [gridConfig]="config" [rows]="employees"></tbw-grid>
-     * ```
-     */
-    gridConfig: _angular_core.InputSignal<GridConfig<any> | undefined>;
-    /**
-     * Enable cell/row/range selection.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/selection';
-     * ```
-     *
-     * @example
-     * ```html
-     * <!-- Shorthand - just the mode -->
-     * <tbw-grid [selection]="'range'" />
-     *
-     * <!-- Full config object -->
-     * <tbw-grid [selection]="{ mode: 'range', checkbox: true }" />
-     * ```
-     *
-     * @deprecated Use `GridSelectionDirective` from
-     * `@toolbox-web/grid-angular/features/selection`. Will be removed in v2.0.0.
-     */
-    selection: _angular_core.InputSignal<"row" | SelectionConfig<any> | "cell" | "range" | undefined>;
-    /**
-     * Enable inline cell editing.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/editing';
-     * ```
-     *
-     * @example
-     * ```html
-     * <!-- Enable with default trigger (dblclick) -->
-     * <tbw-grid [editing]="true" />
-     *
-     * <!-- Specify trigger -->
-     * <tbw-grid [editing]="'click'" />
-     * <tbw-grid [editing]="'dblclick'" />
-     * <tbw-grid [editing]="'manual'" />
-     *
-     * <!-- Full config with callbacks -->
-     * <tbw-grid [editing]="{ editOn: 'dblclick', onBeforeEditClose: myCallback }" />
-     * ```
-     *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    editing: _angular_core.InputSignal<boolean | "click" | "dblclick" | "manual" | EditingConfig | undefined>;
-    /**
-     * Enable clipboard copy/paste. Requires selection to be enabled.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/clipboard';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [selection]="'range'" [clipboard]="true" />
-     * ```
-     *
-     * @deprecated Use `GridClipboardDirective` from
-     * `@toolbox-web/grid-angular/features/clipboard`. Will be removed in v2.0.0.
-     */
-    clipboard: _angular_core.InputSignal<boolean | ClipboardConfig | undefined>;
-    /**
-     * Enable right-click context menu.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/context-menu';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [contextMenu]="true" />
-     * ```
-     *
-     * @deprecated Use `GridContextMenuDirective` from
-     * `@toolbox-web/grid-angular/features/context-menu`. Will be removed in v2.0.0.
-     */
-    contextMenu: _angular_core.InputSignal<boolean | ContextMenuConfig | undefined>;
-    /**
-     * Enable multi-column sorting.
-     *
-     * Multi-sort allows users to sort by multiple columns simultaneously.
-     * For basic single-column sorting, columns with `sortable: true` work without this plugin.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/multi-sort';
-     * ```
-     *
-     * @example
-     * ```html
-     * <!-- Enable multi-column sorting -->
-     * <tbw-grid [multiSort]="true" />
-     *
-     * <!-- Limit to single column (uses plugin but restricts to 1 column) -->
-     * <tbw-grid [multiSort]="'single'" />
-     *
-     * <!-- Full config -->
-     * <tbw-grid [multiSort]="{ maxSortColumns: 3 }" />
-     * ```
-     *
-     * @deprecated Use `GridMultiSortDirective` from
-     * `@toolbox-web/grid-angular/features/multi-sort`. Will be removed in v2.0.0.
-     */
-    multiSort: _angular_core.InputSignal<boolean | "multi" | MultiSortConfig | "single" | undefined>;
-    /**
-     * Enable column filtering.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/filtering';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [filtering]="true" />
-     * <tbw-grid [filtering]="{ debounceMs: 200 }" />
-     * ```
-     *
-     * @deprecated Use `GridFilteringDirective` from
-     * `@toolbox-web/grid-angular/features/filtering` and add it to your
-     * component's `imports`. The directive owns the `filtering` input + the
-     * `filterChange` output and lets the typed surface tree-shake away when
-     * the feature is not imported. This input remains as a non-breaking shim
-     * and will be removed in v2.0.0.
-     */
-    filtering: _angular_core.InputSignal<boolean | FilterConfig<any> | undefined>;
-    /**
-     * Enable column drag-to-reorder.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/reorder-columns';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [reorderColumns]="true" />
-     * ```
-     *
-     * @deprecated Use `GridReorderColumnsDirective` from
-     * `@toolbox-web/grid-angular/features/reorder-columns`. Will be removed in v2.0.0.
-     */
-    reorderColumns: _angular_core.InputSignal<boolean | ReorderConfig | undefined>;
-    /**
-     * Enable column visibility toggle panel.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/visibility';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [visibility]="true" />
-     * ```
-     *
-     * @deprecated Use `GridVisibilityDirective` from
-     * `@toolbox-web/grid-angular/features/visibility`. Will be removed in v2.0.0.
-     */
-    visibility: _angular_core.InputSignal<boolean | VisibilityConfig | undefined>;
-    /**
-     * Enable pinned/sticky columns.
-     * Columns are pinned via the `sticky` column property.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/pinned-columns';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [pinnedColumns]="true" [columns]="[
-     *   { field: 'id', pinned: 'left' },
-     *   { field: 'name' },
-     *   { field: 'actions', pinned: 'right' }
-     * ]" />
-     * ```
-     *
-     * @deprecated Use `GridPinnedColumnsDirective` from
-     * `@toolbox-web/grid-angular/features/pinned-columns`. Will be removed in v2.0.0.
-     */
-    pinnedColumns: _angular_core.InputSignal<boolean | undefined>;
-    /**
-     * Enable multi-level column headers (column groups).
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/grouping-columns';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [groupingColumns]="true" />
-     * ```
-     *
-     * @deprecated Use `GridGroupingColumnsDirective` from
-     * `@toolbox-web/grid-angular/features/grouping-columns`. Will be removed in v2.0.0.
-     */
-    groupingColumns: _angular_core.InputSignal<boolean | GroupingColumnsConfig | undefined>;
-    /**
-     * Enable horizontal column virtualization for wide grids.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/column-virtualization';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [columnVirtualization]="true" />
-     * ```
-     *
-     * @deprecated Use `GridColumnVirtualizationDirective` from
-     * `@toolbox-web/grid-angular/features/column-virtualization`. Will be removed in v2.0.0.
-     */
-    columnVirtualization: _angular_core.InputSignal<boolean | ColumnVirtualizationConfig | undefined>;
-    /**
-     * Enable row drag-to-reorder.
-     *
-     * @deprecated Use `rowDragDrop` instead. `reorderRows` remains as an alias.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/reorder-rows';
-     * ```
-     */
-    reorderRows: _angular_core.InputSignal<boolean | RowReorderConfig | undefined>;
-    /**
-     * Enable row drag-and-drop within and across grids.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/row-drag-drop';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [rowDragDrop]="{ dropZone: 'employees', operation: 'move' }" />
-     * ```
-     *
-     * @deprecated Use `GridRowDragDropDirective` from
-     * `@toolbox-web/grid-angular/features/row-drag-drop`. Will be removed in v2.0.0.
-     */
-    rowDragDrop: _angular_core.InputSignal<boolean | RowDragDropConfig<any> | undefined>;
-    /**
-     * Enable row grouping by field values.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/grouping-rows';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [groupingRows]="{ groupBy: ['department'] }" />
-     * ```
-     *
-     * @deprecated Use `GridGroupingRowsDirective` from
-     * `@toolbox-web/grid-angular/features/grouping-rows`. Will be removed in v2.0.0.
-     */
-    groupingRows: _angular_core.InputSignal<GroupingRowsConfig | undefined>;
-    /**
-     * Enable pinned rows (aggregation/status bar).
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/pinned-rows';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [pinnedRows]="{ bottom: [{ type: 'aggregation' }] }" />
-     * ```
-     *
-     * @deprecated Use `GridPinnedRowsDirective` from
-     * `@toolbox-web/grid-angular/features/pinned-rows`. Will be removed in v2.0.0.
-     */
-    pinnedRows: _angular_core.InputSignal<boolean | PinnedRowsConfig | undefined>;
-    /**
-     * Enable hierarchical tree view.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/tree';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [tree]="{ childrenField: 'children' }" />
-     * ```
-     *
-     * @deprecated Use `GridTreeDirective` from
-     * `@toolbox-web/grid-angular/features/tree`. Will be removed in v2.0.0.
-     */
-    tree: _angular_core.InputSignal<boolean | TreeConfig | undefined>;
-    /**
-     * Enable master-detail expandable rows.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/master-detail';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [masterDetail]="{ detailRenderer: detailFn }" />
-     * ```
-     *
-     * @deprecated Use `GridMasterDetailDirective` from
-     * `@toolbox-web/grid-angular/features/master-detail`. Will be removed in v2.0.0.
-     */
-    masterDetail: _angular_core.InputSignal<MasterDetailConfig | undefined>;
-    /**
-     * Enable responsive card layout for narrow viewports.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/responsive';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [responsive]="{ breakpoint: 768 }" />
-     * ```
-     *
-     * @deprecated Use `GridResponsiveDirective` from
-     * `@toolbox-web/grid-angular/features/responsive`. Will be removed in v2.0.0.
-     */
-    responsive: _angular_core.InputSignal<boolean | ResponsivePluginConfig<unknown> | undefined>;
-    /**
-     * Enable undo/redo for cell edits. Requires editing to be enabled.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/undo-redo';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [editing]="'dblclick'" [undoRedo]="true" />
-     * ```
-     *
-     * @deprecated Use `GridUndoRedoDirective` from
-     * `@toolbox-web/grid-angular/features/undo-redo`. Will be removed in v2.0.0.
-     */
-    undoRedo: _angular_core.InputSignal<boolean | UndoRedoConfig | undefined>;
-    /**
-     * Enable CSV/JSON export functionality.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/export';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [export]="true" />
-     * <tbw-grid [export]="{ filename: 'data.csv' }" />
-     * ```
-     *
-     * @deprecated Use `GridExportDirective` from
-     * `@toolbox-web/grid-angular/features/export`. Will be removed in v2.0.0.
-     */
-    exportFeature: _angular_core.InputSignal<boolean | ExportConfig | undefined>;
-    /**
-     * Enable print functionality.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/print';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [print]="true" />
-     * ```
-     *
-     * @deprecated Use `GridPrintDirective` from
-     * `@toolbox-web/grid-angular/features/print`. Will be removed in v2.0.0.
-     */
-    print: _angular_core.InputSignal<boolean | PrintConfig | undefined>;
-    /**
-     * Enable pivot table functionality.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/pivot';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [pivot]="{ rowFields: ['category'], valueField: 'sales' }" />
-     * ```
-     *
-     * @deprecated Use `GridPivotDirective` from
-     * `@toolbox-web/grid-angular/features/pivot`. Will be removed in v2.0.0.
-     */
-    pivot: _angular_core.InputSignal<PivotConfig | undefined>;
-    /**
-     * Enable server-side data operations.
-     *
-     * **Requires feature import:**
-     * ```typescript
-     * import '@toolbox-web/grid-angular/features/server-side';
-     * ```
-     *
-     * @example
-     * ```html
-     * <tbw-grid [serverSide]="{ dataSource: fetchDataFn }" />
-     * ```
-     *
-     * @deprecated Use `GridServerSideDirective` from
-     * `@toolbox-web/grid-angular/features/server-side`. Will be removed in v2.0.0.
-     */
-    serverSide: _angular_core.InputSignal<ServerSideConfig | undefined>;
-    /**
-     * Controls the tooltip behavior for the grid.
-     *
-     * @example
-     * ```html
-     * <tbw-grid [tooltip]="true" />
-     * <tbw-grid [tooltip]="{ header: true, cell: false }" />
-     * ```
-     *
-     * @deprecated Use `GridTooltipDirective` from
-     * `@toolbox-web/grid-angular/features/tooltip`. Will be removed in v2.0.0.
-     */
-    tooltip: _angular_core.InputSignal<boolean | TooltipConfig | undefined>;
-    /**
-     * Emitted when a cell is clicked.
-     *
-     * @example
-     * ```html
-     * <tbw-grid (cellClick)="onCellClick($event)">...</tbw-grid>
-     * ```
-     */
-    cellClick: _angular_core.OutputEmitterRef<CellClickDetail<any>>;
-    /**
-     * Emitted when a row is clicked.
-     *
-     * @example
-     * ```html
-     * <tbw-grid (rowClick)="onRowClick($event)">...</tbw-grid>
-     * ```
-     */
-    rowClick: _angular_core.OutputEmitterRef<RowClickDetail<any>>;
-    /**
-     * Emitted when a cell is activated (Enter key or double-click).
-     *
-     * @example
-     * ```html
-     * <tbw-grid (cellActivate)="onCellActivate($event)">...</tbw-grid>
-     * ```
-     */
-    cellActivate: _angular_core.OutputEmitterRef<CellActivateDetail<any>>;
-    /**
-     * Emitted when a cell value changes (before commit).
-     *
-     * @example
-     * ```html
-     * <tbw-grid (cellChange)="onCellChange($event)">...</tbw-grid>
-     * ```
-     */
-    cellChange: _angular_core.OutputEmitterRef<CellChangeDetail<any>>;
-    /**
-     * Emitted when a cell value is committed (inline editing).
-     * Provides the row, field, new value, and change tracking information.
+     * Custom CSS styles to inject into the grid.
+     * Use this to style custom cell renderers, editors, or detail panels.
      *
      * @example
-     * ```html
-     * <tbw-grid (cellCommit)="onCellCommit($event)">...</tbw-grid>
-     * ```
-     *
      * ```typescript
-     * onCellCommit(event: CellCommitEvent) {
-     *   console.log(`Changed ${event.field} to ${event.value} in row ${event.rowIndex}`);
-     * }
-     * ```
-     *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    cellCommit: _angular_core.OutputEmitterRef<CellCommitEvent<unknown, unknown>>;
-    /**
-     * Emitted when a cell edit is cancelled (Escape, click outside without
-     * commit, or `editor.cancel()`).
-     *
-     * @example
-     * ```html
-     * <tbw-grid (cellCancel)="onCellCancel($event)">...</tbw-grid>
-     * ```
-     *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    cellCancel: _angular_core.OutputEmitterRef<CellCancelDetail>;
-    /**
-     * Emitted when a cell editor opens.
-     *
-     * @example
-     * ```html
-     * <tbw-grid (editOpen)="onEditOpen($event)">...</tbw-grid>
-     * ```
-     *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    editOpen: _angular_core.OutputEmitterRef<EditOpenDetail<any>>;
-    /**
-     * Emitted before an editor closes. Useful for last-chance validation.
-     *
-     * @example
-     * ```html
-     * <tbw-grid (beforeEditClose)="onBeforeEditClose($event)">...</tbw-grid>
-     * ```
-     *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    beforeEditClose: _angular_core.OutputEmitterRef<BeforeEditCloseDetail<any>>;
-    /**
-     * Emitted after an editor closes (whether committed or cancelled).
-     *
-     * @example
-     * ```html
-     * <tbw-grid (editClose)="onEditClose($event)">...</tbw-grid>
-     * ```
-     *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    editClose: _angular_core.OutputEmitterRef<EditCloseDetail<any>>;
-    /**
-     * Emitted when the dirty / changed-rows state transitions.
-     *
-     * @example
-     * ```html
-     * <tbw-grid (dirtyChange)="onDirtyChange($event)">...</tbw-grid>
+     * // In your component
+     * customStyles = `
+     *   .my-detail-panel { padding: 16px; }
+     *   .my-status-badge { border-radius: 4px; }
+     * `;
      * ```
      *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    dirtyChange: _angular_core.OutputEmitterRef<DirtyChangeDetail<any>>;
-    /**
-     * Emitted when row data is replaced (e.g. via the `rows` setter).
-     *
-     * @example
      * ```html
-     * <tbw-grid (dataChange)="onDataChange($event)">...</tbw-grid>
+     * <tbw-grid [customStyles]="customStyles">...</tbw-grid>
      * ```
      */
-    dataChange: _angular_core.OutputEmitterRef<DataChangeDetail>;
+    customStyles: _angular_core.InputSignal<string | undefined>;
     /**
-     * Emitted when a row's values are committed (bulk/row editing).
-     * Provides the row data and change tracking information.
+     * Grid-wide sorting toggle.
+     * When false, disables sorting for all columns regardless of their individual `sortable` setting.
+     * When true (default), columns with `sortable: true` can be sorted.
      *
-     * @example
-     * ```html
-     * <tbw-grid (rowCommit)="onRowCommit($event)">...</tbw-grid>
-     * ```
+     * This is a core grid config property, not a plugin feature.
+     * For multi-column sorting, also add the `[multiSort]` feature.
      *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    rowCommit: _angular_core.OutputEmitterRef<RowCommitEvent<unknown>>;
-    /**
-     * Emitted when the changed rows are reset.
+     * @default true
      *
      * @example
      * ```html
-     * <tbw-grid (changedRowsReset)="onChangedRowsReset($event)">...</tbw-grid>
-     * ```
+     * <!-- Disable all sorting -->
+     * <tbw-grid [sortable]="false" />
      *
-     * @deprecated Use `GridEditingDirective` from
-     * `@toolbox-web/grid-angular/features/editing`. Will be removed in v2.0.0.
-     */
-    changedRowsReset: _angular_core.OutputEmitterRef<ChangedRowsResetDetail<unknown>>;
-    /**
-     * Emitted when sort state changes.
+     * <!-- Enable sorting (default) - columns still need sortable: true -->
+     * <tbw-grid [sortable]="true" />
      *
-     * @example
-     * ```html
-     * <tbw-grid (sortChange)="onSortChange($event)">...</tbw-grid>
+     * <!-- Enable multi-column sorting -->
+     * <tbw-grid [sortable]="true" [multiSort]="true" />
      * ```
      */
-    sortChange: _angular_core.OutputEmitterRef<SortChangeDetail>;
+    sortable: _angular_core.InputSignal<boolean | undefined>;
     /**
-     * Emitted when filter values change.
+     * Grid-wide filtering toggle.
+     * When false, disables filtering for all columns regardless of their individual `filterable` setting.
+     * When true (default), columns with `filterable: true` can be filtered.
      *
-     * @example
-     * ```html
-     * <tbw-grid (filterChange)="onFilterChange($event)">...</tbw-grid>
-     * ```
+     * Requires the FilteringPlugin to be loaded.
      *
-     * @deprecated Use `GridFilteringDirective` from
-     * `@toolbox-web/grid-angular/features/filtering` (the directive
-     * declares the `(filterChange)` output). This output remains as a
-     * non-breaking shim and will be removed in v2.0.0.
-     */
-    filterChange: _angular_core.OutputEmitterRef<FilterChangeDetail>;
-    /**
-     * Emitted when a column is resized.
+     * @default true
      *
      * @example
      * ```html
-     * <tbw-grid (columnResize)="onColumnResize($event)">...</tbw-grid>
+     * <!-- Disable all filtering -->
+     * <tbw-grid [filterable]="false" [filtering]="true" />
+     *
+     * <!-- Enable filtering (default) -->
+     * <tbw-grid [filterable]="true" [filtering]="true" />
      * ```
      */
-    columnResize: _angular_core.OutputEmitterRef<ColumnResizeDetail>;
+    filterable: _angular_core.InputSignal<boolean | undefined>;
     /**
-     * Emitted when a column's width is reset (double-click on the resize handle).
+     * Grid-wide selection toggle.
+     * When false, disables selection for all rows/cells.
+     * When true (default), selection is enabled based on plugin mode.
+     *
+     * Requires the SelectionPlugin to be loaded.
+     *
+     * @default true
      *
      * @example
      * ```html
-     * <tbw-grid (columnResizeReset)="onColumnResizeReset($event)">...</tbw-grid>
+     * <!-- Disable all selection -->
+     * <tbw-grid [selectable]="false" [selection]="'range'" />
+     *
+     * <!-- Enable selection (default) -->
+     * <tbw-grid [selectable]="true" [selection]="'range'" />
      * ```
      */
-    columnResizeReset: _angular_core.OutputEmitterRef<ColumnResizeResetDetail>;
+    selectable: _angular_core.InputSignal<boolean | undefined>;
     /**
-     * Emitted when a column is moved via drag-and-drop.
+     * Show a loading overlay on the grid.
+     * Use this during initial data fetch or refresh operations.
      *
-     * @example
-     * ```html
-     * <tbw-grid (columnMove)="onColumnMove($event)">...</tbw-grid>
-     * ```
+     * For row/cell loading states, access the grid element directly:
+     * - `grid.setRowLoading(rowId, true/false)`
+     * - `grid.setCellLoading(rowId, field, true/false)`
      *
-     * @deprecated Use `GridReorderColumnsDirective` from
-     * `@toolbox-web/grid-angular/features/reorder-columns`. Will be removed in v2.0.0.
-     */
-    columnMove: _angular_core.OutputEmitterRef<ColumnMoveDetail>;
-    /**
-     * Emitted when a column is shown or hidden — either via the visibility
-     * sidebar, `grid.toggleColumnVisibility(field)`, `grid.setColumnVisible(field, visible)`,
-     * or `grid.showAllColumns()`.
+     * @default false
      *
      * @example
      * ```html
-     * <tbw-grid (columnVisibility)="onColumnVisibility($event)">...</tbw-grid>
+     * <!-- Show loading during data fetch -->
+     * <tbw-grid [loading]="isLoading" [rows]="rows" />
      * ```
      *
-     * @deprecated Use `GridVisibilityDirective` from
-     * `@toolbox-web/grid-angular/features/visibility`. Will be removed in v2.0.0.
-     */
-    columnVisibility: _angular_core.OutputEmitterRef<ColumnVisibilityDetail>;
-    /**
-     * Emitted when column state changes (resize, reorder, visibility).
+     * ```typescript
+     * isLoading = true;
      *
-     * @example
-     * ```html
-     * <tbw-grid (columnStateChange)="onColumnStateChange($event)">...</tbw-grid>
+     * ngOnInit() {
+     *   this.dataService.fetchData().subscribe(data => {
+     *     this.rows = data;
+     *     this.isLoading = false;
+     *   });
+     * }
      * ```
      */
-    columnStateChange: _angular_core.OutputEmitterRef<GridColumnState>;
+    loading: _angular_core.InputSignal<boolean | undefined>;
     /**
-     * Emitted when selection changes.
+     * The data rows to display in the grid.
+     *
+     * Accepts an array of data objects. Each object represents one row.
+     * The grid reads property values for each column's `field` from these objects.
      *
      * @example
      * ```html
-     * <tbw-grid (selectionChange)="onSelectionChange($event)">...</tbw-grid>
+     * <tbw-grid [rows]="employees()" [gridConfig]="config" />
      * ```
-     *
-     * @deprecated Use `GridSelectionDirective` from
-     * `@toolbox-web/grid-angular/features/selection`. Will be removed in v2.0.0.
      */
-    selectionChange: _angular_core.OutputEmitterRef<SelectionChangeDetail>;
+    rows: _angular_core.InputSignal<any[] | undefined>;
     /**
-     * Emitted when a row is moved via drag-and-drop.
+     * Column configuration array.
+     *
+     * Accepts either full `ColumnConfig` objects or shorthand strings such as
+     * `'name'` or `'salary:number'`. Shorthands auto-generate human-readable
+     * headers from the field name.
+     *
+     * Shorthand for setting columns without wrapping them in a full `gridConfig`.
+     * If both `columns` and `gridConfig.columns` are set, `columns` takes precedence
+     * (see configuration precedence system).
      *
      * @example
      * ```html
-     * <tbw-grid (rowMove)="onRowMove($event)">...</tbw-grid>
+     * <tbw-grid [rows]="data" [columns]="['id:number', 'name', { field: 'status', editable: true }]" />
      * ```
-     *
-     * @deprecated Use `GridRowDragDropDirective` from
-     * `@toolbox-web/grid-angular/features/row-drag-drop`. Will be removed in v2.0.0.
      */
-    rowMove: _angular_core.OutputEmitterRef<RowMoveDetail<any>>;
+    columns: _angular_core.InputSignal<ColumnShorthand<any>[] | undefined>;
     /**
-     * Emitted when a row drag starts. Cancelable via `event.preventDefault()`.
+     * Default column properties applied to every column in `columns`.
+     * Individual column properties override these defaults.
      *
      * @example
      * ```html
-     * <tbw-grid (rowDragStart)="onRowDragStart($event)">...</tbw-grid>
+     * <tbw-grid
+     *   [columnDefaults]="{ sortable: true, resizable: true }"
+     *   [columns]="[{ field: 'id', sortable: false }, { field: 'name' }]"
+     * />
      * ```
-     *
-     * @deprecated Use `GridRowDragDropDirective` from
-     * `@toolbox-web/grid-angular/features/row-drag-drop`. Will be removed in v2.0.0.
-     */
-    rowDragStart: _angular_core.OutputEmitterRef<RowDragStartDetail<any>>;
-    /**
-     * Emitted when a row drag ends (after drop or cancel).
-     *
-     * @deprecated Use `GridRowDragDropDirective` from
-     * `@toolbox-web/grid-angular/features/row-drag-drop`. Will be removed in v2.0.0.
      */
-    rowDragEnd: _angular_core.OutputEmitterRef<RowDragEndDetail<any>>;
+    columnDefaults: _angular_core.InputSignal<Partial<ColumnConfig<any>> | undefined>;
     /**
-     * Emitted on the target grid when rows are dropped from another grid.
-     * Cancelable via `event.preventDefault()`.
+     * Column sizing strategy.
      *
-     * @deprecated Use `GridRowDragDropDirective` from
-     * `@toolbox-web/grid-angular/features/row-drag-drop`. Will be removed in v2.0.0.
-     */
-    rowDrop: _angular_core.OutputEmitterRef<RowDropDetail<any>>;
-    /**
-     * Emitted on BOTH source and target grids after a successful cross-grid
-     * row transfer.
+     * - `'stretch'` (default) — columns stretch to fill available width
+     * - `'fixed'` — columns use their declared widths; enables horizontal scrolling
+     * - `'auto-fit'` — columns auto-size to content, then stretch to fill
      *
-     * @deprecated Use `GridRowDragDropDirective` from
-     * `@toolbox-web/grid-angular/features/row-drag-drop`. Will be removed in v2.0.0.
-     */
-    rowTransfer: _angular_core.OutputEmitterRef<RowTransferDetail<any>>;
-    /**
-     * Emitted when a group is expanded or collapsed.
+     * @default 'stretch'
      *
      * @example
      * ```html
-     * <tbw-grid (groupToggle)="onGroupToggle($event)">...</tbw-grid>
+     * <tbw-grid [rows]="data" fitMode="fixed" />
+     * <tbw-grid [rows]="data" [fitMode]="dynamicMode()" />
      * ```
-     *
-     * @deprecated Use `GridGroupingRowsDirective` from
-     * `@toolbox-web/grid-angular/features/grouping-rows`. Will be removed in v2.0.0.
      */
-    groupToggle: _angular_core.OutputEmitterRef<GroupToggleDetail>;
+    fitMode: _angular_core.InputSignal<FitMode | undefined>;
     /**
-     * Emitted when a group is expanded.
+     * How automatic column inference combines with explicitly provided columns.
+     *
+     * - `'auto'` (default): infer only when no columns are provided.
+     * - `'merge'`: always infer from data, then overlay provided columns by `field`.
      *
      * @example
      * ```html
-     * <tbw-grid (groupExpand)="onGroupExpand($event)">...</tbw-grid>
+     * <tbw-grid [rows]="data" columnInference="merge" />
+     * <tbw-grid [rows]="data" [columnInference]="mode()" />
      * ```
-     *
-     * @deprecated Use `GridGroupingRowsDirective` from
-     * `@toolbox-web/grid-angular/features/grouping-rows`. Will be removed in v2.0.0.
      */
-    groupExpand: _angular_core.OutputEmitterRef<GroupExpandDetail>;
+    columnInference: _angular_core.InputSignal<ColumnInferenceMode | undefined>;
     /**
-     * Emitted when a group is collapsed.
+     * Grid configuration object with optional Angular-specific extensions.
      *
-     * @example
-     * ```html
-     * <tbw-grid (groupCollapse)="onGroupCollapse($event)">...</tbw-grid>
-     * ```
+     * Accepts Angular-augmented `GridConfig` from `@toolbox-web/grid-angular`.
+     * You can specify Angular component classes directly for renderers and editors.
      *
-     * @deprecated Use `GridGroupingRowsDirective` from
-     * `@toolbox-web/grid-angular/features/grouping-rows`. Will be removed in v2.0.0.
-     */
-    groupCollapse: _angular_core.OutputEmitterRef<GroupCollapseDetail>;
-    /**
-     * Emitted when a tree node is expanded.
+     * Component classes must implement the appropriate interfaces:
+     * - Renderers: `CellRenderer<TRow, TValue>` - requires `value()` and `row()` signal inputs
+     * - Editors: `CellEditor<TRow, TValue>` - adds `commit` and `cancel` outputs
      *
      * @example
-     * ```html
-     * <tbw-grid (treeExpand)="onTreeExpand($event)">...</tbw-grid>
-     * ```
+     * ```typescript
+     * // Simple config with plain renderers
+     * config: GridConfig = {
+     *   columns: [
+     *     { field: 'name', header: 'Name' },
+     *     { field: 'active', type: 'boolean' }
+     *   ],
+     *   typeDefaults: {
+     *     boolean: { renderer: (ctx) => ctx.value ? '✓' : '✗' }
+     *   }
+     * };
      *
-     * @deprecated Use `GridTreeDirective` from
-     * `@toolbox-web/grid-angular/features/tree`. Will be removed in v2.0.0.
-     */
-    treeExpand: _angular_core.OutputEmitterRef<TreeExpandDetail<any>>;
-    /**
-     * Emitted when a detail panel is expanded or collapsed.
+     * // Config with component classes
+     * config: GridConfig<Employee> = {
+     *   columns: [
+     *     { field: 'name', header: 'Name' },
+     *     { field: 'bonus', header: 'Bonus', editable: true, editor: BonusEditorComponent }
+     *   ]
+     * };
+     * ```
      *
-     * @example
      * ```html
-     * <tbw-grid (detailExpand)="onDetailExpand($event)">...</tbw-grid>
+     * <tbw-grid [gridConfig]="config" [rows]="employees"></tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridMasterDetailDirective` from
-     * `@toolbox-web/grid-angular/features/master-detail`. Will be removed in v2.0.0.
      */
-    detailExpand: _angular_core.OutputEmitterRef<DetailExpandDetail>;
+    gridConfig: _angular_core.InputSignal<GridConfig<any> | undefined>;
     /**
-     * Emitted when responsive mode changes (table ↔ card).
+     * Emitted when a cell is clicked.
      *
      * @example
      * ```html
-     * <tbw-grid (responsiveChange)="onResponsiveChange($event)">...</tbw-grid>
+     * <tbw-grid (cellClick)="onCellClick($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridResponsiveDirective` from
-     * `@toolbox-web/grid-angular/features/responsive`. Will be removed in v2.0.0.
      */
-    responsiveChange: _angular_core.OutputEmitterRef<ResponsiveChangeDetail>;
+    cellClick: _angular_core.OutputEmitterRef<CellClickDetail<any>>;
     /**
-     * Emitted when the context menu opens.
+     * Emitted when a row is clicked.
      *
      * @example
      * ```html
-     * <tbw-grid (contextMenuOpen)="onContextMenuOpen($event)">...</tbw-grid>
+     * <tbw-grid (rowClick)="onRowClick($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridContextMenuDirective` from
-     * `@toolbox-web/grid-angular/features/context-menu`. Will be removed in v2.0.0.
      */
-    contextMenuOpen: _angular_core.OutputEmitterRef<ContextMenuOpenDetail>;
+    rowClick: _angular_core.OutputEmitterRef<RowClickDetail<any>>;
     /**
-     * Emitted when cells are copied to clipboard.
+     * Emitted when a cell is activated (Enter key or double-click).
      *
      * @example
      * ```html
-     * <tbw-grid (copy)="onCopy($event)">...</tbw-grid>
+     * <tbw-grid (cellActivate)="onCellActivate($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridClipboardDirective` from
-     * `@toolbox-web/grid-angular/features/clipboard`. Will be removed in v2.0.0.
      */
-    copy: _angular_core.OutputEmitterRef<CopyDetail>;
+    cellActivate: _angular_core.OutputEmitterRef<CellActivateDetail<any>>;
     /**
-     * Emitted when cells are pasted from clipboard.
+     * Emitted when a cell value changes (before commit).
      *
      * @example
      * ```html
-     * <tbw-grid (paste)="onPaste($event)">...</tbw-grid>
+     * <tbw-grid (cellChange)="onCellChange($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridClipboardDirective` from
-     * `@toolbox-web/grid-angular/features/clipboard`. Will be removed in v2.0.0.
      */
-    paste: _angular_core.OutputEmitterRef<PasteDetail>;
+    cellChange: _angular_core.OutputEmitterRef<CellChangeDetail<any>>;
     /**
-     * Emitted when an undo action is performed.
+     * Emitted when row data is replaced (e.g. via the `rows` setter).
      *
      * @example
      * ```html
-     * <tbw-grid (undo)="onUndo($event)">...</tbw-grid>
+     * <tbw-grid (dataChange)="onDataChange($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridUndoRedoDirective` from
-     * `@toolbox-web/grid-angular/features/undo-redo`. Will be removed in v2.0.0.
      */
-    undo: _angular_core.OutputEmitterRef<UndoRedoDetail>;
+    dataChange: _angular_core.OutputEmitterRef<DataChangeDetail>;
     /**
-     * Emitted when a redo action is performed.
+     * Emitted when sort state changes.
      *
      * @example
      * ```html
-     * <tbw-grid (redo)="onRedo($event)">...</tbw-grid>
+     * <tbw-grid (sortChange)="onSortChange($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridUndoRedoDirective` from
-     * `@toolbox-web/grid-angular/features/undo-redo`. Will be removed in v2.0.0.
      */
-    redo: _angular_core.OutputEmitterRef<UndoRedoDetail>;
+    sortChange: _angular_core.OutputEmitterRef<SortChangeDetail>;
     /**
-     * Emitted when export completes.
+     * Emitted when a column is resized.
      *
      * @example
      * ```html
-     * <tbw-grid (exportComplete)="onExportComplete($event)">...</tbw-grid>
+     * <tbw-grid (columnResize)="onColumnResize($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridExportDirective` from
-     * `@toolbox-web/grid-angular/features/export`. Will be removed in v2.0.0.
      */
-    exportComplete: _angular_core.OutputEmitterRef<ExportCompleteDetail>;
+    columnResize: _angular_core.OutputEmitterRef<ColumnResizeDetail>;
     /**
-     * Emitted when print starts.
+     * Emitted when a column's width is reset (double-click on the resize handle).
      *
      * @example
      * ```html
-     * <tbw-grid (printStart)="onPrintStart($event)">...</tbw-grid>
+     * <tbw-grid (columnResizeReset)="onColumnResizeReset($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridPrintDirective` from
-     * `@toolbox-web/grid-angular/features/print`. Will be removed in v2.0.0.
      */
-    printStart: _angular_core.OutputEmitterRef<PrintStartDetail>;
+    columnResizeReset: _angular_core.OutputEmitterRef<ColumnResizeResetDetail>;
     /**
-     * Emitted when print completes.
+     * Emitted when column state changes (resize, reorder, visibility).
      *
      * @example
      * ```html
-     * <tbw-grid (printComplete)="onPrintComplete($event)">...</tbw-grid>
+     * <tbw-grid (columnStateChange)="onColumnStateChange($event)">...</tbw-grid>
      * ```
-     *
-     * @deprecated Use `GridPrintDirective` from
-     * `@toolbox-web/grid-angular/features/print`. Will be removed in v2.0.0.
      */
-    printComplete: _angular_core.OutputEmitterRef<PrintCompleteDetail>;
+    columnStateChange: _angular_core.OutputEmitterRef<GridColumnState>;
     /**
      * Emitted (rAF-batched) when the grid's viewport is scrolled vertically.
      *
@@ -4123,36 +1734,43 @@ declare class Grid implements OnInit, AfterContentInit, OnDestroy {
      */
     render: _angular_core.OutputEmitterRef<RenderDetail>;
     private readonly eventOutputMap;
-    /** Events deliberately not exposed as Angular outputs. Keep empty unless documented. */
+    /**
+     * Events deliberately not exposed as outputs on the `Grid` directive.
+     *
+     * Every entry here is a **feature-owned** event surfaced by its per-feature
+     * directive instead (e.g. `GridEditingDirective` declares `(cellCommit)`,
+     * `GridSelectionDirective` declares `(selectionChange)`). The directive
+     * claims the DOM event via `claimEvent` so it is the sole emitter. The v1.x
+     * shims that forwarded these events from `Grid` were removed in v3.0.0 —
+     * consumers must import the relevant feature directive.
+     */
     private _intentionallyOmittedEvents;
     private _assertEventOutputMapCoversCore;
     private eventListeners;
     ngOnInit(): void;
     /**
-     * Sets up event listeners for all outputs using the eventOutputMap.
+     * Sets up event listeners for the core outputs in `eventOutputMap`.
      *
-     * Hybrid v1.x / v2 ownership: events claimed by an attribute-selector
-     * feature directive (via `claimEvent` in `feature-claims.ts`) are skipped
-     * here so the directive's own `output()` is the sole emitter. Without
-     * this skip both this directive's deprecated output and the directive's
-     * new output would fire for the same DOM event.
+     * Feature-owned events (e.g. `cell-commit`, `selection-change`) are not in
+     * `eventOutputMap` — they are surfaced by their per-feature directive, which
+     * claims the DOM event via `claimEvent`. Events still claimed here are
+     * skipped so the claiming directive's `output()` is the sole emitter.
      */
     private setupEventListeners;
     /**
-     * Creates plugins from feature inputs.
+     * Creates plugins from the per-feature directive claims.
      * Uses the feature registry to allow tree-shaking - only imported features are bundled.
      * Per-feature config bridging (e.g. converting Angular component classes inside
      * `groupingColumns` / `groupingRows` / `pinnedRows` configs to renderer functions)
      * runs via `getFeatureConfigPreprocessor`, populated by feature secondary entries.
      *
-     * Hybrid v1.x / v2 ownership: when an attribute-selector feature directive
-     * (e.g. `GridFilteringDirective`) is present on the same `<tbw-grid>`
-     * element it claims its feature in `feature-claims.ts`. We then read the
-     * claim's config getter — which transitively reads the directive's input
-     * signal, establishing reactive dependency tracking — instead of the
-     * deprecated input on this directive. This keeps the existing `[filtering]`
-     * binding working when used directly on `<tbw-grid>` (no directive, no
-     * claim) while letting the directive own the binding when imported.
+     * v3 ownership: feature configuration is owned entirely by the per-feature
+     * attribute-selector directives (e.g. `GridFilteringDirective`). When such a
+     * directive is present on the same `<tbw-grid>` element it claims its feature
+     * in `feature-claims.ts`; we read the claim's config getter — which
+     * transitively reads the directive's input signal, establishing reactive
+     * dependency tracking. The deprecated per-feature inputs that previously
+     * lived on this directive were removed in v3.0.0.
      *
      * Returns the array of created plugins (doesn't modify grid).
      */
@@ -4165,7 +1783,7 @@ declare class Grid implements OnInit, AfterContentInit, OnDestroy {
     private registerCustomStyles;
     ngOnDestroy(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<Grid, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Grid, "tbw-grid,[data-tbw-grid]", never, { "customStyles": { "alias": "customStyles"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "columnDefaults": { "alias": "columnDefaults"; "required": false; "isSignal": true; }; "fitMode": { "alias": "fitMode"; "required": false; "isSignal": true; }; "columnInference": { "alias": "columnInference"; "required": false; "isSignal": true; }; "gridConfig": { "alias": "gridConfig"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "editing": { "alias": "editing"; "required": false; "isSignal": true; }; "clipboard": { "alias": "clipboard"; "required": false; "isSignal": true; }; "contextMenu": { "alias": "contextMenu"; "required": false; "isSignal": true; }; "multiSort": { "alias": "multiSort"; "required": false; "isSignal": true; }; "filtering": { "alias": "filtering"; "required": false; "isSignal": true; }; "reorderColumns": { "alias": "reorderColumns"; "required": false; "isSignal": true; }; "visibility": { "alias": "visibility"; "required": false; "isSignal": true; }; "pinnedColumns": { "alias": "pinnedColumns"; "required": false; "isSignal": true; }; "groupingColumns": { "alias": "groupingColumns"; "required": false; "isSignal": true; }; "columnVirtualization": { "alias": "columnVirtualization"; "required": false; "isSignal": true; }; "reorderRows": { "alias": "reorderRows"; "required": false; "isSignal": true; }; "rowDragDrop": { "alias": "rowDragDrop"; "required": false; "isSignal": true; }; "groupingRows": { "alias": "groupingRows"; "required": false; "isSignal": true; }; "pinnedRows": { "alias": "pinnedRows"; "required": false; "isSignal": true; }; "tree": { "alias": "tree"; "required": false; "isSignal": true; }; "masterDetail": { "alias": "masterDetail"; "required": false; "isSignal": true; }; "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "undoRedo": { "alias": "undoRedo"; "required": false; "isSignal": true; }; "exportFeature": { "alias": "export"; "required": false; "isSignal": true; }; "print": { "alias": "print"; "required": false; "isSignal": true; }; "pivot": { "alias": "pivot"; "required": false; "isSignal": true; }; "serverSide": { "alias": "serverSide"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; }, { "cellClick": "cellClick"; "rowClick": "rowClick"; "cellActivate": "cellActivate"; "cellChange": "cellChange"; "cellCommit": "cellCommit"; "cellCancel": "cellCancel"; "editOpen": "editOpen"; "beforeEditClose": "beforeEditClose"; "editClose": "editClose"; "dirtyChange": "dirtyChange"; "dataChange": "dataChange"; "rowCommit": "rowCommit"; "changedRowsReset": "changedRowsReset"; "sortChange": "sortChange"; "filterChange": "filterChange"; "columnResize": "columnResize"; "columnResizeReset": "columnResizeReset"; "columnMove": "columnMove"; "columnVisibility": "columnVisibility"; "columnStateChange": "columnStateChange"; "selectionChange": "selectionChange"; "rowMove": "rowMove"; "rowDragStart": "rowDragStart"; "rowDragEnd": "rowDragEnd"; "rowDrop": "rowDrop"; "rowTransfer": "rowTransfer"; "groupToggle": "groupToggle"; "groupExpand": "groupExpand"; "groupCollapse": "groupCollapse"; "treeExpand": "treeExpand"; "detailExpand": "detailExpand"; "responsiveChange": "responsiveChange"; "contextMenuOpen": "contextMenuOpen"; "copy": "copy"; "paste": "paste"; "undo": "undo"; "redo": "redo"; "exportComplete": "exportComplete"; "printStart": "printStart"; "printComplete": "printComplete"; "tbwScroll": "tbwScroll"; "render": "render"; }, never, never, true, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<Grid, "tbw-grid,[data-tbw-grid]", never, { "customStyles": { "alias": "customStyles"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "columnDefaults": { "alias": "columnDefaults"; "required": false; "isSignal": true; }; "fitMode": { "alias": "fitMode"; "required": false; "isSignal": true; }; "columnInference": { "alias": "columnInference"; "required": false; "isSignal": true; }; "gridConfig": { "alias": "gridConfig"; "required": false; "isSignal": true; }; }, { "cellClick": "cellClick"; "rowClick": "rowClick"; "cellActivate": "cellActivate"; "cellChange": "cellChange"; "dataChange": "dataChange"; "sortChange": "sortChange"; "columnResize": "columnResize"; "columnResizeReset": "columnResizeReset"; "columnStateChange": "columnStateChange"; "tbwScroll": "tbwScroll"; "render": "render"; }, never, never, true, never>;
 }
 
 /**
@@ -4185,40 +1803,6 @@ interface StructuralCellContext<TValue = any, TRow = any> {
     /** The column configuration */
     column: any;
 }
-/**
- * Context type for structural editor directives with `any` defaults.
- * This provides better ergonomics in templates without requiring explicit type annotations.
- *
- * @internal Use `GridEditorContext` in application code for stricter typing.
- * @since 0.1.1
- */
-interface StructuralEditorContext<TValue = any, TRow = any> {
-    /** The cell value for this column */
-    $implicit: TValue;
-    /** The cell value (explicit binding) */
-    value: TValue;
-    /** The full row data object */
-    row: TRow;
-    /** The column configuration */
-    column: any;
-    /**
-     * Callback function to commit the edited value.
-     */
-    onCommit: (value: TValue) => void;
-    /**
-     * Callback function to cancel editing.
-     */
-    onCancel: () => void;
-    /**
-     * The FormControl for this cell, if the grid is bound to a FormArray with FormGroups.
-     *
-     * Returns `undefined` if:
-     * - The grid is not bound to a FormArray
-     * - The FormArray doesn't contain FormGroups
-     * - The field doesn't exist in the FormGroup
-     */
-    control?: AbstractControl;
-}
 /**
  * Structural directive for cell view rendering.
  *
@@ -4286,82 +1870,6 @@ declare class TbwRenderer implements OnDestroy {
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwRenderer, never>;
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwRenderer, "[tbwRenderer]", never, {}, {}, never, never, true, never>;
 }
-/**
- * Structural directive for cell editor rendering.
- *
- * This provides a cleaner syntax for defining custom cell editors without
- * the nested `<tbw-grid-column-editor>` and `<ng-template>` boilerplate.
- *
- * ## Usage
- *
- * ```html
- * <!-- Instead of this verbose syntax: -->
- * <tbw-grid-column field="status">
- *   <tbw-grid-column-editor>
- *     <ng-template let-value let-onCommit="onCommit" let-onCancel="onCancel">
- *       <app-status-editor [value]="value" (commit)="onCommit($event)" (cancel)="onCancel()" />
- *     </ng-template>
- *   </tbw-grid-column-editor>
- * </tbw-grid-column>
- *
- * <!-- Use this cleaner syntax (with auto-wiring - no explicit bindings needed!): -->
- * <tbw-grid-column field="status">
- *   <app-status-editor *tbwEditor="let value" [value]="value" />
- * </tbw-grid-column>
- * ```
- *
- * ## Template Context
- *
- * The structural directive provides the same context as `GridColumnEditor`:
- * - `$implicit` / `value`: The cell value
- * - `row`: The full row data object
- * - `column`: The column configuration
- * - `onCommit`: Callback function to commit the new value (optional - auto-wired if component emits `commit` event)
- * - `onCancel`: Callback function to cancel editing (optional - auto-wired if component emits `cancel` event)
- *
- * ## Import
- *
- * ```typescript
- * import { TbwEditor } from '@toolbox-web/grid-angular';
- *
- * @Component({
- *   imports: [TbwEditor],
- *   // ...
- * })
- * ```
- *
- * @example
- * ```html
- * <tbw-grid-column field="status" editable>
- *   <app-status-editor *tbwEditor="let value" [value]="value" />
- * </tbw-grid-column>
- * ```
- *
- * @category Directive
- *
- * MOVE-IN-V2: this directive (and its `StructuralEditorContext` type) will
- * physically move into `@toolbox-web/grid-angular/features/editing` in v2.0.0;
- * the deprecated re-export from the main `@toolbox-web/grid-angular` entry
- * will be removed at the same time. Consumers should already be importing
- * from the feature entry. (`TbwRenderer` stays in the main entry — it is
- * editor-agnostic.)
- * @since 0.1.1
- */
-declare class TbwEditor implements OnDestroy {
-    private template;
-    private elementRef;
-    private columnElement;
-    constructor();
-    private registerTemplate;
-    ngOnDestroy(): void;
-    /**
-     * Static type guard for template context.
-     * Uses `any` defaults for ergonomic template usage.
-     */
-    static ngTemplateContextGuard(dir: TbwEditor, ctx: unknown): ctx is StructuralEditorContext;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TbwEditor, never>;
-    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TbwEditor, "[tbwEditor]", never, {}, {}, never, never, true, never>;
-}
 
 /**
  * Combined provider helper for grid type defaults and icons.
@@ -4595,6 +2103,6 @@ declare function isEventClaimed(grid: HTMLElement, eventName: ClaimableEventName
  */
 declare function unclaimEvent(grid: HTMLElement, eventName: ClaimableEventName): void;
 
-export { BaseFilterPanel, BaseGridEditor, BaseGridEditorCVA, BaseOverlayEditor, GRID_ICONS, GRID_TYPE_DEFAULTS, Grid, GridAdapter, GridColumnEditor, GridColumnView, GridDetailView, GridFormArray, GridHeaderContent, GridIconRegistry, GridLazyForm, GridResponsiveCard, GridToolPanel, GridToolbarContent, GridTypeRegistry, TbwEditor, TbwGridColumn, TbwGridHeader, TbwGridToolButtons, TbwRenderer, applyColumnDefaults, claimEvent, getDetailTemplate, getFeatureClaim, getFeatureConfigPreprocessor, getFormArrayContext, getLazyFormContext, getResponsiveCardTemplate, hasColumnShorthands, injectGrid, isComponentClass, isEventClaimed, makeFlushFocusedInput, normalizeColumns, parseColumnShorthand, provideGrid, provideGridIcons, provideGridTypeDefaults, registerDetailRendererBridge, registerEditorMountHook, registerFeatureClaim, registerFeatureConfigPreprocessor, registerFilterPanelTypeDefaultBridge, registerResponsiveCardRendererBridge, registerTemplateBridge, runTemplateBridges, unclaimEvent, unregisterFeatureClaim };
-export type { CellCommitEvent, CellEditor, CellRenderer, ColumnConfig, ColumnShorthand, EditorMountHook, FeatureConfigGetter, FeatureConfigPreprocessor, FeatureName, FilterPanel, FilterPanelTypeDefaultBridge, FormArrayContext, GridCellContext, GridConfig, GridDetailContext, GridEditorContext, GridHeaderContentContext, GridResponsiveCardContext, GridToolPanelContext, GridToolbarContentContext, InjectGridReturn, LazyFormFactory, OverlayPosition, ProvideGridOptions, RowCommitEvent, RowFormChangeEvent, RowRendererBridge, StructuralCellContext, StructuralEditorContext, TemplateBridge, TemplateBridgeContext, TypeDefault, TypeDefaultRegistration };
+export { GRID_ICONS, GRID_TYPE_DEFAULTS, Grid, GridAdapter, GridColumnView, GridIconRegistry, GridTypeRegistry, TbwGridColumn, TbwGridHeader, TbwGridToolButtons, TbwGridType, TbwRenderer, claimEvent, getFeatureClaim, getFeatureConfigPreprocessor, injectGrid, isComponentClass, isEventClaimed, makeFlushFocusedInput, provideGrid, provideGridIcons, provideGridTypeDefaults, registerDetailRendererBridge, registerEditorMountHook, registerEditorSpecBridge, registerFeatureClaim, registerFeatureConfigPreprocessor, registerFilterPanelTypeDefaultBridge, registerResponsiveCardRendererBridge, registerTemplateBridge, registerToolPanelRendererBridge, runTemplateBridges, unclaimEvent, unregisterFeatureClaim };
+export type { CellCommitEvent, CellEditor, CellRenderer, ColumnConfig, EditorMountHook, EditorSpecBridge, FeatureConfigGetter, FeatureConfigPreprocessor, FeatureName, FilterPanel, FilterPanelTypeDefaultBridge, GridCellContext, GridConfig, InjectGridReturn, ProvideGridOptions, RowCommitEvent, RowRendererBridge, StructuralCellContext, TemplateBridge, TemplateBridgeContext, ToolPanelRendererBridge, TypeDefault, TypeDefaultRegistration };
 //# sourceMappingURL=toolbox-web-grid-angular.d.ts.map