eru-grid 0.0.1

package/index.d.ts

@@ -0,0 +1,788 @@
+import * as eru_grid from 'eru-grid';
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef } from '@angular/core';
+import { Observable } from 'rxjs';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+
+interface Row {
+    entity_id: string;
+    title: string;
+    groupId: string;
+    status: string;
+    index?: number;
+    [key: string]: any;
+}
+interface RowGroup {
+    id: string;
+    title: string;
+    totalRowCount: number;
+    rows: Row[];
+    isExpanded?: boolean;
+    isLoading?: boolean;
+    currentPage?: number;
+    hasMoreRows?: boolean;
+    currentLoadedRows: number;
+}
+interface GroupItem$1 {
+    type: 'header' | 'row' | 'table-header' | 'row-place-holder' | 'ghost-loading';
+    group?: RowGroup;
+    row?: Row;
+}
+interface ColumnWidthConstraints {
+    minWidth?: number;
+    maxWidth?: number;
+}
+type GridMode = 'table' | 'pivot';
+interface GridFeatures {
+    editable: boolean;
+    columnResizable: boolean;
+    columnReorderable: boolean;
+    cellSelection: boolean;
+    rowSelection: boolean;
+    exportable: boolean;
+    filtering: boolean;
+    showColumnLines?: boolean;
+    showRowLines?: boolean;
+    enableRowSubtotals?: boolean;
+    enableColumnSubtotals?: boolean;
+    enableGrandTotal?: boolean;
+    subtotalPosition?: 'before' | 'after';
+    subtotalLabel?: string;
+    freezeField?: string;
+}
+interface GridStyles {
+    gridLineColor?: string;
+    gridLineWidth?: number;
+    subtotalStyle?: 'bold' | 'italic' | 'highlighted';
+    grandTotalStyle?: 'bold' | 'italic' | 'highlighted';
+}
+interface GridConfiguration {
+    mode: GridMode;
+    config: GridFeatures;
+    styles?: GridStyles;
+    pivot?: PivotConfiguration;
+    data?: any[];
+    columnConstraints?: {
+        global?: ColumnWidthConstraints;
+        byDatatype?: Partial<Record<DataTypes, ColumnWidthConstraints>>;
+    };
+}
+interface Field {
+    name: string;
+    label: string;
+    datatype: DataTypes;
+    field_size: number;
+    grid_index: number;
+    minWidth?: number;
+    maxWidth?: number;
+    symbol?: string;
+    isLeaf?: boolean;
+    parentPath?: string[];
+    children?: Field[];
+    level?: number;
+    colspan?: number;
+    rowspan?: number;
+    showSubtotals?: boolean;
+    aggregationFunction?: AggregationFunction;
+}
+type DataTypes = 'number' | 'textbox' | 'currency' | 'date' | 'dropdown_single_select' | 'dropdown_multi_select' | 'location' | 'email' | 'people' | 'checkbox' | 'phone' | 'priority' | 'status' | 'progress' | 'attachment' | 'tags';
+type AggregationFunction = 'sum' | 'count' | 'avg' | 'min' | 'max';
+interface PivotColumnGroupState {
+    [groupKey: string]: {
+        isExpanded: boolean;
+        level: number;
+        childGroups?: string[];
+        parentGroup?: string;
+    };
+}
+interface PivotConfiguration {
+    rows: string[];
+    cols: string[];
+    aggregations: Field[];
+    clientSideThreshold?: number;
+}
+interface PivotMetadata {
+    totalRows: number;
+    totalColumns: number;
+    processingTime?: number;
+    memoryUsed?: number;
+    dataSize: number;
+}
+interface PivotRow {
+    [key: string]: any;
+    _rowKey: string;
+    _sourceCount: number;
+    _isSubtotal?: boolean;
+    _isGrandTotal?: boolean;
+    _subtotalLevel?: number;
+    _subtotalLabel?: string;
+}
+interface PivotColumnHeader {
+    label: string;
+    children?: PivotColumnHeader[];
+    leafColumns?: string[];
+    level: number;
+    colspan: number;
+    rowspan: number;
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    subtotalLevel?: number;
+    isCollapsible?: boolean;
+    isExpanded?: boolean;
+    groupKey?: string;
+    parentGroupKey?: string;
+    collapsedValue?: any;
+    collapsedDisplayMode?: 'subtotal' | 'aggregated' | 'first-value' | 'count';
+}
+interface PivotHeaderStructure {
+    maxDepth: number;
+    headerRows: PivotColumnHeader[][];
+    leafColumns: Field[];
+}
+interface PivotResult {
+    data: PivotRow[];
+    columnDefinitions: Field[];
+    rowCount: number;
+    metadata: PivotMetadata;
+    configuration: PivotConfiguration;
+    headerStructure?: PivotHeaderStructure;
+    columnGroupState?: PivotColumnGroupState;
+}
+
+declare class PivotTransformService {
+    private columnGroupState;
+    /**
+     * Main method to transform flat data into pivot table
+     */
+    transformData(sourceData: any[], configuration: PivotConfiguration, gridConfiguration?: GridConfiguration): PivotResult;
+    /**
+     * Group data by row dimensions
+     */
+    private groupByDimensions;
+    /**
+     * Sort grouped data hierarchically so parent dimensions appear with their children grouped together
+     */
+    private sortGroupsHierarchically;
+    /**
+     * Natural sort that handles numbers properly
+     */
+    private naturalSort;
+    /**
+     * Generate unique pivot column values using cartesian product of all dimension values
+     */
+    private generatePivotColumns;
+    /**
+     * Create pivot rows with aggregated data (PERFORMANCE OPTIMIZED)
+     */
+    private createPivotRows;
+    /**
+     * Calculate aggregation for a field (PERFORMANCE OPTIMIZED)
+     */
+    private calculateAggregationOptimized;
+    /**
+     * Calculate aggregation for a field (ORIGINAL - kept for compatibility)
+     */
+    private calculateAggregation;
+    /**
+     * Generate column definitions for the pivot table
+     */
+    private generateColumnDefinitions;
+    /**
+     * Format column label for display
+     */
+    private formatColumnLabel;
+    /**
+     * Get appropriate data type for aggregation function
+     */
+    private getAggregationDataType;
+    /**
+     * Optimize data for large datasets by processing in chunks
+     */
+    transformDataAsync(sourceData: any[], configuration: PivotConfiguration, chunkSize?: number): Promise<PivotResult>;
+    /**
+     * Split array into chunks
+     */
+    private chunkArray;
+    /**
+     * Generate nested header structure for multi-dimensional columns
+     */
+    private generateNestedHeaderStructure;
+    /**
+     * Build nested column headers recursively - generates complete cartesian product structure
+     */
+    private buildNestedHeaders;
+    /**
+     * Calculate colspan for a header at given level
+     */
+    private calculateColspan;
+    /**
+     * Generate leaf columns for the actual data with collapsible support
+     */
+    private generateLeafColumnsWithCollapsible;
+    /**
+     * Get collapsed levels for a combination path
+     */
+    private getCollapsedLevels;
+    /**
+     * Generate leaf columns for the actual data
+     */
+    private generateLeafColumns;
+    /**
+     * Generate all combinations of dimension values
+     */
+    private generateCombinations;
+    /**
+     * Generate flat header structure for single dimension
+     */
+    private generateFlatHeaderStructure;
+    /**
+     * Add subtotals to pivot data based on configuration
+     */
+    private addSubtotals;
+    /**
+     * Add subtotal rows for row dimensions
+     */
+    private addRowSubtotals;
+    /**
+     * Add grand total row
+     */
+    private addGrandTotalRow;
+    /**
+     * Calculate grand total values for all rows (ignores showSubtotals flag)
+     */
+    private calculateGrandTotalRow;
+    /**
+     * Calculate subtotal values for a group of rows
+     */
+    private calculateSubtotalRow;
+    /**
+     * Apply aggregation function to array of values
+     */
+    private applyAggregationFunction;
+    /**
+     * Group rows by dimension values
+     */
+    private groupRowsByDimensions;
+    /**
+     * Export pivot data to CSV format
+     */
+    exportToCsv(pivotResult: PivotResult): string;
+    /**
+     * Initialize column group state based on configuration
+     */
+    /**
+     * Generate unique key for column group
+     */
+    private generateColumnGroupKey;
+    /**
+     * Toggle collapse/expand state of a column group
+     */
+    toggleColumnGroup(groupKey: string, configuration: PivotConfiguration): void;
+    /**
+     * Check if a column group is expanded
+     */
+    isColumnGroupExpanded(groupKey: string): boolean;
+    /**
+     * Get collapsed value for a column group
+     */
+    /**
+     * Calculate subtotal for a column group
+     */
+    private calculateGroupSubtotal;
+    /**
+     * Calculate aggregated value for a column group
+     */
+    private calculateGroupAggregation;
+    /**
+     * Get column keys that belong to a specific group
+     */
+    private getGroupColumnKeys;
+    /**
+     * Get first child value for a column group
+     */
+    private getFirstChildValue;
+    /**
+     * Get count of non-null values in a column group
+     */
+    private getGroupValueCount;
+    /**
+     * Get current column group state
+     */
+    getColumnGroupState(): PivotColumnGroupState;
+    /**
+     * Set column group state (for restoring state)
+     */
+    setColumnGroupState(state: PivotColumnGroupState): void;
+    /**
+     * Calculate rowspan information for pivot rows to merge cells with same values
+     * in earlier dimensions
+     */
+    calculateRowspanInfo(pivotRows: PivotRow[], rowDimensions: string[]): Map<string, {
+        rowspan: number;
+        skip: boolean;
+        parentSpan: number;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PivotTransformService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PivotTransformService>;
+}
+
+declare class GridStore {
+    private readonly gridConfigService;
+    private readonly pivotTransformService;
+    private readonly _columns;
+    private readonly _groups;
+    private readonly _rows;
+    private readonly _selectedRowIds;
+    private readonly _configuration;
+    private readonly _isLoading;
+    private readonly _error;
+    private readonly _activeCell;
+    private readonly _pivotConfiguration;
+    private readonly _pivotResult;
+    readonly columns: _angular_core.Signal<Field[]>;
+    readonly groups: _angular_core.Signal<RowGroup[]>;
+    readonly rows: _angular_core.Signal<Row[]>;
+    readonly selectedRowIds: _angular_core.Signal<Set<string>>;
+    readonly configuration: _angular_core.Signal<GridConfiguration>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly activeCell: _angular_core.Signal<any>;
+    readonly pivotConfiguration: _angular_core.Signal<PivotConfiguration | null>;
+    readonly pivotResult: _angular_core.Signal<PivotResult | null>;
+    readonly selectedRows: _angular_core.Signal<Row[]>;
+    readonly totalSelectedCount: _angular_core.Signal<number>;
+    readonly hasSelection: _angular_core.Signal<boolean>;
+    readonly expandedGroups: _angular_core.Signal<RowGroup[]>;
+    readonly visibleColumns: _angular_core.Signal<Field[]>;
+    readonly rowsByGroup: _angular_core.Signal<Map<string, Row[]>>;
+    readonly currentMode: _angular_core.Signal<GridMode>;
+    readonly isPivotMode: _angular_core.Signal<boolean>;
+    readonly isEditingEnabled: _angular_core.Signal<boolean>;
+    readonly displayColumns: _angular_core.Signal<Field[]>;
+    readonly displayData: _angular_core.Signal<Row[] | eru_grid.PivotRow[]>;
+    readonly pivotDisplayData: _angular_core.Signal<eru_grid.PivotRow[]>;
+    readonly tableDisplayData: _angular_core.Signal<Row[]>;
+    setColumns(columns: Field[]): void;
+    reorderColumns(fromIndex: number, toIndex: number): void;
+    updateColumnWidth(columnName: string, field_size: number): void;
+    setGroups(groups: RowGroup[]): void;
+    toggleGroupExpansion(groupId: string): void;
+    updateGroupLoadingState(groupId: string, isLoading: boolean): void;
+    updateGroupAfterLoading(groupId: string, loadedCount: number, fullyExhausted?: boolean): void;
+    setRows(rows: Row[]): void;
+    addRows(newRows: Row[]): void;
+    updateRow(rowId: string, updates: Partial<Row>): void;
+    selectRow(rowId: string): void;
+    deselectRow(rowId: string): void;
+    toggleRowSelection(rowId: string): void;
+    selectAllRowsInGroup(groupId: string): void;
+    deselectAllRowsInGroup(groupId: string): void;
+    clearSelection(): void;
+    setConfiguration(configuration: GridConfiguration): void;
+    gridConfiguration(): GridConfiguration;
+    setActiveCell(activeCell: any): void;
+    setLoading(isLoading: boolean): void;
+    setError(error: string | null): void;
+    fetchNewRowData(pageSize: number, page: number, group: RowGroup): Observable<any[]>;
+    isRowSelected(rowId: string): boolean;
+    isGroupSelected(groupId: string): boolean;
+    getRowsForGroup(groupId: string): Row[];
+    setGridMode(mode: GridMode): void;
+    updateGridConfiguration(updates: Partial<GridConfiguration>): void;
+    setPivotConfiguration(pivotConfig: PivotConfiguration): void;
+    setSourceData(data: any[]): void;
+    private transformToPivot;
+    clearPivot(): void;
+    forceRefreshPivot(): void;
+    exportPivotToCsv(): string | null;
+    validatePivotConfiguration(config: PivotConfiguration): {
+        isValid: boolean;
+        errors: string[];
+    };
+    isFeatureEnabled(feature: keyof Omit<GridFeatures, 'subtotalPosition' | 'subtotalLabel' | 'freezeField'>): boolean;
+    /**
+     * Get access to the PivotTransformService for external manipulation
+     */
+    getPivotTransformService(): PivotTransformService;
+    /**
+     * Regenerate pivot data (useful after column group state changes)
+     */
+    regeneratePivotData(): void;
+    /**
+     * Update pivot configuration and regenerate if needed
+     */
+    updatePivotConfiguration(updates: Partial<PivotConfiguration>): void;
+    /**
+     * Check if freeze is enabled and valid for current mode
+     */
+    isFreezeEnabled(): boolean;
+    /**
+     * Validate freeze field for pivot mode
+     */
+    private isValidPivotFreezeField;
+    /**
+     * Get the freeze field name
+     */
+    getFreezeField(): string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GridStore>;
+}
+
+type Theme = 'light' | 'dark' | 'high-contrast' | 'auto';
+declare class ThemeService {
+    private document;
+    private readonly storageKey;
+    private readonly _currentTheme;
+    private readonly _systemTheme;
+    readonly currentTheme: _angular_core.Signal<Theme>;
+    readonly systemTheme: _angular_core.Signal<"light" | "dark">;
+    readonly effectiveTheme: _angular_core.WritableSignal<"light" | "dark" | "high-contrast">;
+    constructor();
+    private initializeTheme;
+    private setupSystemThemeListener;
+    private applyTheme;
+    private updateCSSVariables;
+    setTheme(theme: Theme): void;
+    toggleTheme(): void;
+    getAvailableThemes(): Array<{
+        value: Theme;
+        label: string;
+    }>;
+    isLightTheme(): boolean;
+    isDarkTheme(): boolean;
+    isHighContrastTheme(): boolean;
+    isAutoTheme(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare class ColumnConstraintsService {
+    private readonly DATATYPE_DEFAULTS;
+    /**
+     * Get effective constraints for a column, considering all override levels
+     */
+    getColumnConstraints(column: Field | undefined, gridConfig?: GridConfiguration): ColumnWidthConstraints;
+    /**
+     * Validate and constrain a width value for a column
+     */
+    constrainWidth(width: number, column: Field | undefined, gridConfig?: GridConfiguration): number;
+    /**
+     * Get all datatype defaults (for documentation/debugging)
+     */
+    getDatatypeDefaults(): Record<DataTypes, ColumnWidthConstraints>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnConstraintsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ColumnConstraintsService>;
+}
+
+declare class EruGridService {
+    private gridStore;
+    private themeService;
+    private columnConstraintsService;
+    constructor(gridStore: GridStore, themeService: ThemeService, columnConstraintsService: ColumnConstraintsService);
+    set_table_configuration(data: GridConfiguration): void;
+    set_table_column(data: Field[]): void;
+    set_table_group(data: RowGroup[]): void;
+    get columns(): _angular_core.Signal<Field[]>;
+    get groups(): _angular_core.Signal<RowGroup[]>;
+    get rows(): _angular_core.Signal<eru_grid.Row[]>;
+    get selectedRowIds(): _angular_core.Signal<Set<string>>;
+    get hasSelection(): _angular_core.Signal<boolean>;
+    get theme(): ThemeService;
+    getColumnConstraints(column: Field | undefined): eru_grid.ColumnWidthConstraints;
+    constrainColumnWidth(width: number, column: Field | undefined): number;
+    getDatatypeDefaults(): Record<DataTypes, eru_grid.ColumnWidthConstraints>;
+    /**
+     * Configure the grid for pivot mode with pivot configuration
+     */
+    set_pivot_configuration(pivotConfig: PivotConfiguration, sourceData?: any[]): void;
+    /**
+     * Switch grid to table mode or pivot mode
+     */
+    set_grid_mode(mode: GridMode): void;
+    /**
+     * Update grid configuration with new settings
+     */
+    update_grid_configuration(updates: Partial<GridConfiguration>): void;
+    /**
+     * Enable or disable specific grid features
+     */
+    set_grid_features(features: Partial<GridFeatures>): void;
+    /**
+     * Clear pivot configuration and return to table mode
+     */
+    clear_pivot(): void;
+    /**
+     * Export pivot data to CSV format
+     */
+    export_pivot_to_csv(): string | null;
+    /**
+     * Validate pivot configuration
+     */
+    validate_pivot_configuration(config: PivotConfiguration): {
+        isValid: boolean;
+        errors: string[];
+    };
+    get currentMode(): _angular_core.Signal<GridMode>;
+    get isPivotMode(): _angular_core.Signal<boolean>;
+    get pivotConfiguration(): _angular_core.Signal<PivotConfiguration | null>;
+    get pivotResult(): _angular_core.Signal<eru_grid.PivotResult | null>;
+    get displayColumns(): _angular_core.Signal<Field[]>;
+    get displayData(): _angular_core.Signal<eru_grid.Row[] | eru_grid.PivotRow[]>;
+    get isEditingEnabled(): _angular_core.Signal<boolean>;
+    get configuration(): _angular_core.Signal<GridConfiguration>;
+    get isLoading(): _angular_core.Signal<boolean>;
+    get error(): _angular_core.Signal<string | null>;
+    /**
+     * Check if a specific feature is enabled
+     */
+    isFeatureEnabled(feature: keyof Omit<GridFeatures, 'subtotalPosition' | 'subtotalLabel' | 'freezeField'>): boolean;
+    /**
+     * Get direct access to grid store (for debugging purposes)
+     */
+    getGridStore(): GridStore;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EruGridService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EruGridService>;
+}
+
+declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
+    private changeDetectorRef;
+    gridStore: GridStore;
+    private resizeObserver;
+    isColumnReordering: _angular_core.WritableSignal<boolean>;
+    viewport?: CdkVirtualScrollViewport;
+    rowContainer?: ElementRef;
+    private rowLoadQueue;
+    private isProcessingQueue;
+    groupedRows: _angular_core.Signal<GroupItem[]>;
+    columns: _angular_core.Signal<Field[]>;
+    selectedRowIds: _angular_core.Signal<Set<string>>;
+    currentPivotScrollIndex: _angular_core.WritableSignal<number>;
+    firstDataRowIndex: _angular_core.WritableSignal<number>;
+    private _virtualRowspanCache;
+    showColumnLines: _angular_core.Signal<boolean>;
+    showRowLines: _angular_core.Signal<boolean>;
+    gridLineColor: _angular_core.Signal<string>;
+    gridLineWidth: _angular_core.Signal<number>;
+    maxDepth: _angular_core.Signal<number>;
+    subtotalStyle: _angular_core.Signal<"bold" | "italic" | "highlighted">;
+    grandTotalStyle: _angular_core.Signal<"bold" | "italic" | "highlighted">;
+    /**
+     * Check if a row is the first visible row in the pivot viewport
+     * @param rowIndex The index of the row in the virtual scroll
+     * @returns true if this is the first visible row
+     */
+    isFirstVisiblePivotRow(rowIndex: number): boolean;
+    /**
+     * Check if a specific row is the first visible row by comparing with scroll index
+     * @param rowIndex The index of the row to check
+     * @returns true if this row is the first visible row
+     */
+    isRowFirstVisible(rowIndex: number): boolean;
+    /**
+     * Handle scroll events for pivot mode
+     * @param scrollIndex The current scroll index
+     */
+    onPivotScroll(scrollIndex: number): void;
+    /**
+     * Get the actual data index of the first visible row in the pivot data array
+     * @returns The actual index in the pivot data array, or -1 if not available
+     */
+    getFirstVisiblePivotDataIndex(): number;
+    /**
+     * Get the truly visible range (what's actually visible on screen)
+     * @returns Object with start, end, and count of visible items
+     */
+    getVisibleRange(): {
+        start: number;
+        end: number;
+        count: number;
+    };
+    /**
+     * Calculate the actual number of items visible in the viewport
+     * This accounts for headers, padding, and actual viewport dimensions
+     */
+    private getActualVisibleItemCount;
+    /**
+     * Get the rendered range (what's in the DOM including buffer)
+     * @returns Object with start, end, and count of rendered items
+     */
+    getRenderedRange(): {
+        start: number;
+        end: number;
+        count: number;
+    };
+    /**
+     * Get current scroll and visibility information for debugging
+     * @returns Object with current scroll state and ranges
+     */
+    getCurrentScrollInfo(): {
+        scrollIndex: number;
+        visibleRange: {
+            start: number;
+            end: number;
+            count: number;
+        };
+        renderedRange: {
+            start: number;
+            end: number;
+            count: number;
+        };
+        cdkViewportSize: number;
+        actualVisibleCount: number;
+        dataLength: number;
+        viewportHeight: number;
+    };
+    private updateGridLineStyles;
+    private readonly ROWS_PER_PAGE;
+    private readonly SCROLL_THRESHOLD;
+    private lastLoadedGroupIds;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private createGroupedRows;
+    private recalculateViewport;
+    initializeGroups(): void;
+    private fetchInitialRows;
+    fetchRowsForGroup(groupId: string, page: number, pageSize?: number): Promise<void>;
+    private updateGroupLoadingState;
+    private updateGroupAfterLoading;
+    onScroll(scrollIndex: number): void;
+    private getVisibleGroups;
+    private getGroupItemAtIndex;
+    private checkAndLoadMoreRows;
+    private intelligentRowLoading;
+    private checkGroupRowLoading;
+    private queueRowLoading;
+    private adjustColumnWidths;
+    private ensureHorizontalScroll;
+    trackByColumnFn(index: number, column: Field): string;
+    trackByGroupItemFn(index: number, groupItem: GroupItem): string;
+    trackByPivotRowFn(index: number, pivotRow: PivotRow): string;
+    trackByHeaderFn(index: number, header: any): string;
+    hasNestedHeaders(): boolean;
+    getHeaderRows(): any[][];
+    getLeafColumns(): Field[];
+    isRowDimensionHeader(header: any): boolean;
+    getPivotGridColumns(): string;
+    private initializeColumnWidths;
+    private measureAndSetContainerDimensions;
+    private normalizeRowData;
+    private getDisplayValue;
+    private getGenericRowDisplay;
+    toggleRowSelection(event: Event, row: any): void;
+    toggleGroupSelection(event: Event, groupId: string): void;
+    toggleAllGroups(event: Event): void;
+    isRowSelected(rowId?: string): boolean;
+    isGroupSelected(groupId: string): boolean;
+    isAllGroupsSelected(): boolean;
+    getSelectedRows(): any[];
+    private markGroupAsNoMoreRows;
+    toggleGroupExpansion(groupId: string): void;
+    private processRowLoadQueue;
+    /**
+     * Toggle collapse/expand state of a column group
+     */
+    toggleColumnGroup(groupKey: string): void;
+    /**
+     * Check if a column group is expanded
+     */
+    isColumnGroupExpanded(groupKey: string): boolean;
+    /**
+     * Get rowspan information for pivot table cells
+     */
+    private _rowspanInfo;
+    /**
+     * Debug counter for sticky column debugging
+     */
+    private _stickyDebugCount;
+    getRowspanInfo(): Map<string, {
+        rowspan: number;
+        skip: boolean;
+        parentSpan: number;
+    }>;
+    /**
+     * Clear rowspan cache when pivot data changes
+     */
+    clearRowspanCache(): void;
+    /**
+     * Get the effective rowspan for a cell in virtual scrolling context
+     * This method ensures proper rowspan continuity when scrolling
+     */
+    getEffectiveRowspan(visibleRowIndex: number, columnName: string): number | null;
+    /**
+     * Find virtual parent information for cells that inherit rowspan from a parent row
+     */
+    private findVirtualParent;
+    /**
+     * Find the first visible row index that should show the value for a given column
+     */
+    private findFirstVisibleRowForColumn;
+    /**
+     * Check if a cell should be skipped (hidden due to rowspan) - ENHANCED FOR VIRTUAL SCROLLING
+     */
+    shouldSkipCell(rowIndex: number, columnName: string): boolean;
+    /**
+     * Get the effective cell value, considering virtual parents for virtual scrolling
+     */
+    getEffectiveCellValue(index: number, columnName: string, pivotRow: any): any;
+    /**
+     * Get rowspan value for a specific cell - VIRTUAL SCROLLING COMPATIBLE
+     * This is a compatibility wrapper around getEffectiveRowspan
+     */
+    getCellRowspan(rowIndex: number, columnName: string): number;
+    /**
+     * Get columns that should be frozen on the left (all row dimensions up to and including freezeField)
+     */
+    getRowDimensionColumns(): any[];
+    /**
+     * Get columns that should be scrollable on the right (all except frozen fields)
+     */
+    getColumnDimensionColumns(): any[];
+    /**
+     * Get headers that should be frozen (all row dimension headers up to and including freezeField)
+     */
+    getRowDimensionHeaders(headerRow: any[]): any[];
+    /**
+     * Get headers that should be scrollable (all except frozen fields)
+     */
+    getColumnDimensionHeaders(headerRow: any[]): any[];
+    /**
+     * Check if a column should be sticky (frozen on the left)
+     */
+    isStickyColumn(columnName: string, colIndex: number): boolean;
+    /**
+     * Get the left position for sticky columns (CSS left value)
+     */
+    getStickyColumnLeft(columnName: string, colIndex: number): number;
+    /**
+     * Check if a column is a row dimension column
+     */
+    isRowDimensionColumn(columnName: string): boolean;
+    private setupScrollSync;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EruGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EruGridComponent, "eru-grid", never, {}, {}, never, never, true, never>;
+}
+interface GroupItem {
+    type: 'header' | 'row' | 'table-header' | 'row-place-holder' | 'ghost-loading';
+    group?: RowGroup;
+    row?: Row;
+}
+
+declare class ThemeToggleComponent {
+    private themeService;
+    availableThemes: {
+        value: Theme;
+        label: string;
+    }[];
+    getCurrentThemeLabel(): string;
+    getCurrentThemeIcon(): string;
+    getThemeIcon(theme: Theme): string;
+    isActiveTheme(theme: Theme): boolean;
+    setTheme(theme: Theme): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThemeToggleComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThemeToggleComponent, "eru-theme-toggle", never, {}, {}, never, never, true, never>;
+}
+
+export { ColumnConstraintsService, EruGridComponent, EruGridService, GridStore, ThemeService, ThemeToggleComponent };
+export type { AggregationFunction, ColumnWidthConstraints, DataTypes, Field, GridConfiguration, GridFeatures, GridMode, GridStyles, GroupItem$1 as GroupItem, PivotColumnGroupState, PivotColumnHeader, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, Row, RowGroup, Theme };