@toolbox-web/grid 0.0.5 → 0.0.7

package/all.d.ts

@@ -20,7 +20,7 @@ declare interface AggregationRowConfig {
     /** Label when in fullWidth mode */
     label?: string;
     /** Static or computed cell values keyed by field */
-    cells?: Record<string, unknown | string | ((rows: unknown[], field: string, column?: ColumnConfig) => unknown)>;
+    cells?: Record<string, unknown | string | ((rows: unknown[], field: string, column?: ColumnConfig_2) => unknown)>;
     /** Per-field aggregator override; string maps to registered aggregator key */
     aggregators?: Record<string, AggregatorRef_3>;
 }
@@ -37,17 +37,67 @@ declare interface AggregationRowConfig {
  * - By UMD/CDN: TbwGrid.aggregatorRegistry
  * - By plugins via context: ctx.aggregatorRegistry
  */
-declare type AggregatorFn = (rows: any[], field: string, column?: any) => any;
+export declare type AggregatorFn = (rows: any[], field: string, column?: any) => any;
+
+/**
+ * Aggregators Core Registry
+ *
+ * Provides a central registry for aggregator functions.
+ * Built-in aggregators are provided by default.
+ * Plugins can register additional aggregators.
+ *
+ * The registry is exposed as a singleton object that can be accessed:
+ * - By ES module imports: import { aggregatorRegistry } from '@toolbox-web/grid'
+ * - By UMD/CDN: TbwGrid.aggregatorRegistry
+ * - By plugins via context: ctx.aggregatorRegistry
+ */
+declare type AggregatorFn_2 = (rows: any[], field: string, column?: any) => any;
 
 /** Map of field names to aggregator references */
 declare type AggregatorMap = Record<string, AggregatorRef_2>;
 
+/** Map of field names to aggregator references */
+declare type AggregatorMap_2 = Record<string, AggregatorRef_2_2>;
+
 export declare type AggregatorRef = string | ((rows: any[], field: string, column?: any) => any);
 
-declare type AggregatorRef_2 = string | AggregatorFn;
+declare type AggregatorRef_2 = string | AggregatorFn_2;
+
+declare type AggregatorRef_2_2 = string | AggregatorFn;
 
 /** Aggregator reference - string key for built-in or custom function */
-declare type AggregatorRef_3 = string | ((rows: unknown[], field: string, column?: ColumnConfig) => unknown);
+declare type AggregatorRef_3 = string | ((rows: unknown[], field: string, column?: ColumnConfig_2) => unknown);
+
+/**
+ * The aggregator registry singleton.
+ * Plugins should access this through context or the global namespace.
+ */
+export declare const aggregatorRegistry: {
+    /**
+     * Register a custom aggregator function.
+     */
+    register(name: string, fn: AggregatorFn): void;
+    /**
+     * Unregister a custom aggregator function.
+     */
+    unregister(name: string): void;
+    /**
+     * Get an aggregator function by reference.
+     */
+    get(ref: AggregatorRef_2_2 | undefined): AggregatorFn | undefined;
+    /**
+     * Run an aggregator on a set of rows.
+     */
+    run(ref: AggregatorRef_2_2 | undefined, rows: any[], field: string, column?: any): any;
+    /**
+     * Check if an aggregator exists.
+     */
+    has(name: string): boolean;
+    /**
+     * List all available aggregator names.
+     */
+    list(): string[];
+};
 
 /**
  * Base contract for a column. Public; kept intentionally lean so host apps can extend via intersection types.
@@ -95,7 +145,570 @@ export declare interface BaseColumnConfig<TRow = any, TValue = any> {
  *
  * @template TConfig - Configuration type for the plugin
  */
-export declare abstract class BaseGridPlugin<TConfig = unknown> {
+export declare abstract class BaseGridPlugin<TConfig = unknown> {
+    /** Unique plugin identifier (derived from class name by default) */
+    abstract readonly name: string;
+    /** Plugin version - override in subclass if needed */
+    readonly version: string;
+    /** CSS styles to inject into the grid's shadow DOM */
+    readonly styles?: string;
+    /** Custom cell renderers keyed by type name */
+    readonly cellRenderers?: Record<string, CellRenderer>;
+    /** Custom header renderers keyed by type name */
+    readonly headerRenderers?: Record<string, HeaderRenderer>;
+    /** Custom cell editors keyed by type name */
+    readonly cellEditors?: Record<string, CellEditor>;
+    /** The grid instance this plugin is attached to */
+    protected grid: GridElement;
+    /** Plugin configuration - merged with defaults in attach() */
+    protected config: TConfig;
+    /** User-provided configuration from constructor */
+    private readonly userConfig;
+    /**
+     * Default configuration - subclasses should override this getter.
+     * Note: This must be a getter (not property initializer) for proper inheritance
+     * since property initializers run after parent constructor.
+     */
+    protected get defaultConfig(): Partial<TConfig>;
+    constructor(config?: Partial<TConfig>);
+    /**
+     * Called when the plugin is attached to a grid.
+     * Override to set up event listeners, initialize state, etc.
+     */
+    attach(grid: GridElement): void;
+    /**
+     * Called when the plugin is detached from a grid.
+     * Override to clean up event listeners, timers, etc.
+     */
+    detach(): void;
+    /**
+     * Get another plugin instance from the same grid.
+     * Use for inter-plugin communication.
+     */
+    protected getPlugin<T extends BaseGridPlugin>(PluginClass: new (...args: any[]) => T): T | undefined;
+    /**
+     * Emit a custom event from the grid.
+     */
+    protected emit<T>(eventName: string, detail: T): void;
+    /**
+     * Request a re-render of the grid.
+     */
+    protected requestRender(): void;
+    /**
+     * Request a lightweight style update without rebuilding DOM.
+     * Use this instead of requestRender() when only CSS classes need updating.
+     */
+    protected requestAfterRender(): void;
+    /**
+     * Get the current rows from the grid.
+     */
+    protected get rows(): any[];
+    /**
+     * Get the original unfiltered/unprocessed rows from the grid.
+     * Use this when you need all source data regardless of active filters.
+     */
+    protected get sourceRows(): any[];
+    /**
+     * Get the current columns from the grid.
+     */
+    protected get columns(): ColumnConfig[];
+    /**
+     * Get only visible columns from the grid (excludes hidden).
+     * Use this for rendering that needs to match the grid template.
+     */
+    protected get visibleColumns(): ColumnConfig[];
+    /**
+     * Get the shadow root of the grid.
+     */
+    protected get shadowRoot(): ShadowRoot | null;
+    /**
+     * Get the disconnect signal for event listener cleanup.
+     * This signal is aborted when the grid disconnects from the DOM.
+     * Use this when adding event listeners that should be cleaned up automatically.
+     *
+     * Best for:
+     * - Document/window-level listeners added in attach()
+     * - Listeners on the grid element itself
+     * - Any listener that should persist across renders
+     *
+     * Not needed for:
+     * - Listeners on elements created in afterRender() (removed with element)
+     *
+     * @example
+     * element.addEventListener('click', handler, { signal: this.disconnectSignal });
+     * document.addEventListener('keydown', handler, { signal: this.disconnectSignal });
+     */
+    protected get disconnectSignal(): AbortSignal;
+    /**
+     * Get the grid-level icons configuration.
+     * Returns merged icons (user config + defaults).
+     */
+    protected get gridIcons(): typeof DEFAULT_GRID_ICONS;
+    /**
+     * Resolve an icon value to string or HTMLElement.
+     * Checks plugin config first, then grid-level icons, then defaults.
+     *
+     * @param iconKey - The icon key in GridIcons (e.g., 'expand', 'collapse')
+     * @param pluginOverride - Optional plugin-level override
+     * @returns The resolved icon value
+     */
+    protected resolveIcon(iconKey: keyof typeof DEFAULT_GRID_ICONS, pluginOverride?: IconValue): IconValue;
+    /**
+     * Set an icon value on an element.
+     * Handles both string (text/HTML) and HTMLElement values.
+     *
+     * @param element - The element to set the icon on
+     * @param icon - The icon value (string or HTMLElement)
+     */
+    protected setIcon(element: HTMLElement, icon: IconValue): void;
+    /**
+     * Log a warning message.
+     */
+    protected warn(message: string): void;
+    /**
+     * Transform rows before rendering.
+     * Called during each render cycle before rows are rendered to the DOM.
+     * Use this to filter, sort, or add computed properties to rows.
+     *
+     * @param rows - The current rows array (readonly to encourage returning a new array)
+     * @returns The modified rows array to render
+     *
+     * @example
+     * ```ts
+     * processRows(rows: readonly any[]): any[] {
+     *   // Filter out hidden rows
+     *   return rows.filter(row => !row._hidden);
+     * }
+     * ```
+     *
+     * @example
+     * ```ts
+     * processRows(rows: readonly any[]): any[] {
+     *   // Add computed properties
+     *   return rows.map(row => ({
+     *     ...row,
+     *     _fullName: `${row.firstName} ${row.lastName}`
+     *   }));
+     * }
+     * ```
+     */
+    processRows?(rows: readonly any[]): any[];
+    /**
+     * Transform columns before rendering.
+     * Called during each render cycle before column headers and cells are rendered.
+     * Use this to add, remove, or modify column definitions.
+     *
+     * @param columns - The current columns array (readonly to encourage returning a new array)
+     * @returns The modified columns array to render
+     *
+     * @example
+     * ```ts
+     * processColumns(columns: readonly ColumnConfig[]): ColumnConfig[] {
+     *   // Add a selection checkbox column
+     *   return [
+     *     { field: '_select', header: '', width: 40 },
+     *     ...columns
+     *   ];
+     * }
+     * ```
+     */
+    processColumns?(columns: readonly ColumnConfig[]): ColumnConfig[];
+    /**
+     * Called before each render cycle begins.
+     * Use this to prepare state or cache values needed during rendering.
+     *
+     * @example
+     * ```ts
+     * beforeRender(): void {
+     *   this.visibleRowCount = this.calculateVisibleRows();
+     * }
+     * ```
+     */
+    beforeRender?(): void;
+    /**
+     * Called after each render cycle completes.
+     * Use this for DOM manipulation, adding event listeners to rendered elements,
+     * or applying visual effects like selection highlights.
+     *
+     * @example
+     * ```ts
+     * afterRender(): void {
+     *   // Apply selection styling to rendered rows
+     *   const rows = this.shadowRoot?.querySelectorAll('.data-row');
+     *   rows?.forEach((row, i) => {
+     *     row.classList.toggle('selected', this.selectedRows.has(i));
+     *   });
+     * }
+     * ```
+     */
+    afterRender?(): void;
+    /**
+     * Called after scroll-triggered row rendering completes.
+     * This is a lightweight hook for applying visual state to recycled DOM elements.
+     * Use this instead of afterRender when you need to reapply styling during scroll.
+     *
+     * Performance note: This is called frequently during scroll. Keep implementation fast.
+     *
+     * @example
+     * ```ts
+     * onScrollRender(): void {
+     *   // Reapply selection state to visible cells
+     *   this.applySelectionToVisibleCells();
+     * }
+     * ```
+     */
+    onScrollRender?(): void;
+    /**
+     * Return extra height contributed by this plugin (e.g., expanded detail rows).
+     * Used to adjust scrollbar height calculations for virtualization.
+     *
+     * @returns Total extra height in pixels
+     *
+     * @example
+     * ```ts
+     * getExtraHeight(): number {
+     *   return this.expandedRows.size * this.detailHeight;
+     * }
+     * ```
+     */
+    getExtraHeight?(): number;
+    /**
+     * Return extra height that appears before a given row index.
+     * Used by virtualization to correctly calculate scroll positions when
+     * there's variable height content (like expanded detail rows) above the viewport.
+     *
+     * @param beforeRowIndex - The row index to calculate extra height before
+     * @returns Extra height in pixels that appears before this row
+     *
+     * @example
+     * ```ts
+     * getExtraHeightBefore(beforeRowIndex: number): number {
+     *   let height = 0;
+     *   for (const expandedRowIndex of this.expandedRowIndices) {
+     *     if (expandedRowIndex < beforeRowIndex) {
+     *       height += this.getDetailHeight(expandedRowIndex);
+     *     }
+     *   }
+     *   return height;
+     * }
+     * ```
+     */
+    getExtraHeightBefore?(beforeRowIndex: number): number;
+    /**
+     * Adjust the virtualization start index to render additional rows before the visible range.
+     * Use this when expanded content (like detail rows) needs its parent row to remain rendered
+     * even when the parent row itself has scrolled above the viewport.
+     *
+     * @param start - The calculated start row index
+     * @param scrollTop - The current scroll position
+     * @param rowHeight - The height of a single row
+     * @returns The adjusted start index (lower than or equal to original start)
+     *
+     * @example
+     * ```ts
+     * adjustVirtualStart(start: number, scrollTop: number, rowHeight: number): number {
+     *   // If row 5 is expanded and scrolled partially, keep it rendered
+     *   for (const expandedRowIndex of this.expandedRowIndices) {
+     *     const expandedRowTop = expandedRowIndex * rowHeight;
+     *     const expandedRowBottom = expandedRowTop + rowHeight + this.detailHeight;
+     *     if (expandedRowBottom > scrollTop && expandedRowIndex < start) {
+     *       return expandedRowIndex;
+     *     }
+     *   }
+     *   return start;
+     * }
+     * ```
+     */
+    adjustVirtualStart?(start: number, scrollTop: number, rowHeight: number): number;
+    /**
+     * Render a custom row, bypassing the default row rendering.
+     * Use this for special row types like group headers, detail rows, or footers.
+     *
+     * @param row - The row data object
+     * @param rowEl - The row DOM element to render into
+     * @param rowIndex - The index of the row in the data array
+     * @returns `true` if the plugin handled rendering (prevents default), `false`/`void` for default rendering
+     *
+     * @example
+     * ```ts
+     * renderRow(row: any, rowEl: HTMLElement, rowIndex: number): boolean | void {
+     *   if (row._isGroupHeader) {
+     *     rowEl.innerHTML = `<div class="group-header">${row._groupLabel}</div>`;
+     *     return true; // Handled - skip default rendering
+     *   }
+     *   // Return void to let default rendering proceed
+     * }
+     * ```
+     */
+    renderRow?(row: any, rowEl: HTMLElement, rowIndex: number): boolean | void;
+    /**
+     * Handle keyboard events on the grid.
+     * Called when a key is pressed while the grid or a cell has focus.
+     *
+     * @param event - The native KeyboardEvent
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onKeyDown(event: KeyboardEvent): boolean | void {
+     *   // Handle Ctrl+A for select all
+     *   if (event.ctrlKey && event.key === 'a') {
+     *     this.selectAllRows();
+     *     return true; // Prevent default browser select-all
+     *   }
+     * }
+     * ```
+     */
+    onKeyDown?(event: KeyboardEvent): boolean | void;
+    /**
+     * Handle cell click events.
+     * Called when a data cell is clicked (not headers).
+     *
+     * @param event - Cell click event with row/column context
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onCellClick(event: CellClickEvent): boolean | void {
+     *   if (event.field === '_select') {
+     *     this.toggleRowSelection(event.rowIndex);
+     *     return true; // Handled
+     *   }
+     * }
+     * ```
+     */
+    onCellClick?(event: CellClickEvent): boolean | void;
+    /**
+     * Handle row click events.
+     * Called when any part of a data row is clicked.
+     * Note: This is called in addition to onCellClick, not instead of.
+     *
+     * @param event - Row click event with row context
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onRowClick(event: RowClickEvent): boolean | void {
+     *   if (this.config.mode === 'row') {
+     *     this.selectRow(event.rowIndex, event.originalEvent);
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onRowClick?(event: RowClickEvent): boolean | void;
+    /**
+     * Handle header click events.
+     * Called when a column header is clicked. Commonly used for sorting.
+     *
+     * @param event - Header click event with column context
+     * @returns `true` to prevent default behavior and stop propagation, `false`/`void` to allow default
+     *
+     * @example
+     * ```ts
+     * onHeaderClick(event: HeaderClickEvent): boolean | void {
+     *   if (event.column.sortable !== false) {
+     *     this.toggleSort(event.field);
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onHeaderClick?(event: HeaderClickEvent): boolean | void;
+    /**
+     * Handle scroll events on the grid viewport.
+     * Called during scrolling. Note: This may be called frequently; debounce if needed.
+     *
+     * @param event - Scroll event with scroll position and viewport dimensions
+     *
+     * @example
+     * ```ts
+     * onScroll(event: ScrollEvent): void {
+     *   // Update sticky column positions
+     *   this.updateStickyPositions(event.scrollLeft);
+     * }
+     * ```
+     */
+    onScroll?(event: ScrollEvent): void;
+    /**
+     * Handle cell mousedown events.
+     * Used for initiating drag operations like range selection or column resize.
+     *
+     * @param event - Mouse event with cell context
+     * @returns `true` to indicate drag started (prevents text selection), `false`/`void` otherwise
+     *
+     * @example
+     * ```ts
+     * onCellMouseDown(event: CellMouseEvent): boolean | void {
+     *   if (event.rowIndex !== undefined && this.config.mode === 'range') {
+     *     this.startDragSelection(event.rowIndex, event.colIndex);
+     *     return true; // Prevent text selection
+     *   }
+     * }
+     * ```
+     */
+    onCellMouseDown?(event: CellMouseEvent): boolean | void;
+    /**
+     * Handle cell mousemove events during drag operations.
+     * Only called when a drag is in progress (after mousedown returned true).
+     *
+     * @param event - Mouse event with current cell context
+     * @returns `true` to continue handling the drag, `false`/`void` otherwise
+     *
+     * @example
+     * ```ts
+     * onCellMouseMove(event: CellMouseEvent): boolean | void {
+     *   if (this.isDragging && event.rowIndex !== undefined) {
+     *     this.extendSelection(event.rowIndex, event.colIndex);
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onCellMouseMove?(event: CellMouseEvent): boolean | void;
+    /**
+     * Handle cell mouseup events to end drag operations.
+     *
+     * @param event - Mouse event with final cell context
+     * @returns `true` if drag was finalized, `false`/`void` otherwise
+     *
+     * @example
+     * ```ts
+     * onCellMouseUp(event: CellMouseEvent): boolean | void {
+     *   if (this.isDragging) {
+     *     this.finalizeDragSelection();
+     *     this.isDragging = false;
+     *     return true;
+     *   }
+     * }
+     * ```
+     */
+    onCellMouseUp?(event: CellMouseEvent): boolean | void;
+    /**
+     * Provide context menu items when right-clicking on the grid.
+     * Multiple plugins can contribute items; they are merged into a single menu.
+     *
+     * @param params - Context about where the menu was triggered (row, column, etc.)
+     * @returns Array of menu items to display
+     *
+     * @example
+     * ```ts
+     * getContextMenuItems(params: ContextMenuParams): ContextMenuItem[] {
+     *   if (params.isHeader) {
+     *     return [
+     *       { id: 'sort-asc', label: 'Sort Ascending', action: () => this.sortAsc(params.field) },
+     *       { id: 'sort-desc', label: 'Sort Descending', action: () => this.sortDesc(params.field) },
+     *     ];
+     *   }
+     *   return [
+     *     { id: 'copy', label: 'Copy Cell', action: () => this.copyCell(params) },
+     *   ];
+     * }
+     * ```
+     */
+    getContextMenuItems?(params: ContextMenuParams): ContextMenuItem[];
+    /**
+     * Contribute plugin-specific state for a column.
+     * Called by the grid when collecting column state for serialization.
+     * Plugins can add their own properties to the column state.
+     *
+     * @param field - The field name of the column
+     * @returns Partial column state with plugin-specific properties, or undefined if no state to contribute
+     *
+     * @example
+     * ```ts
+     * getColumnState(field: string): Partial<ColumnState> | undefined {
+     *   const filterModel = this.filterModels.get(field);
+     *   if (filterModel) {
+     *     // Uses module augmentation to add filter property to ColumnState
+     *     return { filter: filterModel } as Partial<ColumnState>;
+     *   }
+     *   return undefined;
+     * }
+     * ```
+     */
+    getColumnState?(field: string): Partial<ColumnState> | undefined;
+    /**
+     * Apply plugin-specific state to a column.
+     * Called by the grid when restoring column state from serialized data.
+     * Plugins should restore their internal state based on the provided state.
+     *
+     * @param field - The field name of the column
+     * @param state - The column state to apply (may contain plugin-specific properties)
+     *
+     * @example
+     * ```ts
+     * applyColumnState(field: string, state: ColumnState): void {
+     *   // Check for filter property added via module augmentation
+     *   const filter = (state as any).filter;
+     *   if (filter) {
+     *     this.filterModels.set(field, filter);
+     *     this.applyFilter();
+     *   }
+     * }
+     * ```
+     */
+    applyColumnState?(field: string, state: ColumnState): void;
+    /**
+     * Register a tool panel for this plugin.
+     * Return undefined if plugin has no tool panel.
+     * The shell will create a toolbar toggle button and render the panel content
+     * when the user opens the panel.
+     *
+     * @returns Tool panel definition, or undefined if plugin has no panel
+     *
+     * @example
+     * ```ts
+     * getToolPanel(): ToolPanelDefinition | undefined {
+     *   return {
+     *     id: 'columns',
+     *     title: 'Columns',
+     *     icon: '☰',
+     *     tooltip: 'Show/hide columns',
+     *     order: 10,
+     *     render: (container) => {
+     *       this.renderColumnList(container);
+     *       return () => this.cleanup();
+     *     },
+     *   };
+     * }
+     * ```
+     */
+    getToolPanel?(): ToolPanelDefinition | undefined;
+    /**
+     * Register content for the shell header center section.
+     * Return undefined if plugin has no header content.
+     * Examples: search input, selection summary, status indicators.
+     *
+     * @returns Header content definition, or undefined if plugin has no header content
+     *
+     * @example
+     * ```ts
+     * getHeaderContent(): HeaderContentDefinition | undefined {
+     *   return {
+     *     id: 'quick-filter',
+     *     order: 10,
+     *     render: (container) => {
+     *       const input = document.createElement('input');
+     *       input.type = 'text';
+     *       input.placeholder = 'Search...';
+     *       input.addEventListener('input', this.handleInput);
+     *       container.appendChild(input);
+     *       return () => input.removeEventListener('input', this.handleInput);
+     *     },
+     *   };
+     * }
+     * ```
+     */
+    getHeaderContent?(): HeaderContentDefinition | undefined;
+}
+
+/**
+ * Abstract base class for all grid plugins.
+ *
+ * @template TConfig - Configuration type for the plugin
+ */
+declare abstract class BaseGridPlugin_2<TConfig = unknown> {
     /** Unique plugin identifier (derived from class name by default) */
     abstract readonly name: string;
     /** Plugin version - override in subclass if needed */
@@ -103,11 +716,11 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
     /** CSS styles to inject into the grid's shadow DOM */
     readonly styles?: string;
     /** Custom cell renderers keyed by type name */
-    readonly cellRenderers?: Record<string, CellRenderer>;
+    readonly cellRenderers?: Record<string, CellRenderer_2>;
     /** Custom header renderers keyed by type name */
-    readonly headerRenderers?: Record<string, HeaderRenderer>;
+    readonly headerRenderers?: Record<string, HeaderRenderer_2>;
     /** Custom cell editors keyed by type name */
-    readonly cellEditors?: Record<string, CellEditor>;
+    readonly cellEditors?: Record<string, CellEditor_2>;
     /** The grid instance this plugin is attached to */
     protected grid: GridElement_2;
     /** Plugin configuration - merged with defaults in attach() */
@@ -135,7 +748,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * Get another plugin instance from the same grid.
      * Use for inter-plugin communication.
      */
-    protected getPlugin<T extends BaseGridPlugin>(PluginClass: new (...args: any[]) => T): T | undefined;
+    protected getPlugin<T extends BaseGridPlugin_2>(PluginClass: new (...args: any[]) => T): T | undefined;
     /**
      * Emit a custom event from the grid.
      */
@@ -161,12 +774,12 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
     /**
      * Get the current columns from the grid.
      */
-    protected get columns(): ColumnConfig[];
+    protected get columns(): ColumnConfig_2[];
     /**
      * Get only visible columns from the grid (excludes hidden).
      * Use this for rendering that needs to match the grid template.
      */
-    protected get visibleColumns(): ColumnConfig[];
+    protected get visibleColumns(): ColumnConfig_2[];
     /**
      * Get the shadow root of the grid.
      */
@@ -189,6 +802,28 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * document.addEventListener('keydown', handler, { signal: this.disconnectSignal });
      */
     protected get disconnectSignal(): AbortSignal;
+    /**
+     * Get the grid-level icons configuration.
+     * Returns merged icons (user config + defaults).
+     */
+    protected get gridIcons(): typeof DEFAULT_GRID_ICONS_2;
+    /**
+     * Resolve an icon value to string or HTMLElement.
+     * Checks plugin config first, then grid-level icons, then defaults.
+     *
+     * @param iconKey - The icon key in GridIcons (e.g., 'expand', 'collapse')
+     * @param pluginOverride - Optional plugin-level override
+     * @returns The resolved icon value
+     */
+    protected resolveIcon(iconKey: keyof typeof DEFAULT_GRID_ICONS_2, pluginOverride?: IconValue_2): IconValue_2;
+    /**
+     * Set an icon value on an element.
+     * Handles both string (text/HTML) and HTMLElement values.
+     *
+     * @param element - The element to set the icon on
+     * @param icon - The icon value (string or HTMLElement)
+     */
+    protected setIcon(element: HTMLElement, icon: IconValue_2): void;
     /**
      * Log a warning message.
      */
@@ -240,7 +875,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    processColumns?(columns: readonly ColumnConfig[]): ColumnConfig[];
+    processColumns?(columns: readonly ColumnConfig_2[]): ColumnConfig_2[];
     /**
      * Called before each render cycle begins.
      * Use this to prepare state or cache values needed during rendering.
@@ -286,6 +921,68 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * ```
      */
     onScrollRender?(): void;
+    /**
+     * Return extra height contributed by this plugin (e.g., expanded detail rows).
+     * Used to adjust scrollbar height calculations for virtualization.
+     *
+     * @returns Total extra height in pixels
+     *
+     * @example
+     * ```ts
+     * getExtraHeight(): number {
+     *   return this.expandedRows.size * this.detailHeight;
+     * }
+     * ```
+     */
+    getExtraHeight?(): number;
+    /**
+     * Return extra height that appears before a given row index.
+     * Used by virtualization to correctly calculate scroll positions when
+     * there's variable height content (like expanded detail rows) above the viewport.
+     *
+     * @param beforeRowIndex - The row index to calculate extra height before
+     * @returns Extra height in pixels that appears before this row
+     *
+     * @example
+     * ```ts
+     * getExtraHeightBefore(beforeRowIndex: number): number {
+     *   let height = 0;
+     *   for (const expandedRowIndex of this.expandedRowIndices) {
+     *     if (expandedRowIndex < beforeRowIndex) {
+     *       height += this.getDetailHeight(expandedRowIndex);
+     *     }
+     *   }
+     *   return height;
+     * }
+     * ```
+     */
+    getExtraHeightBefore?(beforeRowIndex: number): number;
+    /**
+     * Adjust the virtualization start index to render additional rows before the visible range.
+     * Use this when expanded content (like detail rows) needs its parent row to remain rendered
+     * even when the parent row itself has scrolled above the viewport.
+     *
+     * @param start - The calculated start row index
+     * @param scrollTop - The current scroll position
+     * @param rowHeight - The height of a single row
+     * @returns The adjusted start index (lower than or equal to original start)
+     *
+     * @example
+     * ```ts
+     * adjustVirtualStart(start: number, scrollTop: number, rowHeight: number): number {
+     *   // If row 5 is expanded and scrolled partially, keep it rendered
+     *   for (const expandedRowIndex of this.expandedRowIndices) {
+     *     const expandedRowTop = expandedRowIndex * rowHeight;
+     *     const expandedRowBottom = expandedRowTop + rowHeight + this.detailHeight;
+     *     if (expandedRowBottom > scrollTop && expandedRowIndex < start) {
+     *       return expandedRowIndex;
+     *     }
+     *   }
+     *   return start;
+     * }
+     * ```
+     */
+    adjustVirtualStart?(start: number, scrollTop: number, rowHeight: number): number;
     /**
      * Render a custom row, bypassing the default row rendering.
      * Use this for special row types like group headers, detail rows, or footers.
@@ -343,7 +1040,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    onCellClick?(event: CellClickEvent): boolean | void;
+    onCellClick?(event: CellClickEvent_2): boolean | void;
     /**
      * Handle row click events.
      * Called when any part of a data row is clicked.
@@ -362,7 +1059,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    onRowClick?(event: RowClickEvent): boolean | void;
+    onRowClick?(event: RowClickEvent_2): boolean | void;
     /**
      * Handle header click events.
      * Called when a column header is clicked. Commonly used for sorting.
@@ -380,7 +1077,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    onHeaderClick?(event: HeaderClickEvent): boolean | void;
+    onHeaderClick?(event: HeaderClickEvent_2): boolean | void;
     /**
      * Handle scroll events on the grid viewport.
      * Called during scrolling. Note: This may be called frequently; debounce if needed.
@@ -395,7 +1092,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    onScroll?(event: ScrollEvent): void;
+    onScroll?(event: ScrollEvent_2): void;
     /**
      * Handle cell mousedown events.
      * Used for initiating drag operations like range selection or column resize.
@@ -413,7 +1110,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    onCellMouseDown?(event: CellMouseEvent): boolean | void;
+    onCellMouseDown?(event: CellMouseEvent_2): boolean | void;
     /**
      * Handle cell mousemove events during drag operations.
      * Only called when a drag is in progress (after mousedown returned true).
@@ -431,7 +1128,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    onCellMouseMove?(event: CellMouseEvent): boolean | void;
+    onCellMouseMove?(event: CellMouseEvent_2): boolean | void;
     /**
      * Handle cell mouseup events to end drag operations.
      *
@@ -449,7 +1146,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    onCellMouseUp?(event: CellMouseEvent): boolean | void;
+    onCellMouseUp?(event: CellMouseEvent_2): boolean | void;
     /**
      * Provide context menu items when right-clicking on the grid.
      * Multiple plugins can contribute items; they are merged into a single menu.
@@ -472,7 +1169,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    getContextMenuItems?(params: ContextMenuParams): ContextMenuItem[];
+    getContextMenuItems?(params: ContextMenuParams_2): ContextMenuItem_2[];
     /**
      * Contribute plugin-specific state for a column.
      * Called by the grid when collecting column state for serialization.
@@ -493,7 +1190,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    getColumnState?(field: string): Partial<ColumnState> | undefined;
+    getColumnState?(field: string): Partial<ColumnState_2> | undefined;
     /**
      * Apply plugin-specific state to a column.
      * Called by the grid when restoring column state from serialized data.
@@ -514,7 +1211,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    applyColumnState?(field: string, state: ColumnState): void;
+    applyColumnState?(field: string, state: ColumnState_2): void;
     /**
      * Register a tool panel for this plugin.
      * Return undefined if plugin has no tool panel.
@@ -540,7 +1237,7 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    getToolPanel?(): ToolPanelDefinition | undefined;
+    getToolPanel?(): ToolPanelDefinition_2 | undefined;
     /**
      * Register content for the shell header center section.
      * Return undefined if plugin has no header content.
@@ -566,13 +1263,26 @@ export declare abstract class BaseGridPlugin<TConfig = unknown> {
      * }
      * ```
      */
-    getHeaderContent?(): HeaderContentDefinition | undefined;
+    getHeaderContent?(): HeaderContentDefinition_2 | undefined;
+}
+
+/**
+ * Cell click event
+ */
+export declare interface CellClickEvent {
+    rowIndex: number;
+    colIndex: number;
+    field: string;
+    value: any;
+    row: any;
+    cellEl: HTMLElement;
+    originalEvent: MouseEvent;
 }
 
 /**
  * Cell click event
  */
-declare interface CellClickEvent {
+declare interface CellClickEvent_2 {
     rowIndex: number;
     colIndex: number;
     field: string;
@@ -612,7 +1322,15 @@ declare interface CellContext<T = any> {
 /**
  * Cell coordinates
  */
-declare interface CellCoords {
+export declare interface CellCoords {
+    row: number;
+    col: number;
+}
+
+/**
+ * Cell coordinates
+ */
+declare interface CellCoords_2 {
     row: number;
     col: number;
 }
@@ -620,16 +1338,25 @@ declare interface CellCoords {
 /**
  * Cell editor interface for plugins.
  */
-declare interface CellEditor {
+export declare interface CellEditor {
     create(ctx: PluginCellRenderContext, commitFn: (value: any) => void, cancelFn: () => void): HTMLElement;
     getValue?(element: HTMLElement): any;
     focus?(element: HTMLElement): void;
 }
 
+/**
+ * Cell editor interface for plugins.
+ */
+declare interface CellEditor_2 {
+    create(ctx: PluginCellRenderContext_2, commitFn: (value: any) => void, cancelFn: () => void): HTMLElement;
+    getValue?(element: HTMLElement): any;
+    focus?(element: HTMLElement): void;
+}
+
 /**
  * Cell mouse event (for drag operations, selection, etc.)
  */
-declare interface CellMouseEvent {
+export declare interface CellMouseEvent {
     /** Event type: mousedown, mousemove, or mouseup */
     type: 'mousedown' | 'mousemove' | 'mouseup';
     /** Row index, undefined if not over a data cell */
@@ -656,6 +1383,36 @@ declare interface CellMouseEvent {
     originalEvent: MouseEvent;
 }
 
+/**
+ * Cell mouse event (for drag operations, selection, etc.)
+ */
+declare interface CellMouseEvent_2 {
+    /** Event type: mousedown, mousemove, or mouseup */
+    type: 'mousedown' | 'mousemove' | 'mouseup';
+    /** Row index, undefined if not over a data cell */
+    rowIndex?: number;
+    /** Column index, undefined if not over a cell */
+    colIndex?: number;
+    /** Field name, undefined if not over a cell */
+    field?: string;
+    /** Cell value, undefined if not over a data cell */
+    value?: unknown;
+    /** Row data object, undefined if not over a data row */
+    row?: unknown;
+    /** Column configuration, undefined if not over a column */
+    column?: ColumnConfig_2;
+    /** The cell element, undefined if not over a cell */
+    cellElement?: HTMLElement;
+    /** The row element, undefined if not over a row */
+    rowElement?: HTMLElement;
+    /** Whether the event is over a header cell */
+    isHeader: boolean;
+    /** Cell coordinates if over a valid data cell */
+    cell?: CellCoords_2;
+    /** The original mouse event */
+    originalEvent: MouseEvent;
+}
+
 /** Public representation of a cell range (for events) */
 export declare interface CellRange {
     /** Starting cell coordinates */
@@ -670,6 +1427,20 @@ export declare interface CellRange {
     };
 }
 
+/** Public representation of a cell range (for events) */
+declare interface CellRange_2 {
+    /** Starting cell coordinates */
+    from: {
+        row: number;
+        col: number;
+    };
+    /** Ending cell coordinates */
+    to: {
+        row: number;
+        col: number;
+    };
+}
+
 /**
  * Context passed to custom view renderers (pure display – no commit helpers).
  */
@@ -684,10 +1455,29 @@ export declare interface CellRenderContext<TRow = any, TValue = any> {
     column: ColumnConfig<TRow>;
 }
 
+/**
+ * Context passed to custom view renderers (pure display – no commit helpers).
+ */
+declare interface CellRenderContext_2<TRow = any, TValue = any> {
+    /** Row object for the cell being rendered. */
+    row: TRow;
+    /** Value at field. */
+    value: TValue;
+    /** Field key. */
+    field: keyof TRow & string;
+    /** Column configuration reference. */
+    column: ColumnConfig_2<TRow>;
+}
+
+/**
+ * Cell renderer function type for plugins.
+ */
+export declare type CellRenderer = (ctx: PluginCellRenderContext) => string | HTMLElement;
+
 /**
  * Cell renderer function type for plugins.
  */
-declare type CellRenderer = (ctx: PluginCellRenderContext) => string | HTMLElement;
+declare type CellRenderer_2 = (ctx: PluginCellRenderContext_2) => string | HTMLElement;
 
 /** Emitted when the changed rows tracking set is cleared programmatically. */
 export declare interface ChangedRowsResetDetail<TRow = any> {
@@ -726,7 +1516,7 @@ declare interface ClipboardConfig {
  * new ClipboardPlugin({ includeHeaders: true })
  * ```
  */
-export declare class ClipboardPlugin extends BaseGridPlugin<ClipboardConfig> {
+export declare class ClipboardPlugin extends BaseGridPlugin_2<ClipboardConfig> {
     #private;
     readonly name = "clipboard";
     readonly version = "1.0.0";
@@ -785,6 +1575,30 @@ export declare interface ColumnConfig<TRow = any> extends BaseColumnConfig<TRow,
     lockVisible?: boolean;
 }
 
+/**
+ * Full column configuration including optional custom view/renderer & grouping metadata.
+ */
+declare interface ColumnConfig_2<TRow = any> extends BaseColumnConfig<TRow, any> {
+    /** Optional custom view renderer used instead of default text rendering */
+    viewRenderer?: ColumnViewRenderer_2<TRow, any>;
+    /** External view spec (lets host app mount any framework component) */
+    externalView?: {
+        component: any;
+        props?: Record<string, any>;
+        mount?: (options: {
+            placeholder: HTMLElement;
+            context: CellRenderContext_2<TRow, any>;
+            spec: any;
+        }) => void | {
+            dispose?: () => void;
+        };
+    };
+    /** Whether the column is initially hidden */
+    hidden?: boolean;
+    /** Prevent this column from being hidden by the visibility plugin */
+    lockVisible?: boolean;
+}
+
 export declare type ColumnConfigMap<TRow = any> = ColumnConfig<TRow>[];
 
 /**
@@ -828,7 +1642,7 @@ declare interface ColumnGroup<T = any> {
     /** Display label for the group header */
     label?: string;
     /** Columns belonging to this group */
-    columns: ColumnConfig<T>[];
+    columns: ColumnConfig_2<T>[];
     /** Index of first column in this group */
     firstIndex: number;
 }
@@ -862,6 +1676,16 @@ export declare interface ColumnSortState {
     priority: number;
 }
 
+/**
+ * Sort state for a column
+ */
+declare interface ColumnSortState_2 {
+    /** Sort direction */
+    direction: 'asc' | 'desc';
+    /** Priority for multi-sort (0 = primary, 1 = secondary, etc.) */
+    priority: number;
+}
+
 /**
  * State for a single column. Captures user-driven changes at runtime.
  * Plugins can extend this interface via module augmentation to add their own state.
@@ -889,8 +1713,37 @@ export declare interface ColumnState {
     sort?: ColumnSortState;
 }
 
+/**
+ * State for a single column. Captures user-driven changes at runtime.
+ * Plugins can extend this interface via module augmentation to add their own state.
+ *
+ * @example
+ * ```ts
+ * // In filtering plugin
+ * declare module '@toolbox-web/grid' {
+ *   interface ColumnState {
+ *     filter?: FilterValue;
+ *   }
+ * }
+ * ```
+ */
+declare interface ColumnState {
+    /** Column field identifier */
+    field: string;
+    /** Position index after reordering (0-based) */
+    order: number;
+    /** Width in pixels (undefined = use default) */
+    width?: number;
+    /** Visibility state */
+    visible: boolean;
+    /** Sort state (undefined = not sorted) */
+    sort?: ColumnSortState_2;
+}
+
 export declare type ColumnViewRenderer<TRow = any, TValue = any> = (ctx: CellRenderContext<TRow, TValue>) => Node | string | void;
 
+declare type ColumnViewRenderer_2<TRow = any, TValue = any> = (ctx: CellRenderContext_2<TRow, TValue>) => Node | string | void;
+
 /**
  * Column Virtualization Plugin Types
  *
@@ -916,7 +1769,7 @@ declare interface ColumnVirtualizationConfig {
  * new ColumnVirtualizationPlugin({ threshold: 30, overscan: 3 })
  * ```
  */
-export declare class ColumnVirtualizationPlugin extends BaseGridPlugin<ColumnVirtualizationConfig> {
+export declare class ColumnVirtualizationPlugin extends BaseGridPlugin_2<ColumnVirtualizationConfig> {
     readonly name = "columnVirtualization";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<ColumnVirtualizationConfig>;
@@ -929,9 +1782,9 @@ export declare class ColumnVirtualizationPlugin extends BaseGridPlugin<ColumnVir
     private columnOffsets;
     attach(grid: GridElement_2): void;
     detach(): void;
-    processColumns(columns: readonly ColumnConfig[]): ColumnConfig[];
+    processColumns(columns: readonly ColumnConfig_2[]): ColumnConfig_2[];
     afterRender(): void;
-    onScroll(event: ScrollEvent): void;
+    onScroll(event: ScrollEvent_2): void;
     /**
      * Check if column virtualization is currently active.
      */
@@ -966,20 +1819,33 @@ declare interface ContextMenuConfig {
     /** Whether the context menu is enabled (default: true) */
     enabled?: boolean;
     /** Menu items - static array or function returning items */
-    items?: ContextMenuItem_2[] | ((params: ContextMenuParams_2) => ContextMenuItem_2[]);
+    items?: ContextMenuItem_3[] | ((params: ContextMenuParams_3) => ContextMenuItem_3[]);
+}
+
+/**
+ * Context menu item
+ */
+export declare interface ContextMenuItem {
+    id: string;
+    label: string;
+    icon?: string;
+    disabled?: boolean;
+    separator?: boolean;
+    children?: ContextMenuItem[];
+    action?: (params: ContextMenuParams) => void;
 }
 
 /**
  * Context menu item
  */
-declare interface ContextMenuItem {
+declare interface ContextMenuItem_2 {
     id: string;
     label: string;
     icon?: string;
     disabled?: boolean;
     separator?: boolean;
-    children?: ContextMenuItem[];
-    action?: (params: ContextMenuParams) => void;
+    children?: ContextMenuItem_2[];
+    action?: (params: ContextMenuParams_2) => void;
 }
 
 /**
@@ -991,7 +1857,7 @@ declare interface ContextMenuItem {
  * Context menu item definition.
  * Supports icons, shortcuts, submenus, separators, and dynamic disabled/hidden states.
  */
-declare interface ContextMenuItem_2 {
+declare interface ContextMenuItem_3 {
     /** Unique identifier for the menu item */
     id: string;
     /** Display label for the menu item */
@@ -1001,13 +1867,13 @@ declare interface ContextMenuItem_2 {
     /** Optional keyboard shortcut hint (display only) */
     shortcut?: string;
     /** Whether the item is disabled (static or dynamic) */
-    disabled?: boolean | ((params: ContextMenuParams_2) => boolean);
+    disabled?: boolean | ((params: ContextMenuParams_3) => boolean);
     /** Whether the item is hidden (static or dynamic) */
-    hidden?: boolean | ((params: ContextMenuParams_2) => boolean);
+    hidden?: boolean | ((params: ContextMenuParams_3) => boolean);
     /** Action handler when the item is clicked */
-    action?: (params: ContextMenuParams_2) => void;
+    action?: (params: ContextMenuParams_3) => void;
     /** Nested submenu items */
-    subMenu?: ContextMenuItem_2[];
+    subMenu?: ContextMenuItem_3[];
     /** Whether this is a separator (id and name required but ignored) */
     separator?: boolean;
     /** Optional CSS class to add to the menu item */
@@ -1017,7 +1883,7 @@ declare interface ContextMenuItem_2 {
 /**
  * Context menu parameters
  */
-declare interface ContextMenuParams {
+export declare interface ContextMenuParams {
     x: number;
     y: number;
     rowIndex?: number;
@@ -1029,11 +1895,26 @@ declare interface ContextMenuParams {
     isHeader?: boolean;
 }
 
+/**
+ * Context menu parameters
+ */
+declare interface ContextMenuParams_2 {
+    x: number;
+    y: number;
+    rowIndex?: number;
+    colIndex?: number;
+    field?: string;
+    value?: any;
+    row?: any;
+    column?: ColumnConfig_2;
+    isHeader?: boolean;
+}
+
 /**
  * Parameters passed to context menu callbacks.
  * Provides context about what element triggered the menu.
  */
-declare interface ContextMenuParams_2 {
+declare interface ContextMenuParams_3 {
     /** The row data object (null for header clicks) */
     row: unknown;
     /** The row index (-1 for header clicks) */
@@ -1067,7 +1948,7 @@ declare interface ContextMenuParams_2 {
  * })
  * ```
  */
-export declare class ContextMenuPlugin extends BaseGridPlugin<ContextMenuConfig> {
+export declare class ContextMenuPlugin extends BaseGridPlugin_2<ContextMenuConfig> {
     readonly name = "contextMenu";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<ContextMenuConfig>;
@@ -1085,7 +1966,7 @@ export declare class ContextMenuPlugin extends BaseGridPlugin<ContextMenuConfig>
      * @param y - Y coordinate
      * @param params - Partial context menu parameters
      */
-    showMenu(x: number, y: number, params: Partial<ContextMenuParams_2>): void;
+    showMenu(x: number, y: number, params: Partial<ContextMenuParams_3>): void;
     /**
      * Hide the context menu.
      */
@@ -1146,7 +2027,7 @@ export declare type DataGridCustomEvent<K extends keyof DataGridEventMap<any>, T
  * @cssprop --tbw-color-bg - Background color
  * @cssprop --tbw-color-fg - Foreground/text color
  */
-declare class DataGridElement<T = any> extends HTMLElement implements InternalGrid<T> {
+export declare class DataGridElement<T = any> extends HTMLElement implements InternalGrid<T> {
     #private;
     static readonly tagName = "tbw-grid";
     _rows: T[];
@@ -1394,8 +2275,6 @@ declare class DataGridElement<T = any> extends HTMLElement implements InternalGr
      */
     refreshVirtualWindow(force?: boolean): void;
 }
-export { DataGridElement }
-export { DataGridElement as GridElement }
 
 /**
  * The compiled webcomponent interface for DataGrid
@@ -1422,6 +2301,12 @@ declare interface DataRowModelItem {
     rowIndex: number;
 }
 
+/** Default icons used when not overridden */
+export declare const DEFAULT_GRID_ICONS: Required<GridIcons>;
+
+/** Default icons used when not overridden */
+declare const DEFAULT_GRID_ICONS_2: Required<GridIcons_2>;
+
 export declare type DGEventName = (typeof DGEvents)[keyof typeof DGEvents];
 
 export declare const DGEvents: {
@@ -1453,6 +2338,22 @@ export declare interface EditAction {
     timestamp: number;
 }
 
+/** Represents a single edit action that can be undone/redone */
+declare interface EditAction_2 {
+    /** Type of action - currently only 'cell-edit' is supported */
+    type: 'cell-edit';
+    /** The row index where the edit occurred */
+    rowIndex: number;
+    /** The field (column key) that was edited */
+    field: string;
+    /** The value before the edit */
+    oldValue: unknown;
+    /** The value after the edit */
+    newValue: unknown;
+    /** Unix timestamp when the edit occurred */
+    timestamp: number;
+}
+
 /**
  * Internal editor execution context extending the generic cell context with commit helpers.
  */
@@ -1483,6 +2384,14 @@ declare interface ExportConfig {
 /** Supported export formats */
 export declare type ExportFormat = 'csv' | 'excel' | 'json';
 
+/**
+ * Export Plugin Types
+ *
+ * Type definitions for the data export feature.
+ */
+/** Supported export formats */
+declare type ExportFormat_2 = 'csv' | 'excel' | 'json';
+
 /** Parameters for a specific export operation */
 export declare interface ExportParams {
     /** Export format */
@@ -1501,6 +2410,24 @@ export declare interface ExportParams {
     processHeader?: (header: string, field: string) => string;
 }
 
+/** Parameters for a specific export operation */
+declare interface ExportParams_2 {
+    /** Export format */
+    format: ExportFormat_2;
+    /** File name for the export (without extension) */
+    fileName?: string;
+    /** Specific column fields to export */
+    columns?: string[];
+    /** Specific row indices to export */
+    rowIndices?: number[];
+    /** Include column headers in export */
+    includeHeaders?: boolean;
+    /** Custom cell value processor */
+    processCell?: (value: any, field: string, row: any) => any;
+    /** Custom header processor */
+    processHeader?: (header: string, field: string) => string;
+}
+
 /**
  * Export Plugin for tbw-grid
  *
@@ -1514,7 +2441,7 @@ export declare interface ExportParams {
  * })
  * ```
  */
-export declare class ExportPlugin extends BaseGridPlugin<ExportConfig> {
+export declare class ExportPlugin extends BaseGridPlugin_2<ExportConfig> {
     readonly name = "export";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<ExportConfig>;
@@ -1526,17 +2453,17 @@ export declare class ExportPlugin extends BaseGridPlugin<ExportConfig> {
      * Export data to CSV format.
      * @param params - Optional export parameters
      */
-    exportCsv(params?: Partial<ExportParams>): void;
+    exportCsv(params?: Partial<ExportParams_2>): void;
     /**
      * Export data to Excel format (XML Spreadsheet).
      * @param params - Optional export parameters
      */
-    exportExcel(params?: Partial<ExportParams>): void;
+    exportExcel(params?: Partial<ExportParams_2>): void;
     /**
      * Export data to JSON format.
      * @param params - Optional export parameters
      */
-    exportJson(params?: Partial<ExportParams>): void;
+    exportJson(params?: Partial<ExportParams_2>): void;
     /**
      * Check if an export is currently in progress.
      * @returns Whether export is in progress
@@ -1547,7 +2474,7 @@ export declare class ExportPlugin extends BaseGridPlugin<ExportConfig> {
      * @returns Export info or null if no export has occurred
      */
     getLastExport(): {
-        format: ExportFormat;
+        format: ExportFormat_2;
         timestamp: Date;
     } | null;
 }
@@ -1578,6 +2505,22 @@ export declare interface ExternalMountViewDetail<TRow = any> {
 
 /** Configuration options for the filtering plugin */
 export declare interface FilterConfig {
+    /** Whether filtering is enabled (default: true) */
+    enabled?: boolean;
+    /** Debounce delay in ms for filter input (default: 300) */
+    debounceMs?: number;
+    /** Whether text filtering is case sensitive (default: false) */
+    caseSensitive?: boolean;
+    /** Whether to trim whitespace from filter input (default: true) */
+    trimInput?: boolean;
+    /** Use Web Worker for filtering large datasets >1000 rows (default: true) */
+    useWorker?: boolean;
+    /** Custom filter panel renderer (replaces default panel content) */
+    filterPanelRenderer?: FilterPanelRenderer_2;
+}
+
+/** Configuration options for the filtering plugin */
+declare interface FilterConfig_2 {
     /** Whether filtering is enabled (default: true) */
     enabled?: boolean;
     /** Debounce delay in ms for filter input (default: 300) */
@@ -1600,10 +2543,10 @@ export declare interface FilterConfig {
  * new FilteringPlugin({ enabled: true, debounceMs: 300 })
  * ```
  */
-export declare class FilteringPlugin extends BaseGridPlugin<FilterConfig> {
+export declare class FilteringPlugin extends BaseGridPlugin_2<FilterConfig_2> {
     readonly name = "filtering";
     readonly version = "1.0.0";
-    protected get defaultConfig(): Partial<FilterConfig>;
+    protected get defaultConfig(): Partial<FilterConfig_2>;
     private filters;
     private cachedResult;
     private cacheKey;
@@ -1624,23 +2567,23 @@ export declare class FilteringPlugin extends BaseGridPlugin<FilterConfig> {
      * Set a filter on a specific field.
      * Pass null to remove the filter.
      */
-    setFilter(field: string, filter: Omit<FilterModel, 'field'> | null): void;
+    setFilter(field: string, filter: Omit<FilterModel_2, 'field'> | null): void;
     /**
      * Get the current filter for a field.
      */
-    getFilter(field: string): FilterModel | undefined;
+    getFilter(field: string): FilterModel_2 | undefined;
     /**
      * Get all active filters.
      */
-    getFilters(): FilterModel[];
+    getFilters(): FilterModel_2[];
     /**
      * Alias for getFilters() to match functional API naming.
      */
-    getFilterModel(): FilterModel[];
+    getFilterModel(): FilterModel_2[];
     /**
      * Set filters from an array (replaces all existing filters).
      */
-    setFilterModel(filters: FilterModel[]): void;
+    setFilterModel(filters: FilterModel_2[]): void;
     /**
      * Clear all filters.
      */
@@ -1660,7 +2603,7 @@ export declare class FilteringPlugin extends BaseGridPlugin<FilterConfig> {
     /**
      * Get all active filters (alias for getFilters).
      */
-    getActiveFilters(): FilterModel[];
+    getActiveFilters(): FilterModel_2[];
     /**
      * Get unique values for a field (for set filter dropdowns).
      * Uses sourceRows to include all values regardless of current filter.
@@ -1697,11 +2640,11 @@ export declare class FilteringPlugin extends BaseGridPlugin<FilterConfig> {
     /**
      * Return filter state for a column if it has an active filter.
      */
-    getColumnState(field: string): Partial<ColumnState> | undefined;
+    getColumnState(field: string): Partial<ColumnState_2> | undefined;
     /**
      * Apply filter state from column state.
      */
-    applyColumnState(field: string, state: ColumnState): void;
+    applyColumnState(field: string, state: ColumnState_2): void;
     readonly styles = "\n    .header-cell.filtered::before {\n      content: '';\n      position: absolute;\n      top: 4px;\n      right: 4px;\n      width: 6px;\n      height: 6px;\n      background: var(--tbw-filter-accent, var(--tbw-color-accent, #3b82f6));\n      border-radius: 50%;\n    }\n    .tbw-filter-btn {\n      display: inline-flex;\n      align-items: center;\n      justify-content: center;\n      background: transparent;\n      border: none;\n      cursor: pointer;\n      padding: 2px;\n      margin-left: 4px;\n      opacity: 0.4;\n      transition: opacity 0.15s;\n      color: inherit;\n      vertical-align: middle;\n    }\n    .tbw-filter-btn:hover,\n    .tbw-filter-btn.active {\n      opacity: 1;\n    }\n    .tbw-filter-btn.active {\n      color: var(--tbw-filter-accent, var(--tbw-color-accent, #3b82f6));\n    }\n  ";
 }
 
@@ -1719,11 +2662,50 @@ export declare interface FilterModel {
     valueTo?: unknown;
 }
 
+/** Filter model representing a single filter condition */
+declare interface FilterModel_2 {
+    /** The field/column to filter on */
+    field: string;
+    /** The type of filter */
+    type: FilterType_2;
+    /** The filter operator */
+    operator: FilterOperator_2;
+    /** The filter value (type depends on operator) */
+    value: unknown;
+    /** Secondary value for 'between' operator */
+    valueTo?: unknown;
+}
+
 /** Filter operators for different filter types */
 export declare type FilterOperator = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank' | 'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'between' | 'in' | 'notIn';
 
+/** Filter operators for different filter types */
+declare type FilterOperator_2 = 'contains' | 'notContains' | 'equals' | 'notEquals' | 'startsWith' | 'endsWith' | 'blank' | 'notBlank' | 'lessThan' | 'lessThanOrEqual' | 'greaterThan' | 'greaterThanOrEqual' | 'between' | 'in' | 'notIn';
+
 /** Parameters passed to custom filter panel renderer */
 declare interface FilterPanelParams {
+    /** The field being filtered */
+    field: string;
+    /** The column configuration */
+    column: ColumnConfig_2;
+    /** All unique values for this field */
+    uniqueValues: unknown[];
+    /** Currently excluded values (for set filter) */
+    excludedValues: Set<unknown>;
+    /** Current search text */
+    searchText: string;
+    /** Apply a set filter (exclude these values) */
+    applySetFilter: (excludedValues: unknown[]) => void;
+    /** Apply a text filter */
+    applyTextFilter: (operator: FilterOperator_2, value: string, valueTo?: string) => void;
+    /** Clear the filter for this field */
+    clearFilter: () => void;
+    /** Close the filter panel */
+    closePanel: () => void;
+}
+
+/** Parameters passed to custom filter panel renderer */
+declare interface FilterPanelParams_2 {
     /** The field being filtered */
     field: string;
     /** The column configuration */
@@ -1747,9 +2729,15 @@ declare interface FilterPanelParams {
 /** Custom filter panel renderer function. Return undefined to use default panel for this column. */
 declare type FilterPanelRenderer = (container: HTMLElement, params: FilterPanelParams) => void | undefined;
 
+/** Custom filter panel renderer function. Return undefined to use default panel for this column. */
+declare type FilterPanelRenderer_2 = (container: HTMLElement, params: FilterPanelParams_2) => void | undefined;
+
 /** Supported filter types */
 export declare type FilterType = 'text' | 'number' | 'date' | 'set' | 'boolean';
 
+/** Supported filter types */
+declare type FilterType_2 = 'text' | 'number' | 'date' | 'set' | 'boolean';
+
 export declare type FitMode = (typeof FitModeEnum)[keyof typeof FitModeEnum];
 
 export declare const FitModeEnum: {
@@ -1773,6 +2761,8 @@ declare interface FlattenedTreeRow {
     parentKey: string | null;
 }
 
+export declare const getAggregator: (ref: AggregatorRef_2_2 | undefined) => AggregatorFn | undefined;
+
 export declare interface GetRowsParams {
     startRow: number;
     endRow: number;
@@ -1783,12 +2773,28 @@ export declare interface GetRowsParams {
     filterModel?: Record<string, any>;
 }
 
+declare interface GetRowsParams_2 {
+    startRow: number;
+    endRow: number;
+    sortModel?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+    filterModel?: Record<string, any>;
+}
+
 export declare interface GetRowsResult {
     rows: any[];
     totalRowCount: number;
     lastRow?: number;
 }
 
+declare interface GetRowsResult_2 {
+    rows: any[];
+    totalRowCount: number;
+    lastRow?: number;
+}
+
 /**
  * CSS class names used in the grid's shadow DOM.
  * Use these when adding/removing classes or querying elements.
@@ -1901,6 +2907,12 @@ export declare interface GridConfig<TRow = any> {
      * When configured, adds an optional wrapper with title, toolbar, and collapsible side panels.
      */
     shell?: ShellConfig;
+    /**
+     * Grid-wide icon configuration.
+     * Provides consistent icons across all plugins (tree, grouping, sorting, etc.).
+     * Plugins will use these by default but can override with their own config.
+     */
+    icons?: GridIcons;
 }
 
 export declare type GridCSSVar = (typeof GridCSSVars)[keyof typeof GridCSSVars];
@@ -1944,7 +2956,7 @@ export declare const GridDataAttrs: {
     readonly STICKY: "data-sticky";
 };
 
-declare interface GridElement_2 {
+export declare interface GridElement {
     shadowRoot: ShadowRoot | null;
     rows: any[];
     columns: ColumnConfig[];
@@ -1959,6 +2971,63 @@ declare interface GridElement_2 {
     dispatchEvent(event: Event): boolean;
 }
 
+declare interface GridElement_2 {
+    shadowRoot: ShadowRoot | null;
+    rows: any[];
+    columns: ColumnConfig_2[];
+    gridConfig: any;
+    /** AbortSignal that is aborted when the grid disconnects from the DOM */
+    disconnectSignal: AbortSignal;
+    requestRender(): void;
+    requestAfterRender(): void;
+    forceLayout(): Promise<void>;
+    getPlugin<T extends BaseGridPlugin_2>(PluginClass: new (...args: any[]) => T): T | undefined;
+    getPluginByName(name: string): BaseGridPlugin_2 | undefined;
+    dispatchEvent(event: Event): boolean;
+}
+
+/**
+ * Grid-wide icon configuration.
+ * All icons are optional - sensible defaults are used when not specified.
+ */
+export declare interface GridIcons {
+    /** Expand icon for collapsed items (trees, groups, details). Default: '▶' */
+    expand?: IconValue;
+    /** Collapse icon for expanded items (trees, groups, details). Default: '▼' */
+    collapse?: IconValue;
+    /** Sort ascending indicator. Default: '▲' */
+    sortAsc?: IconValue;
+    /** Sort descending indicator. Default: '▼' */
+    sortDesc?: IconValue;
+    /** Sort neutral/unsorted indicator. Default: '⇅' */
+    sortNone?: IconValue;
+    /** Submenu arrow for context menus. Default: '▶' */
+    submenuArrow?: IconValue;
+    /** Drag handle icon for reordering. Default: '⋮⋮' */
+    dragHandle?: IconValue;
+}
+
+/**
+ * Grid-wide icon configuration.
+ * All icons are optional - sensible defaults are used when not specified.
+ */
+declare interface GridIcons_2 {
+    /** Expand icon for collapsed items (trees, groups, details). Default: '▶' */
+    expand?: IconValue_2;
+    /** Collapse icon for expanded items (trees, groups, details). Default: '▼' */
+    collapse?: IconValue_2;
+    /** Sort ascending indicator. Default: '▲' */
+    sortAsc?: IconValue_2;
+    /** Sort descending indicator. Default: '▼' */
+    sortDesc?: IconValue_2;
+    /** Sort neutral/unsorted indicator. Default: '⇅' */
+    sortNone?: IconValue_2;
+    /** Submenu arrow for context menus. Default: '▶' */
+    submenuArrow?: IconValue_2;
+    /** Drag handle icon for reordering. Default: '⋮⋮' */
+    dragHandle?: IconValue_2;
+}
+
 /**
  * Common CSS selectors for querying grid elements.
  * Built from the class constants for consistency.
@@ -1987,7 +3056,7 @@ declare interface GroupHeaderRenderParams {
     /** The group label (or id if no label) */
     label: string;
     /** Columns in this group */
-    columns: ColumnConfig[];
+    columns: ColumnConfig_2[];
     /** Starting column index */
     firstIndex: number;
     /** Whether this is an implicit (unnamed) group */
@@ -2015,7 +3084,7 @@ declare interface GroupingColumnsConfig {
  * })
  * ```
  */
-export declare class GroupingColumnsPlugin extends BaseGridPlugin<GroupingColumnsConfig> {
+export declare class GroupingColumnsPlugin extends BaseGridPlugin_2<GroupingColumnsConfig> {
     readonly name = "groupingColumns";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<GroupingColumnsConfig>;
@@ -2026,7 +3095,7 @@ export declare class GroupingColumnsPlugin extends BaseGridPlugin<GroupingColumn
      * Auto-detect column groups from column configuration.
      */
     static detect(rows: readonly any[], config: any): boolean;
-    processColumns(columns: readonly ColumnConfig[]): ColumnConfig[];
+    processColumns(columns: readonly ColumnConfig_2[]): ColumnConfig_2[];
     afterRender(): void;
     /**
      * Check if column groups are active.
@@ -2043,7 +3112,7 @@ export declare class GroupingColumnsPlugin extends BaseGridPlugin<GroupingColumn
      * @param groupId - The group ID to find
      * @returns Array of columns in the group
      */
-    getGroupColumns(groupId: string): ColumnConfig[];
+    getGroupColumns(groupId: string): ColumnConfig_2[];
     /**
      * Refresh column groups (recompute from current columns).
      */
@@ -2062,7 +3131,32 @@ export declare interface GroupingRowsConfig {
     groupOn?: (row: any) => any[] | any | null | false;
     /** Whether groups are expanded by default (default: false) */
     defaultExpanded?: boolean;
-    /** Custom group row renderer */
+    /** Custom group row renderer - takes full control of group row rendering */
+    groupRowRenderer?: (params: GroupRowRenderParams_2) => HTMLElement | string | void;
+    /** Show row count in group headers (default: true) */
+    showRowCount?: boolean;
+    /** Indent width per depth level in pixels (default: 20) */
+    indentWidth?: number;
+    /** Aggregators for group row cells by field name */
+    aggregators?: AggregatorMap_2;
+    /** Custom format function for group label */
+    formatLabel?: (value: any, depth: number, key: string) => string;
+    /** Whether to render group row as full-width spanning cell (default: true) */
+    fullWidth?: boolean;
+}
+
+/** Configuration options for the row grouping plugin */
+declare interface GroupingRowsConfig_2 {
+    /** Whether the plugin is enabled (default: true) */
+    enabled?: boolean;
+    /**
+     * Callback to determine group path for a row.
+     * Return an array of group keys, a single key, null/false to skip grouping.
+     */
+    groupOn?: (row: any) => any[] | any | null | false;
+    /** Whether groups are expanded by default (default: false) */
+    defaultExpanded?: boolean;
+    /** Custom group row renderer - takes full control of group row rendering */
     groupRowRenderer?: (params: GroupRowRenderParams) => HTMLElement | string | void;
     /** Show row count in group headers (default: true) */
     showRowCount?: boolean;
@@ -2089,10 +3183,10 @@ export declare interface GroupingRowsConfig {
  * })
  * ```
  */
-export declare class GroupingRowsPlugin extends BaseGridPlugin<GroupingRowsConfig> {
+export declare class GroupingRowsPlugin extends BaseGridPlugin_2<GroupingRowsConfig_2> {
     readonly name = "groupingRows";
     readonly version = "1.0.0";
-    protected get defaultConfig(): Partial<GroupingRowsConfig>;
+    protected get defaultConfig(): Partial<GroupingRowsConfig_2>;
     private expandedKeys;
     private flattenedRows;
     private isActive;
@@ -2103,7 +3197,7 @@ export declare class GroupingRowsPlugin extends BaseGridPlugin<GroupingRowsConfi
      */
     static detect(rows: readonly any[], config: any): boolean;
     processRows(rows: readonly any[]): any[];
-    onCellClick(event: CellClickEvent): boolean | void;
+    onCellClick(event: CellClickEvent_2): boolean | void;
     /**
      * Render a row. Returns true if we handled the row (group row), false otherwise.
      */
@@ -2204,6 +3298,22 @@ declare interface GroupRowRenderParams {
     toggleExpand: () => void;
 }
 
+/** Parameters passed to custom group row renderer */
+declare interface GroupRowRenderParams_2 {
+    /** The group key */
+    key: string;
+    /** The group value (last segment of path) */
+    value: any;
+    /** Depth level (0-based) */
+    depth: number;
+    /** All data rows in this group (including nested) */
+    rows: any[];
+    /** Whether the group is expanded */
+    expanded: boolean;
+    /** Toggle expand/collapse */
+    toggleExpand: () => void;
+}
+
 /**
  * Group state information returned by getGroupState()
  */
@@ -2221,7 +3331,7 @@ declare interface GroupState {
 /**
  * Header click event
  */
-declare interface HeaderClickEvent {
+export declare interface HeaderClickEvent {
     colIndex: number;
     field: string;
     column: ColumnConfig;
@@ -2229,6 +3339,17 @@ declare interface HeaderClickEvent {
     originalEvent: MouseEvent;
 }
 
+/**
+ * Header click event
+ */
+declare interface HeaderClickEvent_2 {
+    colIndex: number;
+    field: string;
+    column: ColumnConfig_2;
+    headerEl: HTMLElement;
+    originalEvent: MouseEvent;
+}
+
 /**
  * Header content definition for plugins contributing to shell header center section.
  */
@@ -2243,10 +3364,35 @@ export declare interface HeaderContentDefinition {
     order?: number;
 }
 
+/**
+ * Header content definition for plugins contributing to shell header center section.
+ */
+declare interface HeaderContentDefinition_2 {
+    /** Unique content ID */
+    id: string;
+    /** Content factory - called once when shell header renders */
+    render: (container: HTMLElement) => void | (() => void);
+    /** Called when content is removed (for cleanup) */
+    onDestroy?: () => void;
+    /** Order priority (lower = first, default: 100) */
+    order?: number;
+}
+
+/**
+ * Header renderer function type for plugins.
+ */
+export declare type HeaderRenderer = (ctx: PluginHeaderRenderContext) => string | HTMLElement;
+
 /**
  * Header renderer function type for plugins.
  */
-declare type HeaderRenderer = (ctx: PluginHeaderRenderContext) => string | HTMLElement;
+declare type HeaderRenderer_2 = (ctx: PluginHeaderRenderContext_2) => string | HTMLElement;
+
+/** Icon value - can be a string (text/HTML) or HTMLElement */
+export declare type IconValue = string | HTMLElement;
+
+/** Icon value - can be a string (text/HTML) or HTMLElement */
+declare type IconValue_2 = string | HTMLElement;
 
 /** Result of automatic column inference from sample rows. */
 export declare interface InferredColumnResult<TRow = any> {
@@ -2302,6 +3448,18 @@ declare interface InternalGrid<T = any> extends PublicGrid<T>, GridConfig<T> {
     requestStateChange?: () => void;
 }
 
+/**
+ * Keyboard modifier flags
+ */
+export declare interface KeyboardModifiers {
+    ctrl?: boolean;
+    shift?: boolean;
+    alt?: boolean;
+    meta?: boolean;
+}
+
+export declare const listAggregators: () => string[];
+
 /**
  * Master/Detail Plugin Types
  *
@@ -2335,16 +3493,38 @@ declare interface MasterDetailConfig {
  * })
  * ```
  */
-export declare class MasterDetailPlugin extends BaseGridPlugin<MasterDetailConfig> {
+export declare class MasterDetailPlugin extends BaseGridPlugin_2<MasterDetailConfig> {
+    #private;
     readonly name = "masterDetail";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<MasterDetailConfig>;
     private expandedRows;
     private detailElements;
     detach(): void;
-    processColumns(columns: readonly ColumnConfig[]): ColumnConfig[];
-    onRowClick(event: RowClickEvent): boolean | void;
+    processColumns(columns: readonly ColumnConfig_2[]): ColumnConfig_2[];
+    onRowClick(event: RowClickEvent_2): boolean | void;
+    onCellClick(): boolean | void;
     afterRender(): void;
+    /**
+     * Called on scroll to sync detail elements with visible rows.
+     * Removes details for rows that scrolled out of view and reattaches for visible rows.
+     */
+    onScrollRender(): void;
+    /**
+     * Return total extra height from all expanded detail rows.
+     * Used by grid virtualization to adjust scrollbar height.
+     */
+    getExtraHeight(): number;
+    /**
+     * Return extra height that appears before a given row index.
+     * This is the sum of heights of all expanded details whose parent row is before the given index.
+     */
+    getExtraHeightBefore(beforeRowIndex: number): number;
+    /**
+     * Adjust the virtualization start index to keep expanded row visible while its detail is visible.
+     * This ensures the detail scrolls smoothly out of view instead of disappearing abruptly.
+     */
+    adjustVirtualStart(start: number, scrollTop: number, rowHeight: number): number;
     /**
      * Expand the detail row at the given index.
      * @param rowIndex - Index of the row to expand
@@ -2398,6 +3578,16 @@ export declare interface MultiSortConfig {
     showSortIndex?: boolean;
 }
 
+/** Configuration options for the multi-sort plugin */
+declare interface MultiSortConfig_2 {
+    /** Whether multi-sort is enabled (default: true) */
+    enabled?: boolean;
+    /** Maximum number of columns to sort by (default: 3) */
+    maxSortColumns?: number;
+    /** Whether to show sort order badges (1, 2, 3) on headers (default: true) */
+    showSortIndex?: boolean;
+}
+
 /**
  * Multi-Sort Plugin for tbw-grid
  *
@@ -2406,25 +3596,25 @@ export declare interface MultiSortConfig {
  * new MultiSortPlugin({ maxSortColumns: 3, showSortIndex: true })
  * ```
  */
-export declare class MultiSortPlugin extends BaseGridPlugin<MultiSortConfig> {
+export declare class MultiSortPlugin extends BaseGridPlugin_2<MultiSortConfig_2> {
     readonly name = "multiSort";
     readonly version = "1.0.0";
-    protected get defaultConfig(): Partial<MultiSortConfig>;
+    protected get defaultConfig(): Partial<MultiSortConfig_2>;
     private sortModel;
     detach(): void;
     processRows(rows: readonly unknown[]): unknown[];
-    onHeaderClick(event: HeaderClickEvent): boolean;
+    onHeaderClick(event: HeaderClickEvent_2): boolean;
     afterRender(): void;
     /**
      * Get the current sort model.
      * @returns Copy of the current sort model
      */
-    getSortModel(): SortModel[];
+    getSortModel(): SortModel_2[];
     /**
      * Set the sort model programmatically.
      * @param model - New sort model to apply
      */
-    setSortModel(model: SortModel[]): void;
+    setSortModel(model: SortModel_2[]): void;
     /**
      * Clear all sorting.
      */
@@ -2444,12 +3634,12 @@ export declare class MultiSortPlugin extends BaseGridPlugin<MultiSortConfig> {
     /**
      * Return sort state for a column if it's in the sort model.
      */
-    getColumnState(field: string): Partial<ColumnState> | undefined;
+    getColumnState(field: string): Partial<ColumnState_2> | undefined;
     /**
      * Apply sort state from column state.
      * Rebuilds the sort model from all column states.
      */
-    applyColumnState(field: string, state: ColumnState): void;
+    applyColumnState(field: string, state: ColumnState_2): void;
     readonly styles = "\n    .header-cell[data-sort=\"asc\"]::after {\n      content: '\u2191';\n      margin-left: 4px;\n      opacity: 0.8;\n    }\n    .header-cell[data-sort=\"desc\"]::after {\n      content: '\u2193';\n      margin-left: 4px;\n      opacity: 0.8;\n    }\n    .sort-index {\n      font-size: 10px;\n      background: var(--tbw-multi-sort-badge-bg, var(--tbw-color-panel-bg));\n      color: var(--tbw-multi-sort-badge-color, var(--tbw-color-fg));\n      border-radius: 50%;\n      width: 14px;\n      height: 14px;\n      display: inline-flex;\n      align-items: center;\n      justify-content: center;\n      margin-left: 2px;\n      font-weight: 600;\n    }\n  ";
 }
 
@@ -2472,7 +3662,7 @@ declare interface PinnedColumnsConfig {
  * new PinnedColumnsPlugin({ enabled: true })
  * ```
  */
-export declare class PinnedColumnsPlugin extends BaseGridPlugin<PinnedColumnsConfig> {
+export declare class PinnedColumnsPlugin extends BaseGridPlugin_2<PinnedColumnsConfig> {
     readonly name = "pinnedColumns";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<PinnedColumnsConfig>;
@@ -2484,9 +3674,9 @@ export declare class PinnedColumnsPlugin extends BaseGridPlugin<PinnedColumnsCon
      * Auto-detect sticky columns from column configuration.
      */
     static detect(rows: readonly unknown[], config: {
-        columns?: ColumnConfig[];
+        columns?: ColumnConfig_2[];
     }): boolean;
-    processColumns(columns: readonly ColumnConfig[]): ColumnConfig[];
+    processColumns(columns: readonly ColumnConfig_2[]): ColumnConfig_2[];
     afterRender(): void;
     /**
      * Re-apply sticky offsets (e.g., after column resize).
@@ -2495,11 +3685,11 @@ export declare class PinnedColumnsPlugin extends BaseGridPlugin<PinnedColumnsCon
     /**
      * Get columns pinned to the left.
      */
-    getLeftPinnedColumns(): ColumnConfig[];
+    getLeftPinnedColumns(): ColumnConfig_2[];
     /**
      * Get columns pinned to the right.
      */
-    getRightPinnedColumns(): ColumnConfig[];
+    getRightPinnedColumns(): ColumnConfig_2[];
     /**
      * Clear all sticky positioning.
      */
@@ -2519,13 +3709,29 @@ declare interface PinnedRowsConfig {
     /** Show filtered row count when filter is active (default: true) */
     showFilteredCount?: boolean;
     /** Custom panels to display in the info bar */
-    customPanels?: PinnedRowsPanel[];
+    customPanels?: PinnedRowsPanel_2[];
     /** Aggregation rows (footer/header rows with computed values) */
     aggregationRows?: AggregationRowConfig[];
 }
 
 /** Context provided to panel renderers */
-export declare interface PinnedRowsContext {
+export declare interface PinnedRowsContext {
+    /** Total number of rows in the grid */
+    totalRows: number;
+    /** Number of rows after filtering */
+    filteredRows: number;
+    /** Number of selected rows */
+    selectedRows: number;
+    /** Current column configuration */
+    columns: ColumnConfig[];
+    /** Current row data */
+    rows: unknown[];
+    /** Reference to the grid element */
+    grid: HTMLElement;
+}
+
+/** Context provided to panel renderers */
+declare interface PinnedRowsContext_2 {
     /** Total number of rows in the grid */
     totalRows: number;
     /** Number of rows after filtering */
@@ -2533,7 +3739,7 @@ export declare interface PinnedRowsContext {
     /** Number of selected rows */
     selectedRows: number;
     /** Current column configuration */
-    columns: ColumnConfig[];
+    columns: ColumnConfig_2[];
     /** Current row data */
     rows: unknown[];
     /** Reference to the grid element */
@@ -2550,6 +3756,16 @@ export declare interface PinnedRowsPanel {
     render: (context: PinnedRowsContext) => HTMLElement | string;
 }
 
+/** Custom panel definition for the status bar */
+declare interface PinnedRowsPanel_2 {
+    /** Unique identifier for the panel */
+    id: string;
+    /** Position within the status bar */
+    position: 'left' | 'center' | 'right';
+    /** Render function for the panel content */
+    render: (context: PinnedRowsContext_2) => HTMLElement | string;
+}
+
 /**
  * Pinned Rows Plugin for tbw-grid
  *
@@ -2566,7 +3782,7 @@ export declare interface PinnedRowsPanel {
  * })
  * ```
  */
-export declare class PinnedRowsPlugin extends BaseGridPlugin<PinnedRowsConfig> {
+export declare class PinnedRowsPlugin extends BaseGridPlugin_2<PinnedRowsConfig> {
     readonly name = "pinnedRows";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<PinnedRowsConfig>;
@@ -2588,12 +3804,12 @@ export declare class PinnedRowsPlugin extends BaseGridPlugin<PinnedRowsConfig> {
      * Get the current status bar context.
      * @returns The context with row counts and other info
      */
-    getContext(): PinnedRowsContext;
+    getContext(): PinnedRowsContext_2;
     /**
      * Add a custom panel to the info bar.
      * @param panel - The panel configuration to add
      */
-    addPanel(panel: PinnedRowsPanel): void;
+    addPanel(panel: PinnedRowsPanel_2): void;
     /**
      * Remove a custom panel by ID.
      * @param id - The panel ID to remove
@@ -2624,6 +3840,15 @@ export declare interface PivotConfig {
     showGrandTotal?: boolean;
 }
 
+declare interface PivotConfig_2 {
+    enabled?: boolean;
+    rowGroupFields?: string[];
+    columnGroupFields?: string[];
+    valueFields?: PivotValueField_2[];
+    showTotals?: boolean;
+    showGrandTotal?: boolean;
+}
+
 declare type PivotDataRow = Record<string, unknown>;
 
 /**
@@ -2638,17 +3863,17 @@ declare type PivotDataRow = Record<string, unknown>;
  * })
  * ```
  */
-export declare class PivotPlugin extends BaseGridPlugin<PivotConfig> {
+export declare class PivotPlugin extends BaseGridPlugin_2<PivotConfig_2> {
     readonly name = "pivot";
     readonly version = "1.0.0";
-    protected get defaultConfig(): Partial<PivotConfig>;
+    protected get defaultConfig(): Partial<PivotConfig_2>;
     private isActive;
     private pivotResult;
     private columnHeaders;
     private rowHeaders;
     detach(): void;
     processRows(rows: readonly unknown[]): PivotDataRow[];
-    processColumns(columns: readonly ColumnConfig[]): ColumnConfig[];
+    processColumns(columns: readonly ColumnConfig_2[]): ColumnConfig_2[];
     /**
      * Enable pivot mode.
      */
@@ -2664,7 +3889,7 @@ export declare class PivotPlugin extends BaseGridPlugin<PivotConfig> {
     /**
      * Get the current pivot result.
      */
-    getPivotResult(): PivotResult | null;
+    getPivotResult(): PivotResult_2 | null;
     /**
      * Set the row group fields for pivoting.
      * @param fields - Array of field names to group rows by
@@ -2679,7 +3904,7 @@ export declare class PivotPlugin extends BaseGridPlugin<PivotConfig> {
      * Set the value fields with aggregation functions.
      * @param fields - Array of value field configurations
      */
-    setValueFields(fields: PivotValueField[]): void;
+    setValueFields(fields: PivotValueField_2[]): void;
     /**
      * Refresh the pivot by clearing cached results.
      */
@@ -2688,6 +3913,13 @@ export declare class PivotPlugin extends BaseGridPlugin<PivotConfig> {
 }
 
 export declare interface PivotResult {
+    rows: PivotRow_2[];
+    columnKeys: string[];
+    totals: Record<string, number>;
+    grandTotal: number;
+}
+
+declare interface PivotResult_2 {
     rows: PivotRow[];
     columnKeys: string[];
     totals: Record<string, number>;
@@ -2704,12 +3936,28 @@ declare interface PivotRow {
     children?: PivotRow[];
 }
 
+declare interface PivotRow_2 {
+    rowKey: string;
+    rowLabel: string;
+    depth: number;
+    values: Record<string, number | null>;
+    total?: number;
+    isGroup: boolean;
+    children?: PivotRow_2[];
+}
+
 export declare interface PivotValueField {
     field: string;
     aggFunc: 'sum' | 'avg' | 'count' | 'min' | 'max' | 'first' | 'last';
     header?: string;
 }
 
+declare interface PivotValueField_2 {
+    field: string;
+    aggFunc: 'sum' | 'avg' | 'count' | 'min' | 'max' | 'first' | 'last';
+    header?: string;
+}
+
 /**
  * Cell render context for plugin cell renderers.
  * Provides full context including position and editing state.
@@ -2718,7 +3966,7 @@ export declare interface PivotValueField {
  * simpler and used for column view renderers. This version provides additional
  * context needed by plugins that register custom cell renderers.
  */
-declare interface PluginCellRenderContext {
+export declare interface PluginCellRenderContext {
     /** The cell value */
     value: any;
     /** The field/column key */
@@ -2735,6 +3983,31 @@ declare interface PluginCellRenderContext {
     isEditing: boolean;
 }
 
+/**
+ * Cell render context for plugin cell renderers.
+ * Provides full context including position and editing state.
+ *
+ * Note: This differs from the core `CellRenderContext` in types.ts which is
+ * simpler and used for column view renderers. This version provides additional
+ * context needed by plugins that register custom cell renderers.
+ */
+declare interface PluginCellRenderContext_2 {
+    /** The cell value */
+    value: any;
+    /** The field/column key */
+    field: string;
+    /** The row data object */
+    row: any;
+    /** Row index in the data array */
+    rowIndex: number;
+    /** Column index */
+    colIndex: number;
+    /** Column configuration */
+    column: ColumnConfig_2;
+    /** Whether the cell is currently in edit mode */
+    isEditing: boolean;
+}
+
 export declare type PluginEventName = (typeof PluginEvents)[keyof typeof PluginEvents];
 
 export declare const PluginEvents: {
@@ -2760,13 +4033,185 @@ export declare const PluginEvents: {
 /**
  * Header render context for plugin header renderers.
  */
-declare interface PluginHeaderRenderContext {
+export declare interface PluginHeaderRenderContext {
     /** Column configuration */
     column: ColumnConfig;
     /** Column index */
     colIndex: number;
 }
 
+/**
+ * Header render context for plugin header renderers.
+ */
+declare interface PluginHeaderRenderContext_2 {
+    /** Column configuration */
+    column: ColumnConfig_2;
+    /** Column index */
+    colIndex: number;
+}
+
+/**
+ * Manages plugins for a single grid instance.
+ */
+export declare class PluginManager {
+    private grid;
+    /** Plugin instances in order of attachment */
+    private plugins;
+    /** Map from plugin class to instance for fast lookup */
+    private pluginMap;
+    /** Cell renderers registered by plugins */
+    private cellRenderers;
+    /** Header renderers registered by plugins */
+    private headerRenderers;
+    /** Cell editors registered by plugins */
+    private cellEditors;
+    constructor(grid: any);
+    /**
+     * Attach all plugins from the config.
+     */
+    attachAll(plugins: BaseGridPlugin[]): void;
+    /**
+     * Attach a plugin to this grid.
+     */
+    attach(plugin: BaseGridPlugin): void;
+    /**
+     * Detach all plugins and clean up.
+     */
+    detachAll(): void;
+    /**
+     * Get a plugin instance by its class.
+     */
+    getPlugin<T extends BaseGridPlugin>(PluginClass: new (...args: any[]) => T): T | undefined;
+    /**
+     * Get a plugin instance by its name.
+     */
+    getPluginByName(name: string): BaseGridPlugin | undefined;
+    /**
+     * Check if a plugin is attached.
+     */
+    hasPlugin<T extends BaseGridPlugin>(PluginClass: new (...args: any[]) => T): boolean;
+    /**
+     * Get all attached plugins.
+     */
+    getAll(): readonly BaseGridPlugin[];
+    /**
+     * Get a cell renderer by type name.
+     */
+    getCellRenderer(type: string): CellRenderer | undefined;
+    /**
+     * Get a header renderer by type name.
+     */
+    getHeaderRenderer(type: string): HeaderRenderer | undefined;
+    /**
+     * Get a cell editor by type name.
+     */
+    getCellEditor(type: string): CellEditor | undefined;
+    /**
+     * Get all CSS styles from all plugins.
+     */
+    getAllStyles(): string;
+    /**
+     * Execute processRows hook on all plugins.
+     */
+    processRows(rows: readonly any[]): any[];
+    /**
+     * Execute processColumns hook on all plugins.
+     */
+    processColumns(columns: readonly ColumnConfig[]): ColumnConfig[];
+    /**
+     * Execute beforeRender hook on all plugins.
+     */
+    beforeRender(): void;
+    /**
+     * Execute afterRender hook on all plugins.
+     */
+    afterRender(): void;
+    /**
+     * Execute onScrollRender hook on all plugins.
+     * Called after scroll-triggered row rendering for lightweight visual state updates.
+     */
+    onScrollRender(): void;
+    /**
+     * Get total extra height contributed by plugins (e.g., expanded detail rows).
+     * Used to adjust scrollbar height calculations.
+     */
+    getExtraHeight(): number;
+    /**
+     * Get extra height from plugins that appears before a given row index.
+     * Used by virtualization to correctly position the scroll window.
+     */
+    getExtraHeightBefore(beforeRowIndex: number): number;
+    /**
+     * Adjust the virtualization start index based on plugin needs.
+     * Returns the minimum start index from all plugins.
+     */
+    adjustVirtualStart(start: number, scrollTop: number, rowHeight: number): number;
+    /**
+     * Execute renderRow hook on all plugins.
+     * Returns true if any plugin handled the row.
+     */
+    renderRow(row: any, rowEl: HTMLElement, rowIndex: number): boolean;
+    /**
+     * Execute onKeyDown hook on all plugins.
+     * Returns true if any plugin handled the event.
+     */
+    onKeyDown(event: KeyboardEvent): boolean;
+    /**
+     * Execute onCellClick hook on all plugins.
+     * Returns true if any plugin handled the event.
+     */
+    onCellClick(event: CellClickEvent): boolean;
+    /**
+     * Execute onRowClick hook on all plugins.
+     * Returns true if any plugin handled the event.
+     */
+    onRowClick(event: RowClickEvent): boolean;
+    /**
+     * Execute onHeaderClick hook on all plugins.
+     * Returns true if any plugin handled the event.
+     */
+    onHeaderClick(event: HeaderClickEvent): boolean;
+    /**
+     * Execute onScroll hook on all plugins.
+     */
+    onScroll(event: ScrollEvent): void;
+    /**
+     * Execute onCellMouseDown hook on all plugins.
+     * Returns true if any plugin handled the event.
+     */
+    onCellMouseDown(event: CellMouseEvent): boolean;
+    /**
+     * Execute onCellMouseMove hook on all plugins.
+     * Returns true if any plugin handled the event.
+     */
+    onCellMouseMove(event: CellMouseEvent): boolean;
+    /**
+     * Execute onCellMouseUp hook on all plugins.
+     * Returns true if any plugin handled the event.
+     */
+    onCellMouseUp(event: CellMouseEvent): boolean;
+    /**
+     * Collect context menu items from all plugins.
+     */
+    getContextMenuItems(params: ContextMenuParams): ContextMenuItem[];
+    /**
+     * Collect tool panels from all plugins.
+     * Returns panels sorted by order (ascending).
+     */
+    getToolPanels(): {
+        plugin: BaseGridPlugin;
+        panel: NonNullable<ReturnType<NonNullable<BaseGridPlugin['getToolPanel']>>>;
+    }[];
+    /**
+     * Collect header contents from all plugins.
+     * Returns contents sorted by order (ascending).
+     */
+    getHeaderContents(): {
+        plugin: BaseGridPlugin;
+        content: NonNullable<ReturnType<NonNullable<BaseGridPlugin['getHeaderContent']>>>;
+    }[];
+}
+
 export declare type PrimitiveColumnType = 'number' | 'string' | 'date' | 'boolean' | 'select' | 'typeahead';
 
 /**
@@ -2808,6 +4253,8 @@ export declare interface PublicGrid<T = any> {
     toggleGroup?: (key: string) => Promise<void>;
 }
 
+export declare const registerAggregator: (name: string, fn: AggregatorFn) => void;
+
 /** Union type for render rows */
 declare type RenderRow = GroupRowModelItem | DataRowModelItem;
 
@@ -2838,7 +4285,7 @@ declare interface ReorderConfig {
  * })
  * ```
  */
-export declare class ReorderPlugin extends BaseGridPlugin<ReorderConfig> {
+export declare class ReorderPlugin extends BaseGridPlugin_2<ReorderConfig> {
     readonly name = "reorder";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<ReorderConfig>;
@@ -2883,7 +4330,17 @@ declare interface ResizeController {
 /**
  * Row click event
  */
-declare interface RowClickEvent {
+export declare interface RowClickEvent {
+    rowIndex: number;
+    row: any;
+    rowEl: HTMLElement;
+    originalEvent: MouseEvent;
+}
+
+/**
+ * Row click event
+ */
+declare interface RowClickEvent_2 {
     rowIndex: number;
     row: any;
     rowEl: HTMLElement;
@@ -2919,10 +4376,25 @@ export declare interface RowGroupRenderConfig {
     class?: string;
 }
 
+export declare const runAggregator: (ref: AggregatorRef_2_2 | undefined, rows: any[], field: string, column?: any) => any;
+
+/**
+ * Scroll event
+ */
+export declare interface ScrollEvent {
+    scrollTop: number;
+    scrollLeft: number;
+    scrollHeight: number;
+    scrollWidth: number;
+    clientHeight: number;
+    clientWidth: number;
+    originalEvent?: Event;
+}
+
 /**
  * Scroll event
  */
-declare interface ScrollEvent {
+declare interface ScrollEvent_2 {
     scrollTop: number;
     scrollLeft: number;
     scrollHeight: number;
@@ -2949,6 +4421,12 @@ export declare interface SelectionConfig {
     mode: SelectionMode_2;
 }
 
+/** Configuration options for the selection plugin */
+declare interface SelectionConfig_2 {
+    /** Selection mode (default: 'cell') */
+    mode: SelectionMode_3;
+}
+
 /**
  * Selection Plugin Types
  *
@@ -2963,6 +4441,19 @@ export declare interface SelectionConfig {
 declare type SelectionMode_2 = 'cell' | 'row' | 'range';
 export { SelectionMode_2 as SelectionMode }
 
+/**
+ * Selection Plugin Types
+ *
+ * Type definitions for the selection feature.
+ */
+/**
+ * Selection mode for the grid:
+ * - 'cell': Single cell selection (default). No border, just focus highlight.
+ * - 'row': Row selection. Clicking a cell selects the entire row. Uses focus outline color.
+ * - 'range': Range selection. Shift+click or drag to select rectangular cell ranges. Uses success border color.
+ */
+declare type SelectionMode_3 = 'cell' | 'row' | 'range';
+
 /**
  * Selection Plugin for tbw-grid
  *
@@ -2971,11 +4462,11 @@ export { SelectionMode_2 as SelectionMode }
  * new SelectionPlugin({ mode: 'range' })
  * ```
  */
-export declare class SelectionPlugin extends BaseGridPlugin<SelectionConfig> {
+export declare class SelectionPlugin extends BaseGridPlugin_2<SelectionConfig_2> {
     #private;
     readonly name = "selection";
     readonly version = "1.0.0";
-    protected get defaultConfig(): Partial<SelectionConfig>;
+    protected get defaultConfig(): Partial<SelectionConfig_2>;
     /** Row selection state (row mode) */
     private selected;
     private lastSelected;
@@ -2988,11 +4479,11 @@ export declare class SelectionPlugin extends BaseGridPlugin<SelectionConfig> {
     /** Cell selection state (cell mode) */
     private selectedCell;
     detach(): void;
-    onCellClick(event: CellClickEvent): boolean;
+    onCellClick(event: CellClickEvent_2): boolean;
     onKeyDown(event: KeyboardEvent): boolean;
-    onCellMouseDown(event: CellMouseEvent): boolean | void;
-    onCellMouseMove(event: CellMouseEvent): boolean | void;
-    onCellMouseUp(_event: CellMouseEvent): boolean | void;
+    onCellMouseDown(event: CellMouseEvent_2): boolean | void;
+    onCellMouseMove(event: CellMouseEvent_2): boolean | void;
+    onCellMouseUp(_event: CellMouseEvent_2): boolean | void;
     afterRender(): void;
     /**
      * Called after scroll-triggered row rendering.
@@ -3013,7 +4504,7 @@ export declare class SelectionPlugin extends BaseGridPlugin<SelectionConfig> {
     /**
      * Get all selected cell ranges in public format.
      */
-    getRanges(): CellRange[];
+    getRanges(): CellRange_2[];
     /**
      * Get all selected cells across all ranges.
      */
@@ -3032,7 +4523,7 @@ export declare class SelectionPlugin extends BaseGridPlugin<SelectionConfig> {
     /**
      * Set selected ranges programmatically.
      */
-    setRanges(ranges: CellRange[]): void;
+    setRanges(ranges: CellRange_2[]): void;
     readonly styles = "\n    /* Prevent text selection during range drag */\n    :host .selecting .data-grid-row > .cell {\n      user-select: none;\n    }\n\n    /* Row selection - use accent color for row focus */\n    :host .data-grid-row.row-focus {\n      background-color: var(--tbw-focus-background, rgba(from var(--tbw-color-accent) r g b / 12%));\n    }\n\n    /* Disable cell-focus outline in row mode - row is the focus unit */\n    :host([data-selection-mode=\"row\"]) .cell-focus {\n      outline: none;\n    }\n\n    /* Selection cell styles - for range mode */\n    :host .data-grid-row > .cell.selected {\n      background-color: var(--tbw-range-selection-bg);\n    }\n    :host .data-grid-row > .cell.selected.top {\n      border-top: 2px solid var(--tbw-range-border-color);\n    }\n    :host .data-grid-row > .cell.selected.bottom {\n      border-bottom: 2px solid var(--tbw-range-border-color);\n    }\n    :host .data-grid-row > .cell.selected.first {\n      border-left: 2px solid var(--tbw-range-border-color);\n    }\n    :host .data-grid-row > .cell.selected.last {\n      border-right: 2px solid var(--tbw-range-border-color);\n    }\n  ";
 }
 
@@ -3047,6 +4538,10 @@ export declare interface ServerSideDataSource {
     getRows(params: GetRowsParams): Promise<GetRowsResult>;
 }
 
+declare interface ServerSideDataSource_2 {
+    getRows(params: GetRowsParams_2): Promise<GetRowsResult_2>;
+}
+
 /**
  * Server-Side Plugin for tbw-grid
  *
@@ -3056,7 +4551,7 @@ export declare interface ServerSideDataSource {
  * plugin.setDataSource(myDataSource);
  * ```
  */
-export declare class ServerSidePlugin extends BaseGridPlugin<ServerSideConfig> {
+export declare class ServerSidePlugin extends BaseGridPlugin_2<ServerSideConfig> {
     readonly name = "serverSide";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<ServerSideConfig>;
@@ -3072,12 +4567,12 @@ export declare class ServerSidePlugin extends BaseGridPlugin<ServerSideConfig> {
      */
     private loadRequiredBlocks;
     processRows(rows: readonly unknown[]): unknown[];
-    onScroll(event: ScrollEvent): void;
+    onScroll(event: ScrollEvent_2): void;
     /**
      * Set the data source for server-side loading.
      * @param dataSource - Data source implementing the getRows method
      */
-    setDataSource(dataSource: ServerSideDataSource): void;
+    setDataSource(dataSource: ServerSideDataSource_2): void;
     /**
      * Refresh all data from the server.
      */
@@ -3142,6 +4637,19 @@ export declare interface SortModel {
     direction: 'asc' | 'desc';
 }
 
+/**
+ * Multi-Sort Plugin Types
+ *
+ * Type definitions for the multi-column sorting feature.
+ */
+/** Represents a single column sort configuration */
+declare interface SortModel_2 {
+    /** The field key to sort by */
+    field: string;
+    /** Sort direction */
+    direction: 'asc' | 'desc';
+}
+
 /**
  * Toolbar button defined via config (programmatic approach).
  * Supports three modes:
@@ -3222,6 +4730,26 @@ export declare interface ToolPanelDefinition {
     order?: number;
 }
 
+/**
+ * Tool panel definition registered by plugins or consumers.
+ */
+declare interface ToolPanelDefinition_2 {
+    /** Unique panel ID */
+    id: string;
+    /** Panel title shown in header */
+    title: string;
+    /** Icon for toolbar button (SVG string or emoji) */
+    icon: string;
+    /** Toolbar button tooltip */
+    tooltip?: string;
+    /** Panel content factory - called when panel opens */
+    render: (container: HTMLElement) => void | (() => void);
+    /** Called when panel closes (for cleanup) */
+    onClose?: () => void;
+    /** Panel order priority (lower = first, default: 100) */
+    order?: number;
+}
+
 /**
  * Tree Data Plugin Types
  *
@@ -3243,6 +4771,27 @@ export declare interface TreeConfig {
     showExpandIcons?: boolean;
 }
 
+/**
+ * Tree Data Plugin Types
+ *
+ * Type definitions for hierarchical tree data with expand/collapse functionality.
+ */
+/** Configuration options for the tree plugin */
+declare interface TreeConfig_2 {
+    /** Whether tree functionality is enabled (default: true) */
+    enabled?: boolean;
+    /** Field name containing child rows (default: 'children') */
+    childrenField?: string;
+    /** Auto-detect tree structure from data (default: true) */
+    autoDetect?: boolean;
+    /** Whether nodes are expanded by default (default: false) */
+    defaultExpanded?: boolean;
+    /** Indentation width per level in pixels (default: 20) */
+    indentWidth?: number;
+    /** Show expand/collapse icons (default: true) */
+    showExpandIcons?: boolean;
+}
+
 /** Event detail emitted when a tree node is expanded or collapsed */
 export declare interface TreeExpandDetail {
     /** The row key that was toggled */
@@ -3265,10 +4814,10 @@ export declare interface TreeExpandDetail {
  * new TreePlugin({ defaultExpanded: true, indentWidth: 24 })
  * ```
  */
-export declare class TreePlugin extends BaseGridPlugin<TreeConfig> {
+export declare class TreePlugin extends BaseGridPlugin_2<TreeConfig_2> {
     readonly name = "tree";
     readonly version = "1.0.0";
-    protected get defaultConfig(): Partial<TreeConfig>;
+    protected get defaultConfig(): Partial<TreeConfig_2>;
     /** Set of expanded row keys */
     private expandedKeys;
     /** Whether initial expansion (based on defaultExpanded config) has been applied */
@@ -3284,8 +4833,8 @@ export declare class TreePlugin extends BaseGridPlugin<TreeConfig> {
      */
     detect(rows: readonly unknown[]): boolean;
     processRows(rows: readonly unknown[]): any[];
-    processColumns(columns: readonly ColumnConfig[]): ColumnConfig[];
-    onCellClick(event: CellClickEvent): boolean;
+    processColumns(columns: readonly ColumnConfig_2[]): ColumnConfig_2[];
+    onCellClick(event: CellClickEvent_2): boolean;
     /**
      * Expand a specific node by key.
      */
@@ -3349,7 +4898,7 @@ declare interface UndoRedoConfig {
  * Tracks cell edits and provides undo/redo functionality via keyboard shortcuts
  * or programmatic API.
  */
-export declare class UndoRedoPlugin extends BaseGridPlugin<UndoRedoConfig> {
+export declare class UndoRedoPlugin extends BaseGridPlugin_2<UndoRedoConfig> {
     readonly name = "undoRedo";
     readonly version = "1.0.0";
     protected get defaultConfig(): Partial<UndoRedoConfig>;
@@ -3380,13 +4929,13 @@ export declare class UndoRedoPlugin extends BaseGridPlugin<UndoRedoConfig> {
      *
      * @returns The undone action, or null if nothing to undo
      */
-    undo(): EditAction | null;
+    undo(): EditAction_2 | null;
     /**
      * Programmatically redo the last undone action.
      *
      * @returns The redone action, or null if nothing to redo
      */
-    redo(): EditAction | null;
+    redo(): EditAction_2 | null;
     /**
      * Check if there are any actions that can be undone.
      */
@@ -3402,13 +4951,15 @@ export declare class UndoRedoPlugin extends BaseGridPlugin<UndoRedoConfig> {
     /**
      * Get a copy of the current undo stack.
      */
-    getUndoStack(): EditAction[];
+    getUndoStack(): EditAction_2[];
     /**
      * Get a copy of the current redo stack.
      */
-    getRedoStack(): EditAction[];
+    getRedoStack(): EditAction_2[];
 }
 
+export declare const unregisterAggregator: (name: string) => void;
+
 /** Virtual window bookkeeping; modified in-place as scroll position changes. */
 declare interface VirtualState {
     enabled: boolean;
@@ -3446,7 +4997,7 @@ declare interface VisibilityConfig {
  * new VisibilityPlugin({ enabled: true, allowHideAll: false })
  * ```
  */
-export declare class VisibilityPlugin extends BaseGridPlugin<VisibilityConfig> {
+export declare class VisibilityPlugin extends BaseGridPlugin_2<VisibilityConfig> {
     readonly name = "visibility";
     readonly version = "1.0.0";
     /** Tool panel ID for shell integration */
@@ -3461,7 +5012,7 @@ export declare class VisibilityPlugin extends BaseGridPlugin<VisibilityConfig> {
     /**
      * Register the column visibility tool panel with the shell.
      */
-    getToolPanel(): ToolPanelDefinition | undefined;
+    getToolPanel(): ToolPanelDefinition_2 | undefined;
     /**
      * Show the visibility sidebar panel.
      */