eru-grid 0.0.21 → 0.0.23

package/types/eru-grid.d.ts

@@ -0,0 +1,1512 @@
+import * as eru_grid from 'eru-grid';
+import * as _angular_core from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy, QueryList, ElementRef, ChangeDetectorRef, EventEmitter, Provider } from '@angular/core';
+import { FixedSizeVirtualScrollStrategy, CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { MatDatepicker } from '@angular/material/datepicker';
+import { MatCommonModule } from '@angular/material/core';
+
+interface Row {
+    entity_id: string;
+    entity_data: {
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+interface RowGroup {
+    id: string;
+    key: string;
+    title: string;
+    totalRowCount: number;
+    isExpanded?: boolean;
+    isLoading?: boolean;
+    currentPage?: number;
+    hasMoreRows?: boolean;
+    currentLoadedRows: number;
+    subtotal?: {
+        [key: string]: number;
+    };
+}
+interface RowGrandTotal {
+    [key: string]: 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;
+    enableColumnGrandTotal?: boolean;
+    enableGrandTotal?: boolean;
+    subtotalPosition?: 'before' | 'after';
+    subtotalPositionColumn?: 'before' | 'after';
+    grandTotalPosition?: 'before' | 'after';
+    grandTotalPositionColumn?: 'before' | 'after';
+    subtotalLabel?: string;
+    freezeField?: string;
+    freezeHeader?: boolean;
+    freezeGrandTotal?: boolean;
+    replaceZeroValue?: string;
+    gridHeight?: number;
+    allowSelection?: boolean;
+    actionColumn?: boolean;
+    actionColumnPosition?: 'before' | 'after';
+    designMode?: boolean;
+}
+interface GridStyles {
+    subTotalStyle?: 'bold' | 'italic' | 'highlighted';
+    grandTotalStyle?: 'bold' | 'italic' | 'highlighted';
+}
+interface GridTokens {
+    [key: string]: string;
+}
+interface GridConfiguration {
+    mode: GridMode;
+    config: GridFeatures;
+    fields: Field[];
+    styles?: GridStyles;
+    tokens?: GridTokens;
+    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;
+    required?: boolean;
+    mandatory?: boolean;
+    minWidth?: number;
+    maxWidth?: number;
+    symbol?: string;
+    options?: any[];
+    option_type?: 'STATIC' | 'API' | 'ENTITY_DATA';
+    entity_name?: string;
+    api_field?: string;
+    api_name?: string;
+    field_name?: string;
+    decimal?: number;
+    num_val?: number;
+    num_val_check?: 'MAX' | 'MIN';
+    seperator?: 'thousands' | 'millions' | 'none';
+    isLeaf?: boolean;
+    parentPath?: string[];
+    children?: Field[];
+    level?: number;
+    colspan?: number;
+    rowspan?: number;
+    showSubtotals?: boolean;
+    aggregationFunction?: AggregationFunction;
+    enableDrilldown?: boolean;
+}
+type DataTypes = 'number' | 'textbox' | 'currency' | 'date' | 'datetime' | 'duration' | '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;
+    name: string;
+    children?: PivotColumnHeader[];
+    leafColumns?: string[];
+    level: number;
+    colspan: number;
+    rowspan: number;
+    dataType: DataTypes;
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    subtotalLevel?: number;
+    parentValue?: string;
+    isCollapsible?: boolean;
+    isExpanded?: boolean;
+    groupKey?: string;
+    parentGroupKey?: string;
+    collapsedValue?: any;
+    collapsedDisplayMode?: 'subtotal' | 'aggregated' | 'first-value' | 'count';
+    enableDrilldown?: boolean;
+}
+interface PivotHeaderStructure {
+    maxDepth: number;
+    headerRows: PivotColumnHeader[][];
+    leafColumns: Field[];
+}
+interface PivotResult {
+    data: PivotRow[];
+    columnDefinitions: Field[];
+    rowCount: number;
+    metadata: PivotMetadata;
+    configuration: PivotConfiguration;
+    headerStructure?: PivotHeaderStructure;
+    columnGroupState?: PivotColumnGroupState;
+}
+interface Drilldown {
+    frozenGrandTotalCell: boolean;
+    columnName: string;
+    rowId: string;
+    rowData?: any;
+    columnValue: any;
+}
+interface ActionClick {
+    rowId: string;
+    rowData?: any;
+}
+interface RowDataRequest {
+    groupId: string;
+    page: number;
+    pageSize: number;
+    timestamp: number;
+    groupTitle?: string;
+    groupKey?: string;
+}
+interface RowDataResponse {
+    groupId: string;
+    rows: Row[];
+    hasMore: boolean;
+    totalCount?: number;
+}
+
+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 and collect unique column dimension values
+     */
+    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;
+    /**
+     * Convert string to title case
+     */
+    private toTitleCase;
+    /**
+     * Generate unique pivot column values from pre-collected dimension value sets
+     */
+    private generatePivotColumnsFromSets;
+    /**
+     * 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 with collapsible support
+     */
+    private generateNestedHeaderStructure;
+    /**
+     * Build nested column headers recursively - generates complete cartesian product structure
+     */
+    private buildNestedHeaders;
+    /**
+     * Calculate colspan for a header at given level - GENERIC VERSION
+     */
+    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 column subtotals as new columns
+     */
+    private addColumnSubtotals;
+    /**
+     * Generate all possible subtotal combinations for hierarchical column dimensions
+     */
+    private generateSubtotalCombinations;
+    /**
+     * Generate all possible dimension paths at a specific level
+     */
+    private generateCombinationsAtLevel;
+    /**
+     * Generate columns with properly positioned subtotal columns
+     */
+    private generateColumnsWithInterleavedSubtotals;
+    /**
+     * Group combinations by dimension levels for subtotal insertion
+     */
+    private groupCombinationsByDimensions;
+    /**
+     * Add interleaved subtotals within column groups
+     */
+    private addInterleavedSubtotals;
+    /**
+     * Group pivot columns by dimension prefixes for subtotal insertion
+     */
+    private groupPivotColumnsByDimensions;
+    /**
+     * Create a subtotal column for a specific dimension prefix
+     */
+    private createSubtotalColumn;
+    /**
+     * Add grand total row
+     */
+    private addGrandTotalRow;
+    /**
+     * Add column grand totals as new columns
+     */
+    private addColumnGrandTotals;
+    /**
+     * 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;
+    /**
+     * 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;
+    }>;
+    /**
+     * Insert column subtotal headers at the correct positions within each priority group
+     */
+    private insertColumnSubtotalHeaders;
+    /**
+     * Add subtotal headers at their correct row levels
+     */
+    private addSubtotalHeadersAtCorrectLevels;
+    /**
+     * Rearrange headers in each row to match the leaf column order
+     */
+    private rearrangeHeadersToMatchLeafColumns;
+    /**
+     * Reorder headers by hierarchy to match leaf column interleaved positioning - GENERIC VERSION
+     */
+    private reorderHeadersByHierarchy;
+    /**
+     * Extract unique values for a specific column dimension from source data
+     */
+    private extractDimensionValues;
+    /**
+     * Extract all dimension values arrays from headers or source data
+     */
+    private extractAllDimensionValues;
+    /**
+     * Group rating headers by their priority parent - GENERIC VERSION
+     */
+    private groupRatingHeadersByPriority;
+    /**
+     * Group subtotals by their priority
+     */
+    private groupSubtotalsByPriority;
+    /**
+     * Group status headers by their rating parent (combination) - GENERIC VERSION
+     */
+    private groupStatusHeadersByRating;
+    /**
+     * Group subtotals by their rating (Priority+Rating combination)
+     */
+    private groupSubtotalsByRating;
+    /**
+     * Add parent group keys to headers based on their position and row level - GENERIC VERSION
+     */
+    private addParentGroupKeysToHeaders;
+    /**
+     * Group headers by their parentGroupKey
+     */
+    private groupHeadersByParentKey;
+    /**
+     * Group subtotals by their parentGroupKey
+     */
+    private groupSubtotalsByParentKey;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PivotTransformService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PivotTransformService>;
+}
+
+declare class EruGridStore {
+    private readonly gridConfigService;
+    private readonly pivotTransformService;
+    private readonly columnConstraintsService;
+    private readonly _columns;
+    private readonly _groups;
+    private readonly _rows;
+    private _groupRows;
+    private readonly _selectedRowIds;
+    private readonly _rowGrandTotal;
+    private readonly _dynamicDataRequest;
+    private readonly _dynamicData;
+    private readonly _configuration;
+    private readonly _isLoading;
+    private readonly _error;
+    private readonly _activeCell;
+    private readonly _pivotConfiguration;
+    private readonly _pivotResult;
+    private readonly _drilldown;
+    private readonly _actionClick;
+    private readonly _dataRequest;
+    private readonly _requestQueue;
+    readonly columns: _angular_core.Signal<Field[]>;
+    readonly groups: _angular_core.Signal<RowGroup[]>;
+    readonly rows: _angular_core.Signal<Row[]>;
+    readonly groupRows: _angular_core.Signal<Map<string, Row[]>>;
+    readonly selectedRowIds: _angular_core.Signal<Set<string>>;
+    readonly configuration: _angular_core.Signal<GridConfiguration>;
+    readonly isLoading: _angular_core.Signal<boolean>;
+    readonly requestQueue: _angular_core.Signal<RowDataRequest[]>;
+    readonly error: _angular_core.Signal<string | null>;
+    readonly activeCell: _angular_core.Signal<any>;
+    readonly rowGrandTotal: _angular_core.Signal<RowGrandTotal | null>;
+    readonly pivotConfiguration: _angular_core.Signal<PivotConfiguration | null>;
+    readonly pivotResult: _angular_core.Signal<PivotResult | null>;
+    readonly drilldown: _angular_core.Signal<Drilldown | null>;
+    readonly actionClick: _angular_core.Signal<ActionClick | null>;
+    readonly dataRequest: _angular_core.Signal<RowDataRequest | null>;
+    readonly dynamicDataRequest: _angular_core.Signal<string[] | null>;
+    readonly dynamicData: _angular_core.Signal<Map<string, any> | 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 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<PivotRow[] | Row[]>;
+    readonly pivotGrandTotalData: _angular_core.Signal<PivotRow[]>;
+    readonly pivotDisplayData: _angular_core.Signal<PivotRow[]>;
+    readonly tableDisplayData: _angular_core.Signal<Row[]>;
+    setColumns(columns: Field[]): void;
+    /**
+     * Detect which columns are used for grouping by analyzing row data
+     * A column is considered grouped if all rows within each group have the same value
+     */
+    private detectGroupedColumns;
+    /**
+     * Get column value from a row
+     */
+    private getRowColumnValue;
+    /**
+     * Compare two values for equality, handling null/undefined
+     */
+    private compareValues;
+    getConfiguration(): GridConfiguration;
+    reorderColumns(fromIndex: number, toIndex: number): void;
+    updateColumnRequired(columnName: string, required: boolean): 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;
+    /**
+       * Validates and enforces rules for grid configuration
+       */
+    validateAndEnforceConfiguration(config: GridConfiguration): GridConfiguration;
+    /**
+     * Update specific configuration properties
+     * This method ensures proper signal updates for nested properties
+     */
+    updateConfigurationProperties(updates: Partial<GridConfiguration['config']>): void;
+    /**
+     * Update grid lines configuration
+     * This method specifically handles grid lines updates
+     */
+    updateGridLines(showColumnLines?: boolean, showRowLines?: boolean): void;
+    gridConfiguration(): GridConfiguration;
+    setActiveCell(activeCell: any): void;
+    setLoading(isLoading: boolean): void;
+    setError(error: string | null): void;
+    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;
+    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;
+    /**
+     * Check if freeze header is enabled
+     */
+    isFreezeHeaderEnabled(): boolean;
+    /**
+     * Check if freeze grand total is enabled
+     */
+    isFreezeGrandTotalEnabled(): boolean;
+    setDrilldown(drilldown: Drilldown, columnValues: string): void;
+    clearPivotDrilldown(): void;
+    setActionClick(actionClick: ActionClick): void;
+    clearActionClick(): void;
+    /**
+     * Emit a data request signal (called by grid component)
+     */
+    setDataRequest(request: RowDataRequest): void;
+    /**
+     * Add request to queue (for handling multiple simultaneous requests)
+     */
+    addToRequestQueue(request: RowDataRequest): void;
+    /**
+     * Remove request from queue (called by consumer after handling)
+     */
+    removeFromRequestQueue(requestId: string): void;
+    /**
+     * Clear all requests from queue
+     */
+    clearRequestQueue(): void;
+    /**
+     * Clear the data request signal (called by consumer after handling)
+     */
+    clearDataRequest(): void;
+    /**
+     * Mark a group as loading (called by grid component before requesting)
+     */
+    startGroupLoading(groupId: string): void;
+    /**
+     * Complete loading for a group (called by consumer after data received)
+     */
+    completeGroupLoading(groupId: string): void;
+    /**
+     * Add rows for a specific group (called by consumer with API data)
+     */
+    addRowsForGroup(groupId: string, rows: Row[], hasMore: boolean): void;
+    /**
+     * Handle error for data request (called by consumer when API fails)
+     */
+    handleDataRequestError(groupId: string, error: any): void;
+    /**
+     * Set the row grand total for table mode
+     */
+    setRowGrandTotal(grandTotal: RowGrandTotal | null): void;
+    /**
+     * Get the row grand total for table mode
+     */
+    getRowGrandTotal(): RowGrandTotal | null;
+    /**
+     * Set the dynamic data request
+     */
+    setDynamicDataRequest(request: string): void;
+    /**
+     * Get the dynamic data request
+     */
+    getDynamicDataRequest(): string[] | null;
+    removeDynamicDataRequest(key: string): void;
+    /**
+     * Set the dynamic data
+     */
+    setDynamicData(key: string, data: any): void;
+    /**
+     * Get the dynamic data for a specific API key
+     */
+    getDynamicData(key: string): any | null;
+    removeDynamicData(key: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EruGridStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EruGridStore>;
+}
+
+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>;
+    /**
+     * Get default field_size for a column following fallback hierarchy
+     * Priority: column.field_size > datatype config minWidth > global config minWidth > datatype default minWidth > 150
+     */
+    getDefaultFieldSize(column: Field | undefined, gridConfig?: GridConfiguration): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnConstraintsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ColumnConstraintsService>;
+}
+
+declare class EruGridService {
+    private eruGridStore;
+    private themeService;
+    private columnConstraintsService;
+    constructor(eruGridStore: EruGridStore, themeService: ThemeService, columnConstraintsService: ColumnConstraintsService);
+    set_table_configuration(data: GridConfiguration): 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;
+    /**
+     * 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.PivotRow[] | eru_grid.Row[]>;
+    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(): EruGridStore;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EruGridService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<EruGridService>;
+}
+
+/**
+ * Custom virtual scroll strategy optimized for catching every scroll event
+ * Uses smaller buffer sizes (minBufferPx: 50, maxBufferPx: 150) to ensure
+ * more frequent scroll detection, especially important when you have 4 grids
+ * and need to catch every scroll event.
+ *
+ * The itemSize is set dynamically via the viewport's [itemSize] input binding
+ * which uses averageGroupHeight(). The strategy's itemSize parameter here is
+ * just a fallback default.
+ */
+declare class CustomVirtualScrollStrategy extends FixedSizeVirtualScrollStrategy {
+    constructor();
+}
+declare class EruGridComponent implements OnInit, AfterViewInit, OnDestroy {
+    private changeDetectorRef;
+    gridService: EruGridService;
+    gridStore: EruGridStore;
+    private elementRef;
+    private resizeObserver;
+    isColumnReordering: _angular_core.WritableSignal<boolean>;
+    firstTr: number | null;
+    allViewports?: QueryList<CdkVirtualScrollViewport>;
+    rowContainer?: ElementRef;
+    headerScroller: ElementRef<HTMLDivElement>;
+    headerScrollers?: QueryList<ElementRef<HTMLDivElement>>;
+    gtScroller: ElementRef<HTMLDivElement>;
+    gridConfig: GridConfiguration | undefined;
+    initialMinHeight: number;
+    initialTotalWidth: number;
+    viewport: CdkVirtualScrollViewport;
+    groupsViewport: CdkVirtualScrollViewport;
+    previousOffset: _angular_core.WritableSignal<number>;
+    groups: _angular_core.Signal<RowGroup[]>;
+    ghostRows: _angular_core.WritableSignal<number>;
+    groupedRows: _angular_core.Signal<GroupItem[]>;
+    columns: _angular_core.Signal<Field[]>;
+    selectedRowIds: _angular_core.Signal<Set<string>>;
+    totalRowCount: _angular_core.Signal<number>;
+    averageGroupHeight: _angular_core.Signal<number>;
+    currentPivotScrollIndex: _angular_core.WritableSignal<number>;
+    firstDataRowIndex: _angular_core.WritableSignal<number>;
+    private ngZone;
+    groupContentHeightsMap: _angular_core.Signal<Map<string, number>>;
+    private _virtualRowspanCache;
+    mode: _angular_core.Signal<eru_grid.GridMode>;
+    isResizable: _angular_core.Signal<boolean>;
+    isEditable: _angular_core.Signal<boolean>;
+    gridHeight: _angular_core.Signal<number>;
+    showColumnLines: _angular_core.Signal<boolean>;
+    showRowLines: _angular_core.Signal<boolean>;
+    maxDepth: _angular_core.Signal<number>;
+    subTotalStyle: _angular_core.Signal<"bold" | "italic" | "highlighted">;
+    grandTotalStyle: _angular_core.Signal<"bold" | "italic" | "highlighted">;
+    freezeHeader: _angular_core.Signal<boolean>;
+    freezeGrandTotal: _angular_core.Signal<boolean>;
+    grandTotalPosition: _angular_core.Signal<"before" | "after">;
+    grandTotalPositionColumn: _angular_core.Signal<"before" | "after">;
+    enableColumnGrandTotal: _angular_core.Signal<boolean>;
+    enableColumnSubtotals: _angular_core.Signal<boolean>;
+    subtotalPositionColumn: _angular_core.Signal<"before" | "after">;
+    subtotalLabel: _angular_core.Signal<string>;
+    /**
+     * Check if a group has subtotal data
+     * @param group The group to check
+     * @returns true if the group has subtotal data
+     */
+    hasSubtotalData(group: RowGroup): boolean;
+    /**
+     * Get subtotal value for a column in a group
+     * @param group The group containing the subtotal
+     * @param columnName The column name to get the subtotal for
+     * @returns The subtotal value or null if not available
+     */
+    getSubtotalValue(group: RowGroup, columnName: string): number | null;
+    /**
+     * Check if grand total data is available (computed signal for reactivity)
+     */
+    hasGrandTotalData: _angular_core.Signal<boolean>;
+    /**
+     * Get grand total value for a column
+     * @param columnName The column name to get the grand total for
+     * @returns The grand total value or null if not available
+     */
+    getGrandTotalValue(columnName: string): number | null;
+    /**
+     * 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;
+    /**
+     * Handle scroll events for pivot mode
+     * @param scrollIndex The current scroll index
+     */
+    onPivotScroll(scrollIndex: number): void;
+    getTotalTableWidth(): number;
+    getMinHeightPx(): number;
+    adjustScrollWidth(): boolean;
+    /**
+     * Get the rendered range (what's in the DOM including buffer)
+     * @returns Object with start, end, and count of rendered items
+     */
+    private readonly ROWS_PER_PAGE;
+    private readonly SCROLL_THRESHOLD;
+    private lastLoadedGroupIds;
+    private requestedGroupIds;
+    private columnsInitialized;
+    /**
+     * Get content height for a specific group from the computed signal
+     * This is efficient as it uses the cached computed signal instead of recalculating
+     */
+    getGroupContentHeight(groupId: string): number;
+    /**
+     * Calculate total height of a group including header and content
+     * This is used for the outer groups virtual scroll viewport
+     */
+    protected getTotalGroupHeight(group: RowGroup): number;
+    /**
+     * Calculate average group height for the outer virtual scroll viewport itemSize
+     * Uses getMinHeightPx() to ensure proper height calculation
+     */
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    applyTokens(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    set_table_group(data: RowGroup[]): void;
+    getInitialMinHeightPx(): number;
+    getInitialTotalWidth(): number;
+    applyCdkWidth(): boolean;
+    private createGroupedRows;
+    initializeGroups(): void;
+    private fetchInitialRows;
+    /**
+     * Fetch data for currently visible groups that haven't been requested yet
+     * This is called on initial load and when groups become visible during scrolling
+     */
+    private fetchDataForVisibleGroups;
+    private updateViewportSize;
+    addRowsForGroup(groupId: string, rows: Row[], hasMore: boolean): void;
+    onScroll(scrollIndex: number, group: RowGroup): void;
+    /**
+     * Get viewport by group ID using the data-group-id attribute
+     */
+    private getViewportByGroupId;
+    protected getVisibleGroups(): RowGroup[];
+    private getGroupItemAtIndex;
+    private checkAndLoadMoreRows;
+    private intelligentGroupLoading;
+    /**
+     * Request rows for a specific group via signal
+     */
+    private requestRowsForGroup;
+    shouldShowRequiredToggleRow(): boolean;
+    onColumnRequiredChange(columnName: string, required: boolean): void;
+    trackByColumnFn(index: number, column: Field): string;
+    trackByGroupItemFn(index: number, groupItem: GroupItem): string;
+    trackByPivotRowFn(index: number, pivotRow: PivotRow): string;
+    trackByRowFn(index: number, row: any): string;
+    trackByGroupFn(index: number, group: RowGroup): string;
+    getRowsForGroup(groupId: string): Row[];
+    getRowsForGroupSignal(groupId: string): _angular_core.Signal<Row[]>;
+    trackByHeaderFn(index: number, header: any): string;
+    hasNestedHeaders(): boolean;
+    getHeaderRows(): any[][];
+    getLeafColumns(): Field[];
+    isRowDimensionHeader(header: any): boolean;
+    /**
+     * Get the Field corresponding to a PivotColumnHeader
+     * For nested headers, finds the first matching leaf column
+     */
+    getFieldForPivotHeader(header: any): Field | undefined;
+    getPivotGridColumns(): string;
+    private initializeColumnWidths;
+    toggleRowSelection(event: Event, row: any): void;
+    toggleGroupSelection(event: Event, groupId: string): void;
+    onActionClick(event: Event, row: any): void;
+    /**
+     * Check if action column is enabled
+     * @returns true if actionColumn is enabled, false otherwise (default: false)
+     */
+    isActionColumnEnabled: _angular_core.Signal<boolean>;
+    /**
+     * Get action column position
+     * @returns 'before' | 'after' (default: 'after')
+     */
+    getActionColumnPosition: _angular_core.Signal<"before" | "after">;
+    /**
+     * Check if action column should be shown at a specific position
+     * @param position The position to check ('before' | 'after')
+     * @returns true if action column is enabled and matches the position
+     */
+    shouldShowActionColumn(position: 'before' | 'after'): boolean;
+    toggleAllGroups(event: Event): void;
+    isRowSelected(rowId?: string): boolean;
+    isGroupSelected(groupId: string): boolean;
+    isAllGroupsSelected(): boolean;
+    getSelectedRows(): any[];
+    toggleGroupExpansion(groupId: string): void;
+    /**
+     * 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;
+    }>;
+    /**
+     * 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;
+    /**
+     * 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
+     */
+    /**
+     * Get columns that should be frozen on the left (all row dimensions up to and including freezeField)
+     */
+    /**
+     * Get columns that should be scrollable on the right (all except frozen fields)
+     */
+    /**
+     * Get headers that should be frozen (all row dimension headers up to and including freezeField)
+     */
+    /**
+     * Get headers that should be scrollable (all except frozen fields)
+     */
+    /**
+     * 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;
+    /**
+     * Handle body scroll to synchronize header and grand total horizontal scroll
+     */
+    /**
+     * Handle scroll events on the groups viewport
+     * This detects when new groups become visible and fetches their data
+     * Can be called with either Event (from scroll event) or number (from scrolledIndexChange)
+     */
+    onGroupsViewportScroll(event: Event | number): void;
+    private groupsScrollTimeout;
+    onTableBodyScroll(event: Event): void;
+    onBodyScroll(event: Event): void;
+    /**
+     * Handle header scroll to synchronize body horizontal scroll
+     */
+    onHeaderScroll(event: Event): void;
+    toggleGroupCollapse(groupId: string): void;
+    /**
+     * Manually trigger scrollbar compensation recalculation (for testing)
+     */
+    recalculateScrollbarCompensation(): void;
+    /**
+     * Adjust header padding to compensate for body table scrollbar width
+     * This ensures perfect column alignment between header and body tables
+     */
+    private adjustHeaderScrollbarCompensation;
+    groupSeperatorColSpan(): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EruGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EruGridComponent, "eru-grid", never, { "gridConfig": { "alias": "gridConfig"; "required": false; }; }, {}, 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>;
+}
+
+declare class HelloWorldComponent {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelloWorldComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelloWorldComponent, "eru-hello-world", never, {}, {}, never, never, true, never>;
+}
+
+interface CurrencyValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+declare class CurrencyComponent {
+    private el;
+    value: _angular_core.InputSignal<string | number | null>;
+    config: _angular_core.InputSignal<Field | null>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    replaceZeroValue: _angular_core.InputSignal<string | undefined>;
+    placeholder: _angular_core.InputSignal<string>;
+    valueChange: EventEmitter<string | number | null>;
+    blur: EventEmitter<string | number | null>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<string | number | null>;
+    validationError: EventEmitter<string>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<string | number | null>;
+    error: _angular_core.WritableSignal<string>;
+    constructor();
+    formatNumberSignal: _angular_core.Signal<string | undefined>;
+    onActivate(): void;
+    onBlur(): void;
+    onValueChange(event: any): void;
+    onDrillableClick(event: Event): void;
+    private validateField;
+    private focusAndPositionCursor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CurrencyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CurrencyComponent, "eru-currency", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "replaceZeroValue": { "alias": "replaceZeroValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "validationError": "validationError"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+interface NumberValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+declare class NumberComponent {
+    private el;
+    value: _angular_core.InputSignal<string | number | null>;
+    config: _angular_core.InputSignal<Field | null>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    replaceZeroValue: _angular_core.InputSignal<string | undefined>;
+    placeholder: _angular_core.InputSignal<string>;
+    valueChange: EventEmitter<string | number | null>;
+    blur: EventEmitter<string | number | null>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<string | number | null>;
+    validationError: EventEmitter<string>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<string | number | null>;
+    error: _angular_core.WritableSignal<string>;
+    constructor();
+    formatNumberSignal: _angular_core.Signal<string | undefined>;
+    onActivate(): void;
+    onBlur(): void;
+    onValueChange(event: any): void;
+    onDrillableClick(event: Event): void;
+    private validateField;
+    private focusAndPositionCursor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberComponent, "eru-number", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "replaceZeroValue": { "alias": "replaceZeroValue"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "validationError": "validationError"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+interface TextboxValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+declare class TextboxComponent implements OnInit {
+    private el;
+    value: _angular_core.InputSignal<string | null>;
+    config: _angular_core.InputSignal<Field | null>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    columnWidth: _angular_core.InputSignal<number>;
+    fieldSize: _angular_core.InputSignal<number>;
+    eruGridStore: _angular_core.InputSignal<EruGridStore | null>;
+    externalError: _angular_core.InputSignal<string>;
+    valueChange: EventEmitter<string | null>;
+    blur: EventEmitter<string | null>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<string | null>;
+    validationError: EventEmitter<string>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<string | null>;
+    internalError: _angular_core.WritableSignal<string>;
+    error: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    getProperty(property: string): any;
+    hasRequiredValidation(): boolean;
+    onActivate(): void;
+    onBlur(event: FocusEvent): void;
+    onValueChange(event: any): void;
+    onDrillableClick(event: Event): void;
+    private validateField;
+    private focusAndPositionCursor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextboxComponent, "eru-textbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "fieldSize": { "alias": "fieldSize"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; "externalError": { "alias": "externalError"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "validationError": "validationError"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+interface EmailValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+declare class EmailComponent implements OnInit {
+    private el;
+    value: _angular_core.InputSignal<string | null>;
+    config: _angular_core.InputSignal<Field | null>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    columnWidth: _angular_core.InputSignal<number>;
+    fieldSize: _angular_core.InputSignal<number>;
+    eruGridStore: _angular_core.InputSignal<EruGridStore | null>;
+    placeholder: _angular_core.InputSignal<string>;
+    externalError: _angular_core.InputSignal<string>;
+    valueChange: EventEmitter<string | null>;
+    blur: EventEmitter<string | null>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<string | null>;
+    validationError: EventEmitter<string>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<string | null>;
+    internalError: _angular_core.WritableSignal<string>;
+    error: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    getProperty(property: string): any;
+    hasRequiredValidation(): boolean;
+    onActivate(): void;
+    onBlur(event: FocusEvent): void;
+    onValueChange(event: any): void;
+    onDrillableClick(event: Event): void;
+    private validateField;
+    private focusAndPositionCursor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmailComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmailComponent, "eru-email", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "fieldSize": { "alias": "fieldSize"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "externalError": { "alias": "externalError"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "validationError": "validationError"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+declare global {
+    interface Window {
+        google: typeof google;
+    }
+}
+declare var google: {
+    maps: {
+        places: {
+            Autocomplete: new (input: HTMLInputElement, options?: any) => {
+                getPlace: () => any;
+                addListener: (event: string, callback: () => void) => void;
+            };
+            AutocompleteOptions: any;
+        };
+    };
+};
+interface LocationConfig {
+    required?: boolean;
+    maxLength?: number;
+    googleApiKey?: string;
+    enableAutocomplete?: boolean;
+}
+interface LocationValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+declare class LocationComponent implements OnInit, AfterViewInit {
+    private el;
+    locationInput?: ElementRef<HTMLInputElement>;
+    value: _angular_core.InputSignal<string | null>;
+    config: _angular_core.InputSignal<Field | null>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    columnWidth: _angular_core.InputSignal<number>;
+    fieldSize: _angular_core.InputSignal<number>;
+    eruGridStore: _angular_core.InputSignal<EruGridStore | null>;
+    externalError: _angular_core.InputSignal<string>;
+    valueChange: EventEmitter<string | null>;
+    blur: EventEmitter<string | null>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<string | null>;
+    validationError: EventEmitter<string>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<string | null>;
+    internalError: _angular_core.WritableSignal<string>;
+    autocomplete: any;
+    error: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    getProperty(property: string): any;
+    hasRequiredValidation(): boolean;
+    shouldEnableAutocomplete(): boolean;
+    private initializeAutocomplete;
+    private loadGoogleMapsScript;
+    private setupAutocomplete;
+    onActivate(): void;
+    onBlur(event: FocusEvent): void;
+    onValueChange(event: any): void;
+    onDrillableClick(event: Event): void;
+    private validateField;
+    private focusAndPositionCursor;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LocationComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LocationComponent, "eru-location", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "fieldSize": { "alias": "fieldSize"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; "externalError": { "alias": "externalError"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "validationError": "validationError"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+declare class CheckboxComponent {
+    value: _angular_core.InputSignal<boolean>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    label: _angular_core.InputSignal<string>;
+    valueChange: EventEmitter<boolean>;
+    change: EventEmitter<boolean>;
+    blur: EventEmitter<boolean>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<boolean>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<boolean>;
+    constructor();
+    onValueChange(event: boolean): void;
+    onActivate(): void;
+    onBlur(): void;
+    onDrillableClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "eru-checkbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "change": "change"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+declare class DateComponent {
+    private el;
+    datepicker: MatDatepicker<Date>;
+    value: _angular_core.InputSignal<string | Date | null>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    placeholder: _angular_core.InputSignal<string>;
+    valueChange: EventEmitter<string | null>;
+    dateChange: EventEmitter<string | null>;
+    drilldownClick: EventEmitter<string | null>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<Date | null>;
+    private shouldOpenPicker;
+    constructor();
+    onActivate(): void;
+    onDateChange(date: Date | null): void;
+    onDrillableClick(event: Event): void;
+    formatDate(date: Date | null): string;
+    parseDateString(dateString: string): Date | null;
+    getDisplayValue(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DateComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DateComponent, "eru-date", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "dateChange": "dateChange"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+interface CountryCode {
+    name: string;
+    code: string;
+    dial_code: string;
+    flag: string;
+}
+
+declare class PhoneComponent implements OnInit, AfterViewInit {
+    private el;
+    phoneContainer: ElementRef<HTMLElement>;
+    value: _angular_core.InputSignal<string | null>;
+    defaultCountry: _angular_core.InputSignal<string>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    columnWidth: _angular_core.InputSignal<number>;
+    fieldSize: _angular_core.InputSignal<number>;
+    valueChange: EventEmitter<string | null>;
+    blur: EventEmitter<string | null>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<string | null>;
+    editModeChange: EventEmitter<boolean>;
+    countryCodes: _angular_core.WritableSignal<CountryCode[]>;
+    selectedCountry: _angular_core.WritableSignal<CountryCode>;
+    countrySearchText: _angular_core.WritableSignal<string>;
+    phoneNumber: _angular_core.WritableSignal<string>;
+    currentValue: _angular_core.WritableSignal<string | null>;
+    isInputFocused: _angular_core.WritableSignal<boolean>;
+    isDropdownOpen: _angular_core.WritableSignal<boolean>;
+    filteredCountries: _angular_core.Signal<CountryCode[]>;
+    isFocused: _angular_core.Signal<boolean>;
+    readonly fullPhoneValue: _angular_core.Signal<string>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    onActivate(): void;
+    onInputFocus(event: FocusEvent): void;
+    onInputBlur(event: FocusEvent): void;
+    onDrillableClick(event: Event): void;
+    /**
+     * Get the flag emoji for display
+     * @returns The flag emoji string
+     */
+    getDisplayFlag(): string;
+    /**
+     * Get the dial code and phone number together (without flag)
+     * @returns The dial code and phone number formatted as "dialCode phoneNumber"
+     */
+    getDisplayPhoneNumber(): string;
+    /**
+     * Format the complete display value (flag + dial code + number)
+     * @returns The complete formatted phone number with flag
+     */
+    formatDisplayValue(): string;
+    selectCountry(countryCode: string): void;
+    onCountryChange(countryCode: string): void;
+    onCountrySelectOpenedChange(opened: boolean): void;
+    onCountrySearchChange(searchValue: string): void;
+    displayFlag(country?: CountryCode): string;
+    onPhoneNumberInput(event: Event): void;
+    private emitValueChange;
+    private focusAndPositionCursor;
+    private parseAndSetValue;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneComponent, "eru-phone", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultCountry": { "alias": "defaultCountry"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "fieldSize": { "alias": "fieldSize"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+declare class ProgressComponent implements OnInit {
+    private el;
+    value: _angular_core.InputSignal<number | null>;
+    config: _angular_core.InputSignal<Field | null>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    isDrillable: _angular_core.InputSignal<boolean>;
+    columnWidth: _angular_core.InputSignal<number>;
+    fieldSize: _angular_core.InputSignal<number>;
+    eruGridStore: _angular_core.InputSignal<EruGridStore | null>;
+    valueChange: EventEmitter<number>;
+    blur: EventEmitter<number | null>;
+    focus: EventEmitter<void>;
+    drilldownClick: EventEmitter<number | null>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<number>;
+    displayValue: _angular_core.Signal<number>;
+    constructor();
+    ngOnInit(): void;
+    onActivate(): void;
+    onBlur(): void;
+    onValueChange(value: number): void;
+    onDrillableClick(event: Event): void;
+    getProperty(property: string): any;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressComponent, "eru-progress", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; "isDrillable": { "alias": "isDrillable"; "required": false; "isSignal": true; }; "columnWidth": { "alias": "columnWidth"; "required": false; "isSignal": true; }; "fieldSize": { "alias": "fieldSize"; "required": false; "isSignal": true; }; "eruGridStore": { "alias": "eruGridStore"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "blur": "blur"; "focus": "focus"; "drilldownClick": "drilldownClick"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+interface RatingConfig {
+    startValue?: number;
+    endValue?: number;
+    emojiValue?: 'star' | 'smile' | 'heart';
+}
+declare class RatingComponent {
+    value: _angular_core.InputSignal<number>;
+    config: _angular_core.InputSignal<RatingConfig>;
+    isEditable: _angular_core.InputSignal<boolean>;
+    isActive: _angular_core.InputSignal<boolean>;
+    valueChange: EventEmitter<number>;
+    editModeChange: EventEmitter<boolean>;
+    currentValue: _angular_core.WritableSignal<number>;
+    hoverRating: _angular_core.WritableSignal<number>;
+    constructor();
+    getRatingStars: _angular_core.Signal<number[]>;
+    getEmoji(star: number): string;
+    onActivate(): void;
+    setRating(value: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RatingComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RatingComponent, "eru-rating", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "config": { "alias": "config"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "isActive": { "alias": "isActive"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "editModeChange": "editModeChange"; }, never, never, true, never>;
+}
+
+declare const MATERIAL_PROVIDERS: Provider[];
+declare const MATERIAL_MODULES: (typeof MatCommonModule)[];
+
+export { CheckboxComponent, ColumnConstraintsService, CurrencyComponent, CustomVirtualScrollStrategy, DateComponent, EmailComponent, EruGridComponent, EruGridService, EruGridStore, HelloWorldComponent, LocationComponent, MATERIAL_MODULES, MATERIAL_PROVIDERS, NumberComponent, PhoneComponent, ProgressComponent, RatingComponent, TextboxComponent, ThemeService, ThemeToggleComponent };
+export type { ActionClick, AggregationFunction, ColumnWidthConstraints, CurrencyValidationResult, DataTypes, Drilldown, EmailValidationResult, Field, GridConfiguration, GridFeatures, GridMode, GridStyles, GridTokens, GroupItem$1 as GroupItem, LocationConfig, LocationValidationResult, NumberValidationResult, PivotColumnGroupState, PivotColumnHeader, PivotConfiguration, PivotHeaderStructure, PivotMetadata, PivotResult, PivotRow, RatingConfig, Row, RowDataRequest, RowDataResponse, RowGrandTotal, RowGroup, TextboxValidationResult, Theme };