@zengrid/angular 1.2.0 → 1.2.1

package/types/zengrid-angular.d.ts

@@ -0,0 +1,654 @@
+import * as _zengrid_core_styles_types_js from '@zengrid/core/styles/types.js';
+import * as _zengrid_core_styles_features_filtering_index_js from '@zengrid/core/styles/features/filtering/index.js';
+import * as _zengrid_core_styles_features_filtering_types_js from '@zengrid/core/styles/features/filtering/types.js';
+import * as _zengrid_core from '@zengrid/core';
+import { ColumnDef, PaginationConfig, LoadingConfig, RowHeightConfig, CellOverflowConfig, SortIcons, RendererCacheConfig, CellRange, GridPlugin, SortState, FilterModel, CellRef, Grid, GridExportOptions, ColumnConstraints, ColumnStateSnapshot, GridStateSnapshot, VisibleRange, HeaderRenderer, GridOptions, PluginHost, GridApiImpl, CellRenderer, CellEditor, GridStore, GridApiInterface, PluginDisposable } from '@zengrid/core';
+export { ARIAManager, ARIAManagerOptions, AdvancedCellRenderer, AdvancedCellRendererOptions, AggregateOperation, AggregationResult, AsyncComputedOptions, AsyncFilterPluginOptions, AsyncSortPluginOptions, AsyncState, AutoFitCalculator, AutoFitCalculatorOptions, AutoScrollOptions, ButtonRenderer, ButtonRendererOptions, CSVExporter, CellEditor, CellPosition, CellRange, CellRef, CellRenderer, CheckboxEditor, CheckboxEditorOptions, CheckboxHeaderRenderer, CheckboxRenderer, CheckboxRendererOptions, Chip, ChipRenderer, ChipRendererOptions, ClipboardManager, ColumnApi, ColumnBatchUpdate, ColumnConstraints, ColumnDef, ColumnDefinition, ColumnDragCommand, ColumnDragEvents, ColumnDragManager, ColumnDragOptions, ColumnEvent, ColumnEventType, ColumnGroup, ColumnGroupManager, ColumnGroupModel, ColumnGroupModelConfig, ColumnGroupRenderParams, ColumnGroupRenderer, ColumnGroupRendererOptions, ColumnModel, ColumnPinPlugin, ColumnPinPosition, ColumnReorderPlugin, ColumnResizeManager, ColumnResizeOptions, ColumnState, ColumnStateSnapshot, ColumnStore, ColumnStoreOptions, ColumnType, ColumnVisibilityPlugin, CompositeElement, ConditionalStyle, GridStore as CoreGridStore, CorePluginOptions, DataAccessor, DateEditor, DateEditorOptions, DatePickerRenderer, DatePickerRendererOptions, DateRangeEditor, DateRangeEditorOptions, DateRangeRenderer, DateRangeRendererOptions, DateRenderer, DateRendererOptions, DateTimeEditor, DateTimeEditorOptions, DateTimePickerRenderer, DateTimePickerRendererOptions, DateTimeRenderer, DateTimeRendererOptions, DatetimeTheme, DependencyGraph, DevToolsConnectorOptions, DragEvent, DragKeyboardHandler, DragState, DragStateSnapshot, DragTouchHandler, DragVisualFeedback, DropPosition, DropZoneResult, DropdownEditor, DropdownEditorOptions, DropdownOption, DropdownRenderer, DropdownRendererOptions, EditingPluginOptions, EditorManager, EditorManagerOptions, EditorParams, EventEmitter, ExportApi, FilterApi, FilterModel, FilterPluginOptions, FilterableHeaderRenderer, FocusManager, FocusManagerOptions, GridApiImpl, GridApiInterface, GridEvents, GridExportOptions, GridOptions, GridPlugin, GridState, GridStateSnapshot, GridStore, HeaderRenderParams, HeaderRenderer, IconHeaderRenderer, ImageRenderer, ImageRendererOptions, IndexMap, IndexMapOptions, KeyboardNavigator, KeyboardNavigatorOptions, LifecyclePluginOptions, LinkRenderer, LinkRendererOptions, MultiColumnSorter, NullPosition, NumberRenderer, NumberRendererOptions, PaginationApi, PartialTheme, PipelineRegistry, PluginHost, ProgressBarRenderer, ProgressBarRendererOptions, ReadonlySparseMatrix, RenderParams, RendererRegistry, ResizeHandleRenderer, ResizePreview, ResizeState, ResizeZoneResult, ResolvedHeaderConfig, SavedFilterPreset, ScrollApi, ScrollEvent, ScrollEventType, ScrollModel, ScrollState, SelectOption, SelectRenderer, SelectRendererOptions, SelectionPluginOptions, SingleColumnSorter, SortApi, SortOptions, SortPluginOptions, SortState, SortStateManager, SortableHeaderRenderer, SparseMatrix, SparseMatrixOptions, StateApi, StoreKeys, TextEditor, TextEditorOptions, TextHeaderRenderer, TextRenderer, ThemeBorders, ThemeBuilder, ThemeColors, ThemeShadows, ThemeSpacing, ThemeTransitions, ThemeTypography, TimeEditor, TimeEditorOptions, TimePickerRenderer, TimePickerRendererOptions, TimeRenderer, TimeRendererOptions, UndoRedoPluginOptions, ViewportEvent, ViewportEventType, ViewportModel, ViewportState, WrappedComputed, WrappedSignal, ZenGridTheme, alpha, applyTheme, containsCell, createAsyncFilterPlugin, createAsyncSortPlugin, createColumnGroupRenderer, createCorePlugin, createDatePickerRenderer, createDateTimePickerRenderer, createDateTimeRenderer, createDevToolsConnector, createEditingPlugin, createFilterPlugin, createHitTester, createIdentityIndexMap, createIndexMap, createLifecyclePlugin, createSelectionPlugin, createSortPlugin, createTheme, createTimePickerRenderer, createTimeRenderer, createUndoRedoPlugin, darkTheme, darken, draculaTheme, formatDate, formatDateForDisplay, formatDateRange, formatDateTime, formatTime, getAllThemes, getTheme, githubTheme, hasTheme, isDateInRange, isValidDate, lightTheme, lighten, listThemes, materialTheme, mergeRanges, nordTheme, normalizeRange, oneDarkTheme, parseDate, parseDateTime, parseTime, rangesIntersect, registerTheme, removeTheme, setDatetimeTheme, setDatetimeThemeConfig, solarizedTheme, themeToCSSVariables, unregisterTheme } from '@zengrid/core';
+import * as _angular_core from '@angular/core';
+import { OutputEmitterRef, TemplateRef, Type, EmbeddedViewRef, ComponentRef, InjectionToken, Provider, Injector, Signal } from '@angular/core';
+import { OperationMode } from '@zengrid/shared';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class ZenGridComponent {
+    private readonly platformId;
+    private readonly cdr;
+    private readonly ngZone;
+    private readonly destroyRef;
+    private readonly templateBridge;
+    private readonly globalConfig;
+    readonly _isBrowser: boolean;
+    get placeholderHeight(): number;
+    private readonly gridContainerRef;
+    private readonly columnChildren;
+    private grid;
+    private gridReady;
+    private warnedOnLegacyBackendCallbacks;
+    private readonly explicitInputs;
+    private pendingModelDataSync;
+    private static readonly legacyBackendCallbackWarning;
+    readonly rowCount: _angular_core.InputSignal<number>;
+    readonly colCount: _angular_core.InputSignal<number>;
+    readonly rowHeight: _angular_core.InputSignalWithTransform<number | number[], number | number[]>;
+    readonly colWidth: _angular_core.InputSignalWithTransform<number | number[], number | number[]>;
+    readonly columns: _angular_core.InputSignalWithTransform<ColumnDef[], ColumnDef[]>;
+    readonly enableSelection: _angular_core.InputSignal<boolean>;
+    readonly enableMultiSelection: _angular_core.InputSignal<boolean>;
+    readonly selectionType: _angular_core.InputSignal<"cell" | "row" | "column" | "range">;
+    readonly enableColumnResize: _angular_core.InputSignal<boolean>;
+    readonly enableColumnDrag: _angular_core.InputSignal<boolean>;
+    readonly enableKeyboardNavigation: _angular_core.InputSignal<boolean>;
+    readonly enableA11y: _angular_core.InputSignal<boolean>;
+    readonly enableCellPooling: _angular_core.InputSignal<boolean>;
+    readonly dataMode: _angular_core.InputSignal<OperationMode>;
+    readonly sortMode: _angular_core.InputSignal<OperationMode>;
+    readonly filterMode: _angular_core.InputSignal<OperationMode>;
+    readonly onDataRequest: _angular_core.InputSignal<(request: _zengrid_core.DataLoadRequest) => Promise<_zengrid_core.DataLoadResponse>>;
+    readonly onSortRequest: _angular_core.InputSignal<(request: unknown) => Promise<unknown>>;
+    readonly onFilterRequest: _angular_core.InputSignal<(request: unknown) => Promise<unknown>>;
+    readonly onLoadMoreRows: _angular_core.InputSignal<(currentRowCount: number) => Promise<any[][]>>;
+    readonly pagination: _angular_core.InputSignal<PaginationConfig>;
+    readonly loading: _angular_core.InputSignal<LoadingConfig>;
+    readonly infiniteScrolling: _angular_core.InputSignal<{
+        enabled?: boolean;
+        threshold?: number;
+        initialRowCount?: number;
+        enableSlidingWindow?: boolean;
+        windowSize?: number;
+        pruneThreshold?: number;
+        onDataPruned?: (prunedRowCount: number, newVirtualOffset: number) => void;
+    }>;
+    readonly rowHeightMode: _angular_core.InputSignal<"auto" | "fixed" | "content-aware">;
+    readonly rowHeightConfig: _angular_core.InputSignal<RowHeightConfig>;
+    readonly columnResize: _angular_core.InputSignal<{
+        resizeZoneWidth?: number;
+        defaultMinWidth?: number;
+        defaultMaxWidth?: number;
+        autoFitSampleSize?: number;
+        autoFitPadding?: number;
+        skipHeaderOnAutoSize?: boolean;
+        showHandles?: boolean;
+        showPreview?: boolean;
+        autoFitOnLoad?: boolean;
+    }>;
+    readonly columnDrag: _angular_core.InputSignal<{
+        dragThreshold?: number;
+        showGhost?: boolean;
+        showDropIndicator?: boolean;
+        showAdjacentHighlights?: boolean;
+        enableTouch?: boolean;
+        touchLongPressDuration?: number;
+        enableKeyboard?: boolean;
+    }>;
+    readonly cellOverflow: _angular_core.InputSignal<CellOverflowConfig>;
+    readonly autoResize: _angular_core.InputSignal<boolean>;
+    readonly overscanRows: _angular_core.InputSignal<number>;
+    readonly overscanCols: _angular_core.InputSignal<number>;
+    readonly sortIcons: _angular_core.InputSignal<SortIcons>;
+    readonly rendererCache: _angular_core.InputSignal<RendererCacheConfig>;
+    readonly onScrollCallback: _angular_core.InputSignal<(scrollTop: number, scrollLeft: number) => void>;
+    readonly onCellClickCallback: _angular_core.InputSignal<(row: number, col: number) => void>;
+    readonly onCellDoubleClickCallback: _angular_core.InputSignal<(row: number, col: number) => void>;
+    readonly onCellContextMenuCallback: _angular_core.InputSignal<(row: number, col: number, event: MouseEvent) => void>;
+    readonly onSelectionChangeCallback: _angular_core.InputSignal<(selection: CellRange[]) => void>;
+    readonly onPageChangeCallback: _angular_core.InputSignal<(page: number, pageSize: number) => void>;
+    readonly onColumnWidthsChangeCallback: _angular_core.InputSignal<(widths: number[]) => void>;
+    readonly plugins: _angular_core.InputSignal<GridPlugin[]>;
+    readonly data: _angular_core.ModelSignal<any[][]>;
+    readonly selection: _angular_core.ModelSignal<CellRange[]>;
+    readonly sortState: _angular_core.ModelSignal<SortState[]>;
+    readonly filterState: _angular_core.ModelSignal<FilterModel[]>;
+    readonly currentPage: _angular_core.ModelSignal<number>;
+    readonly cellClick: OutputEmitterRef<{
+        cell: CellRef;
+        value: any;
+        nativeEvent: MouseEvent;
+    }>;
+    readonly cellDoubleClick: OutputEmitterRef<{
+        cell: CellRef;
+        value: any;
+        nativeEvent: MouseEvent;
+    }>;
+    readonly cellContextMenu: OutputEmitterRef<{
+        cell: CellRef;
+        value: any;
+        nativeEvent: MouseEvent;
+    }>;
+    readonly cellChange: OutputEmitterRef<{
+        cell: CellRef;
+        oldValue: any;
+        newValue: any;
+    }>;
+    readonly cellBeforeChange: OutputEmitterRef<{
+        cell: CellRef;
+        oldValue: any;
+        newValue: any;
+        cancel: () => void;
+    }>;
+    readonly cellAfterChange: OutputEmitterRef<{
+        cell: CellRef;
+        oldValue: any;
+        newValue: any;
+    }>;
+    readonly selectionChangeEvent: OutputEmitterRef<{
+        ranges: CellRange[];
+        previousRanges: CellRange[];
+        isSelected?: (row: number, col: number) => boolean;
+    }>;
+    readonly selectionStart: OutputEmitterRef<{
+        startCell: CellRef;
+    }>;
+    readonly selectionEnd: OutputEmitterRef<{
+        ranges: CellRange[];
+    }>;
+    readonly editStart: OutputEmitterRef<{
+        cell: CellRef;
+        value: any;
+    }>;
+    readonly editEnd: OutputEmitterRef<{
+        cell: CellRef;
+        value: any;
+        cancelled: boolean;
+    }>;
+    readonly editCommit: OutputEmitterRef<{
+        cell: CellRef;
+        oldValue: any;
+        newValue: any;
+    }>;
+    readonly editCancel: OutputEmitterRef<{
+        cell: CellRef;
+        value: any;
+    }>;
+    readonly scroll: OutputEmitterRef<{
+        scrollTop: number;
+        scrollLeft: number;
+        visibleRange: {
+            startRow: number;
+            endRow: number;
+            startCol: number;
+            endCol: number;
+        };
+    }>;
+    readonly scrollStart: OutputEmitterRef<{
+        scrollTop: number;
+        scrollLeft: number;
+    }>;
+    readonly scrollEnd: OutputEmitterRef<{
+        scrollTop: number;
+        scrollLeft: number;
+    }>;
+    readonly sortChange: OutputEmitterRef<{
+        sortState: SortState[];
+        previousSortState: SortState[];
+    }>;
+    readonly sortBeforeSort: OutputEmitterRef<{
+        sortState: SortState[];
+        cancel: () => void;
+    }>;
+    readonly sortAfterSort: OutputEmitterRef<{
+        sortState: SortState[];
+        rowsAffected: number;
+    }>;
+    readonly filterChange: OutputEmitterRef<{
+        filterState: FilterModel[];
+        previousFilterState: FilterModel[];
+    }>;
+    readonly filterBeforeFilter: OutputEmitterRef<{
+        filterState: FilterModel[];
+        cancel: () => void;
+    }>;
+    readonly filterAfterFilter: OutputEmitterRef<{
+        filterState: FilterModel[];
+        rowsVisible: number;
+        rowsHidden: number;
+    }>;
+    readonly filterExport: OutputEmitterRef<{
+        state: _zengrid_core_styles_features_filtering_types_js.FieldFilterState;
+        rest: _zengrid_core_styles_features_filtering_index_js.RESTFilterExport;
+        graphql: _zengrid_core_styles_features_filtering_index_js.GraphQLFilterExport;
+        sql: _zengrid_core_styles_features_filtering_index_js.SQLFilterExport;
+        previousState: _zengrid_core_styles_features_filtering_types_js.FieldFilterState;
+    }>;
+    readonly filterStart: OutputEmitterRef<{
+        timestamp: number;
+        filter: _zengrid_core.FilterExpression;
+    }>;
+    readonly filterEnd: OutputEmitterRef<{
+        timestamp: number;
+        resultCount: number;
+    }>;
+    readonly filterError: OutputEmitterRef<{
+        timestamp: number;
+        error: Error;
+    }>;
+    readonly filterClear: OutputEmitterRef<{
+        timestamp: number;
+    }>;
+    readonly focusChange: OutputEmitterRef<{
+        cell: CellRef | null;
+        previousCell: CellRef | null;
+    }>;
+    readonly focusIn: OutputEmitterRef<{
+        cell: CellRef;
+    }>;
+    readonly focusOut: OutputEmitterRef<{
+        cell: CellRef;
+    }>;
+    readonly keyDown: OutputEmitterRef<{
+        cell: CellRef;
+        key: string;
+        nativeEvent: KeyboardEvent;
+        preventDefault: () => void;
+    }>;
+    readonly keyUp: OutputEmitterRef<{
+        cell: CellRef;
+        key: string;
+        nativeEvent: KeyboardEvent;
+    }>;
+    readonly keyPress: OutputEmitterRef<{
+        cell: CellRef;
+        key: string;
+        nativeEvent: KeyboardEvent;
+    }>;
+    readonly columnResizeEvent: OutputEmitterRef<{
+        column: number;
+        oldWidth: number;
+        newWidth: number;
+    }>;
+    readonly columnMove: OutputEmitterRef<{
+        column: number;
+        oldIndex: number;
+        newIndex: number;
+    }>;
+    readonly columnHide: OutputEmitterRef<{
+        column: number;
+    }>;
+    readonly columnShow: OutputEmitterRef<{
+        column: number;
+    }>;
+    readonly columnDragStart: OutputEmitterRef<{
+        columnId: string;
+        columnIndex: number;
+        column: _zengrid_core_styles_types_js.ColumnDef;
+        nativeEvent: MouseEvent | TouchEvent;
+    }>;
+    readonly columnDragEvent: OutputEmitterRef<{
+        columnId: string;
+        currentX: number;
+        currentY: number;
+        targetColumnId: string | null;
+        targetIndex: number;
+        dropPosition: "before" | "after" | null;
+    }>;
+    readonly columnDragEnd: OutputEmitterRef<{
+        columnId: string;
+        fromIndex: number;
+        toIndex: number;
+        cancelled: boolean;
+    }>;
+    readonly columnDragCancel: OutputEmitterRef<{
+        columnId: string;
+        columnIndex: number;
+        reason: "escape" | "invalid-drop" | "programmatic";
+    }>;
+    readonly headerClick: OutputEmitterRef<{
+        columnIndex: number;
+        column: _zengrid_core_styles_types_js.ColumnDef;
+        nativeEvent: MouseEvent;
+    }>;
+    readonly headerDoubleClick: OutputEmitterRef<{
+        columnIndex: number;
+        column: _zengrid_core_styles_types_js.ColumnDef;
+        nativeEvent: MouseEvent;
+    }>;
+    readonly headerContextMenu: OutputEmitterRef<{
+        columnIndex: number;
+        column: _zengrid_core_styles_types_js.ColumnDef;
+        nativeEvent: MouseEvent;
+    }>;
+    readonly headerHover: OutputEmitterRef<{
+        columnIndex: number;
+        column: _zengrid_core_styles_types_js.ColumnDef;
+        isHovering: boolean;
+    }>;
+    readonly headerSortClick: OutputEmitterRef<{
+        columnIndex: number;
+        column: _zengrid_core_styles_types_js.ColumnDef;
+        currentDirection?: "asc" | "desc";
+        nextDirection: "asc" | "desc" | null;
+        additive?: boolean;
+        trigger?: "click" | "keyboard";
+        nativeEvent?: MouseEvent | KeyboardEvent;
+    }>;
+    readonly headerFilterClick: OutputEmitterRef<{
+        columnIndex: number;
+        column: _zengrid_core_styles_types_js.ColumnDef;
+        hasActiveFilter: boolean;
+        dropdownType?: string;
+        anchorElement?: HTMLElement;
+    }>;
+    readonly headerCheckboxChange: OutputEmitterRef<{
+        columnIndex: number;
+        checked: boolean;
+        action: "select-all" | "deselect-all";
+    }>;
+    readonly renderStart: OutputEmitterRef<{
+        timestamp: number;
+    }>;
+    readonly renderEnd: OutputEmitterRef<{
+        timestamp: number;
+        duration: number;
+    }>;
+    readonly dataLoad: OutputEmitterRef<{
+        rowCount: number;
+        colCount: number;
+    }>;
+    readonly dataChange: OutputEmitterRef<{
+        changes: Array<{
+            cell: CellRef;
+            oldValue: any;
+            newValue: any;
+        }>;
+    }>;
+    readonly loadingStart: OutputEmitterRef<{
+        timestamp: number;
+        message?: string;
+    }>;
+    readonly loadingEnd: OutputEmitterRef<{
+        timestamp: number;
+        duration: number;
+    }>;
+    readonly loadingProgress: OutputEmitterRef<{
+        progress: number;
+        message?: string;
+    }>;
+    readonly undoRedoChange: OutputEmitterRef<{
+        canUndo: boolean;
+        canRedo: boolean;
+        undoCount: number;
+        redoCount: number;
+    }>;
+    readonly gridDestroy: OutputEmitterRef<{
+        timestamp: number;
+    }>;
+    readonly gridError: OutputEmitterRef<{
+        message: string;
+        error: Error;
+        context?: any;
+    }>;
+    readonly gridWarning: OutputEmitterRef<{
+        message: string;
+        context?: any;
+    }>;
+    readonly rowInsert: OutputEmitterRef<{
+        index: number;
+        count: number;
+    }>;
+    readonly rowDelete: OutputEmitterRef<{
+        index: number;
+        count: number;
+    }>;
+    readonly rowMove: OutputEmitterRef<{
+        oldIndex: number;
+        newIndex: number;
+        count: number;
+    }>;
+    readonly copy: OutputEmitterRef<{
+        ranges: CellRange[];
+        data: string;
+    }>;
+    readonly cut: OutputEmitterRef<{
+        ranges: CellRange[];
+        data: string;
+    }>;
+    readonly paste: OutputEmitterRef<{
+        cell: CellRef;
+        data: string;
+    }>;
+    private outputMap;
+    private eventHandlers;
+    constructor();
+    private markExplicitInput;
+    private hasExplicitInput;
+    private getResolvedDataMode;
+    private getRequestedDataMode;
+    private warnOnLegacyBackendCallbacks;
+    private getResolvedRowHeight;
+    private getResolvedColWidth;
+    private getComponentColumns;
+    private buildOutputMap;
+    private initGrid;
+    private getOptionalOptions;
+    private wireEvents;
+    get gridInstance(): Grid | null;
+    render(): void;
+    refresh(): void;
+    clearCache(): void;
+    updateCells(cells: CellRef[]): void;
+    setData(data: any[][]): void;
+    getData(row: number, col: number): any;
+    sortColumn(column: number, direction?: 'asc' | 'desc' | null): void;
+    toggleSort(column: number): void;
+    getSortState(): SortState[];
+    clearSort(): void;
+    setSortState(sortState: SortState[]): void;
+    setFilter(column: number, operator: string, value: any): void;
+    setColumnFilter(column: number, conditions: Array<{
+        operator: string;
+        value: any;
+    }>, logic?: 'AND' | 'OR'): void;
+    getFilterState(): FilterModel[];
+    setFilterState(models: FilterModel[]): void;
+    clearFilters(): void;
+    clearColumnFilter(column: number): void;
+    setQuickFilter(query: string, columns?: number[]): void;
+    clearQuickFilter(): void;
+    exportCSV(options?: GridExportOptions): string;
+    exportTSV(options?: GridExportOptions): string;
+    goToPage(page: number): void;
+    nextPage(): void;
+    previousPage(): void;
+    setPageSize(pageSize: number): void;
+    getCurrentPage(): number;
+    getPageSize(): number;
+    getTotalPages(): number;
+    resizeColumn(col: number, width: number): void;
+    autoFitColumn(col: number): void;
+    autoFitAllColumns(): void;
+    setColumnConstraints(col: number, constraints: ColumnConstraints): void;
+    getColumnState(): ColumnStateSnapshot[];
+    applyColumnState(state: ColumnStateSnapshot[], options?: {
+        applyWidth?: boolean;
+        applyVisibility?: boolean;
+        applyOrder?: boolean;
+    }): void;
+    getStateSnapshot(): GridStateSnapshot | null;
+    applyStateSnapshot(snapshot: GridStateSnapshot): void;
+    scrollToCell(row: number, col: number): void;
+    getScrollPosition(): {
+        top: number;
+        left: number;
+    };
+    getVisibleRange(): VisibleRange | null;
+    registerHeaderRenderer(name: string, renderer: HeaderRenderer): void;
+    updateHeader(columnIndex: number): void;
+    updateAllHeaders(): void;
+    usePlugin(plugin: GridPlugin): void;
+    getStats(): any;
+    getDimensions(): {
+        width: number;
+        height: number;
+    };
+    getColumnPosition(col: number): {
+        x: number;
+        width: number;
+    };
+    getDataMode(): 'frontend' | 'backend';
+    getColumnSort(column: number): any;
+    getSortIcons(): {
+        asc: string;
+        desc: string;
+    };
+    getSortMode(): 'frontend' | 'backend';
+    getFieldFilterState(): any;
+    getFilterExports(): any;
+    getFilterMode(): 'frontend' | 'backend';
+    getQuickFilter(): {
+        query: string;
+        columns: number[] | null;
+    };
+    firstPage(): void;
+    lastPage(): void;
+    scrollThroughCells(cells: Array<{
+        row: number;
+        col: number;
+    }>, options?: {
+        delayMs?: number;
+        smooth?: boolean;
+        onCellReached?: (cell: {
+            row: number;
+            col: number;
+        }, index: number) => void;
+    }): {
+        promise: Promise<void>;
+        abort: () => void;
+    };
+    attachColumnResize(headerElement: HTMLElement): void;
+    detachColumnResize(): void;
+    updateColumnResizeHandles(): void;
+    attachColumnDrag(headerElement: HTMLElement): void;
+    detachColumnDrag(): void;
+    isDragging(): boolean;
+    registerRenderer(name: string, renderer: any): void;
+    updateOptions(options: Partial<GridOptions>): void;
+    refreshHeaders(): void;
+    resetInfiniteScrolling(): void;
+    getSlidingWindowStats(): any;
+    getStore(): any;
+    getPluginHost(): PluginHost | null;
+    getGridApi(): GridApiImpl | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZenGridComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZenGridComponent, "zen-grid", never, { "rowCount": { "alias": "rowCount"; "required": true; "isSignal": true; }; "colCount": { "alias": "colCount"; "required": true; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "colWidth": { "alias": "colWidth"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "enableSelection": { "alias": "enableSelection"; "required": false; "isSignal": true; }; "enableMultiSelection": { "alias": "enableMultiSelection"; "required": false; "isSignal": true; }; "selectionType": { "alias": "selectionType"; "required": false; "isSignal": true; }; "enableColumnResize": { "alias": "enableColumnResize"; "required": false; "isSignal": true; }; "enableColumnDrag": { "alias": "enableColumnDrag"; "required": false; "isSignal": true; }; "enableKeyboardNavigation": { "alias": "enableKeyboardNavigation"; "required": false; "isSignal": true; }; "enableA11y": { "alias": "enableA11y"; "required": false; "isSignal": true; }; "enableCellPooling": { "alias": "enableCellPooling"; "required": false; "isSignal": true; }; "dataMode": { "alias": "dataMode"; "required": false; "isSignal": true; }; "sortMode": { "alias": "sortMode"; "required": false; "isSignal": true; }; "filterMode": { "alias": "filterMode"; "required": false; "isSignal": true; }; "onDataRequest": { "alias": "onDataRequest"; "required": false; "isSignal": true; }; "onSortRequest": { "alias": "onSortRequest"; "required": false; "isSignal": true; }; "onFilterRequest": { "alias": "onFilterRequest"; "required": false; "isSignal": true; }; "onLoadMoreRows": { "alias": "onLoadMoreRows"; "required": false; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "infiniteScrolling": { "alias": "infiniteScrolling"; "required": false; "isSignal": true; }; "rowHeightMode": { "alias": "rowHeightMode"; "required": false; "isSignal": true; }; "rowHeightConfig": { "alias": "rowHeightConfig"; "required": false; "isSignal": true; }; "columnResize": { "alias": "columnResize"; "required": false; "isSignal": true; }; "columnDrag": { "alias": "columnDrag"; "required": false; "isSignal": true; }; "cellOverflow": { "alias": "cellOverflow"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "overscanRows": { "alias": "overscanRows"; "required": false; "isSignal": true; }; "overscanCols": { "alias": "overscanCols"; "required": false; "isSignal": true; }; "sortIcons": { "alias": "sortIcons"; "required": false; "isSignal": true; }; "rendererCache": { "alias": "rendererCache"; "required": false; "isSignal": true; }; "onScrollCallback": { "alias": "onScrollCallback"; "required": false; "isSignal": true; }; "onCellClickCallback": { "alias": "onCellClickCallback"; "required": false; "isSignal": true; }; "onCellDoubleClickCallback": { "alias": "onCellDoubleClickCallback"; "required": false; "isSignal": true; }; "onCellContextMenuCallback": { "alias": "onCellContextMenuCallback"; "required": false; "isSignal": true; }; "onSelectionChangeCallback": { "alias": "onSelectionChangeCallback"; "required": false; "isSignal": true; }; "onPageChangeCallback": { "alias": "onPageChangeCallback"; "required": false; "isSignal": true; }; "onColumnWidthsChangeCallback": { "alias": "onColumnWidthsChangeCallback"; "required": false; "isSignal": true; }; "plugins": { "alias": "plugins"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; "sortState": { "alias": "sortState"; "required": false; "isSignal": true; }; "filterState": { "alias": "filterState"; "required": false; "isSignal": true; }; "currentPage": { "alias": "currentPage"; "required": false; "isSignal": true; }; }, { "data": "dataChange"; "selection": "selectionChange"; "sortState": "sortStateChange"; "filterState": "filterStateChange"; "currentPage": "currentPageChange"; "cellClick": "cellClick"; "cellDoubleClick": "cellDoubleClick"; "cellContextMenu": "cellContextMenu"; "cellChange": "cellChange"; "cellBeforeChange": "cellBeforeChange"; "cellAfterChange": "cellAfterChange"; "selectionChangeEvent": "selectionChanged"; "selectionStart": "selectionStart"; "selectionEnd": "selectionEnd"; "editStart": "editStart"; "editEnd": "editEnd"; "editCommit": "editCommit"; "editCancel": "editCancel"; "scroll": "scroll"; "scrollStart": "scrollStart"; "scrollEnd": "scrollEnd"; "sortChange": "sortChange"; "sortBeforeSort": "sortBeforeSort"; "sortAfterSort": "sortAfterSort"; "filterChange": "filterChange"; "filterBeforeFilter": "filterBeforeFilter"; "filterAfterFilter": "filterAfterFilter"; "filterExport": "filterExport"; "filterStart": "filterStart"; "filterEnd": "filterEnd"; "filterError": "filterError"; "filterClear": "filterClear"; "focusChange": "focusChange"; "focusIn": "focusIn"; "focusOut": "focusOut"; "keyDown": "keyDown"; "keyUp": "keyUp"; "keyPress": "keyPress"; "columnResizeEvent": "columnResize"; "columnMove": "columnMove"; "columnHide": "columnHide"; "columnShow": "columnShow"; "columnDragStart": "columnDragStart"; "columnDragEvent": "columnDrag"; "columnDragEnd": "columnDragEnd"; "columnDragCancel": "columnDragCancel"; "headerClick": "headerClick"; "headerDoubleClick": "headerDoubleClick"; "headerContextMenu": "headerContextMenu"; "headerHover": "headerHover"; "headerSortClick": "headerSortClick"; "headerFilterClick": "headerFilterClick"; "headerCheckboxChange": "headerCheckboxChange"; "renderStart": "renderStart"; "renderEnd": "renderEnd"; "dataLoad": "dataLoad"; "dataChange": "dataChange"; "loadingStart": "loadingStart"; "loadingEnd": "loadingEnd"; "loadingProgress": "loadingProgress"; "undoRedoChange": "undoRedoChange"; "gridDestroy": "gridDestroy"; "gridError": "gridError"; "gridWarning": "gridWarning"; "rowInsert": "rowInsert"; "rowDelete": "rowDelete"; "rowMove": "rowMove"; "copy": "copy"; "cut": "cut"; "paste": "paste"; }, ["columnChildren"], ["*"], true, never>;
+}
+
+declare class ZenCellTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZenCellTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZenCellTemplateDirective, "[zenCellTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZenEditorTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZenEditorTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZenEditorTemplateDirective, "[zenEditorTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ZenHeaderTemplateDirective {
+    readonly templateRef: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZenHeaderTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZenHeaderTemplateDirective, "[zenHeaderTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+interface ZenCellTemplateContext {
+    $implicit: any;
+    value: any;
+    cell: CellRef;
+    row: any;
+    column: ColumnDef;
+    isSelected: boolean;
+}
+interface ZenEditorTemplateContext {
+    $implicit: any;
+    value: any;
+    cell: CellRef;
+    onComplete: (value: any) => void;
+    onChange: (value: any) => void;
+}
+interface ZenHeaderTemplateContext {
+    $implicit: ColumnDef;
+    column: ColumnDef;
+    sortState: 'asc' | 'desc' | null;
+}
+interface ZenGridConfig {
+    [key: string]: any;
+}
+type RendererInput = string | CellRenderer | TemplateRef<ZenCellTemplateContext> | Type<any>;
+type EditorInput = string | CellEditor | TemplateRef<ZenEditorTemplateContext> | Type<any>;
+type HeaderRendererInput = string | HeaderRenderer | TemplateRef<ZenHeaderTemplateContext> | Type<any>;
+
+declare class TemplateBridgeService {
+    private readonly appRef;
+    private readonly injector;
+    private readonly envInjector;
+    private templatePools;
+    private componentPools;
+    createTemplateRenderer(templateRef: TemplateRef<ZenCellTemplateContext>): CellRenderer;
+    createComponentRenderer(componentType: Type<any>): CellRenderer;
+    createTemplateEditor(templateRef: TemplateRef<ZenEditorTemplateContext>): CellEditor;
+    createComponentEditor(componentType: Type<any>): CellEditor;
+    acquireView<C>(templateRef: TemplateRef<C>, context: C): EmbeddedViewRef<C>;
+    releaseView<C>(templateRef: TemplateRef<C>, viewRef: EmbeddedViewRef<C>): void;
+    acquireComponent(componentType: Type<any>, hostElement: HTMLElement): ComponentRef<any>;
+    releaseComponent(componentType: Type<any>, componentRef: ComponentRef<any>): void;
+    destroyAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TemplateBridgeService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TemplateBridgeService>;
+}
+
+declare class ZenColumnComponent {
+    readonly field: _angular_core.InputSignal<string>;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<number>;
+    readonly renderer: _angular_core.InputSignal<RendererInput>;
+    readonly sortable: _angular_core.InputSignal<boolean>;
+    readonly editable: _angular_core.InputSignal<boolean>;
+    readonly editor: _angular_core.InputSignal<EditorInput>;
+    readonly editorOptions: _angular_core.InputSignal<any>;
+    readonly filterable: _angular_core.InputSignal<boolean>;
+    readonly resizable: _angular_core.InputSignal<boolean>;
+    readonly reorderable: _angular_core.InputSignal<boolean>;
+    readonly minWidth: _angular_core.InputSignal<number>;
+    readonly maxWidth: _angular_core.InputSignal<number>;
+    readonly overflow: _angular_core.InputSignal<CellOverflowConfig>;
+    readonly autoHeight: _angular_core.InputSignal<boolean>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly cellTemplate: _angular_core.Signal<ZenCellTemplateDirective>;
+    readonly editorTemplate: _angular_core.Signal<ZenEditorTemplateDirective>;
+    readonly headerTemplate: _angular_core.Signal<ZenHeaderTemplateDirective>;
+    toColumnDef(bridge: TemplateBridgeService): ColumnDef;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZenColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZenColumnComponent, "zen-column", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "header": { "alias": "header"; "required": true; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "renderer": { "alias": "renderer"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "editor": { "alias": "editor"; "required": false; "isSignal": true; }; "editorOptions": { "alias": "editorOptions"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "overflow": { "alias": "overflow"; "required": false; "isSignal": true; }; "autoHeight": { "alias": "autoHeight"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, ["cellTemplate", "editorTemplate", "headerTemplate"], ["*"], true, never>;
+}
+
+declare class ZenGridValueAccessorDirective implements ControlValueAccessor {
+    private readonly grid;
+    private onChange;
+    private onTouched;
+    constructor();
+    writeValue(value: any[][]): void;
+    registerOnChange(fn: (value: any[][]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZenGridValueAccessorDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ZenGridValueAccessorDirective, "zen-grid[formControl],zen-grid[formControlName],zen-grid[ngModel]", never, {}, {}, never, never, true, never>;
+}
+
+declare const ZEN_GRID_CONFIG: InjectionToken<ZenGridConfig>;
+declare function provideZenGrid(config: ZenGridConfig): Provider;
+
+declare class AngularPluginWrapper implements GridPlugin {
+    private readonly injector;
+    private readonly pluginFactory;
+    readonly name: string;
+    readonly phase: number;
+    readonly dependencies?: string[];
+    constructor(injector: Injector, pluginFactory: (injector: Injector) => GridPlugin);
+    setup(store: GridStore, api: GridApiInterface): PluginDisposable | void;
+    dispose(): void;
+}
+declare function createAngularPlugin(injector: Injector, factory: (injector: Injector) => GridPlugin): GridPlugin;
+
+declare const EVENT_MAP: Record<string, string>;
+
+declare function bridgeStoreSignal<T>(store: GridStore, key: string): Signal<T>;
+
+export { AngularPluginWrapper, EVENT_MAP, TemplateBridgeService, ZEN_GRID_CONFIG, ZenCellTemplateDirective, ZenColumnComponent, ZenEditorTemplateDirective, ZenGridComponent, ZenGridValueAccessorDirective, ZenHeaderTemplateDirective, bridgeStoreSignal, createAngularPlugin, provideZenGrid };
+export type { EditorInput, HeaderRendererInput, RendererInput, ZenCellTemplateContext, ZenEditorTemplateContext, ZenGridConfig, ZenHeaderTemplateContext };