@mozaic-ds/angular 2.0.12 → 2.0.14

package/types/mozaic-ds-angular.d.ts

@@ -7,6 +7,8 @@ import { OverlayRef, ConnectedPosition } from '@angular/cdk/overlay';
 import { Observable } from 'rxjs';
 import { CdkPortalOutlet } from '@angular/cdk/portal';
 import * as _mozaic_ds_angular from '@mozaic-ds/angular';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
 import { ComponentHarness } from '@angular/cdk/testing';
 
 type MozBreadcrumbAppearance = 'standard' | 'inverse';
@@ -2215,6 +2217,1143 @@ declare class MozNavigationIndicatorComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozNavigationIndicatorComponent, "moz-navigation-indicator", never, { "steps": { "alias": "steps"; "required": true; "isSignal": true; }; "active": { "alias": "active"; "required": false; "isSignal": true; }; "action": { "alias": "action"; "required": false; "isSignal": true; }; "light": { "alias": "light"; "required": false; "isSignal": true; }; "hideAction": { "alias": "hideAction"; "required": false; "isSignal": true; }; "pauseLabel": { "alias": "pauseLabel"; "required": false; "isSignal": true; }; "resumeLabel": { "alias": "resumeLabel"; "required": false; "isSignal": true; }; }, { "active": "activeChange"; "stepClick": "stepClick"; "actionClick": "actionClick"; }, never, never, true, never>;
 }
 
+type SortDirection = 'asc' | 'desc' | null;
+type CellEditorType = 'text' | 'number' | 'textarea' | 'select' | 'checkbox' | 'date' | 'toggle' | 'custom';
+interface ColumnDef<T = unknown> {
+    /** Unique column identifier */
+    field: string;
+    /** Display name in header */
+    headerName?: string;
+    /** Fixed width in px (e.g. '120px') */
+    width?: string;
+    /** Minimum width in px for resize */
+    minWidth?: string;
+    /** Maximum width in px for resize */
+    maxWidth?: string;
+    /** Flex grow factor (like CSS flex) */
+    flex?: number;
+    /** Whether column is sortable */
+    sortable?: boolean;
+    /** Custom sort comparator */
+    sortComparator?: (a: T, b: T) => number;
+    /** Whether column is resizable */
+    resizable?: boolean;
+    /** Whether column is reorderable */
+    reorderable?: boolean;
+    /** Whether column is groupable */
+    groupable?: boolean;
+    /** Whether column supports filtering */
+    filterable?: boolean;
+    /** Whether column is pinned/frozen ('start' | 'end' | null) */
+    pinned?: 'start' | 'end' | null;
+    /** Whether column is visible */
+    visible?: boolean;
+    /** Whether column can be hidden via header menu */
+    hideable?: boolean;
+    /** Whether column can be frozen via header menu */
+    freezable?: boolean;
+    /** Whether the column header search (filter input) is visible */
+    searchVisible?: boolean;
+    /** Disable the header menu entirely for this column */
+    headerMenuDisabled?: boolean;
+    /** Cell value accessor (alternative to field for nested data) */
+    valueGetter?: (row: T) => unknown;
+    /** Cell value formatter for display */
+    valueFormatter?: (value: unknown, row: T) => string;
+    /** CSS class for column cells */
+    cellClass?: string | ((row: T) => string);
+    /** CSS class for header cell */
+    headerClass?: string;
+    /** Whether this column supports inline editing (double-click to edit) */
+    editable?: boolean;
+    /** Editor type — determines which Mozaic component is rendered in edit mode */
+    cellEditor?: CellEditorType;
+    /** Options for select editors (MozSelectOption[]) */
+    cellEditorOptions?: MozSelectOption[];
+    /** Custom validation before commit */
+    cellEditorValidator?: (value: unknown, row: T) => boolean | string;
+    /** Custom cell template */
+    cellTemplate?: TemplateRef<unknown>;
+    /** Custom edit template */
+    editTemplate?: TemplateRef<unknown>;
+    /** Custom filter template rendered in the sub-header filter row */
+    filterTemplate?: TemplateRef<unknown>;
+}
+interface ColumnStateEntry {
+    field: string;
+    currentWidth: number;
+    order: number;
+    visible: boolean;
+    sort: SortDirection;
+    sortIndex: number | null;
+    pinned: 'start' | 'end' | null;
+    searchVisible: boolean;
+}
+interface ColumnResizeEvent {
+    field: string;
+    previousWidth: number;
+    newWidth: number;
+}
+interface ColumnReorderEvent {
+    field: string;
+    previousIndex: number;
+    newIndex: number;
+    columns: string[];
+}
+interface ColumnFreezeEvent {
+    field: string;
+    side: 'start' | 'end' | null;
+    frozenLeftColumns: string[];
+    frozenRightColumns: string[];
+}
+interface ColumnVisibilityEvent {
+    field: string;
+    visible: boolean;
+    visibleColumns: string[];
+}
+interface ColumnSearchToggleEvent {
+    field: string;
+    searchVisible: boolean;
+}
+type HeaderMenuActionId = 'sort-asc' | 'sort-desc' | 'filter-column' | 'group-column' | 'freeze-column-left' | 'freeze-column-right' | 'unfreeze-column' | 'hide-column' | 'toggle-column-search';
+interface HeaderMenuConfig {
+    field: string;
+    columnIndex: number;
+    headerName: string;
+    sortable: boolean;
+    filterable: boolean;
+    groupable: boolean;
+    freezable: boolean;
+    hideable: boolean;
+    searchVisible: boolean;
+    currentSort: SortDirection;
+}
+
+interface SortDef {
+    field: string;
+    direction: SortDirection;
+    priority: number;
+}
+interface SortEvent {
+    sorts: SortDef[];
+}
+
+interface CellCoord {
+    row: number;
+    col: number;
+}
+interface CellRange {
+    start: CellCoord;
+    end: CellCoord;
+}
+interface CellEditState {
+    editingCell: CellCoord | null;
+    originalValue: unknown;
+    draftValue: unknown;
+    validationError: string | null;
+}
+interface CellEditEvent<T = unknown> {
+    row: T;
+    rowIndex: number;
+    field: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+interface CellEditCancelEvent {
+    rowIndex: number;
+    field: string;
+    originalValue: unknown;
+}
+interface BulkEditEvent {
+    range: CellRange | null;
+    cellCount: number;
+    rowIds: unknown[];
+    fields: string[];
+    selectionMode?: 'rows' | 'cells';
+    rowSelection?: unknown;
+}
+interface BulkCopyEvent {
+    range: CellRange | null;
+    data: string[][];
+    rowIds: unknown[];
+    fields: string[];
+    selectionMode?: 'rows' | 'cells';
+    rowSelection?: unknown;
+}
+interface BulkPasteEvent {
+    range: CellRange | null;
+    data: string[][];
+    rowIds: unknown[];
+    fields: string[];
+    selectionMode?: 'rows' | 'cells';
+    rowSelection?: unknown;
+}
+interface BulkDeleteEvent {
+    range: CellRange | null;
+    cellCount: number;
+    rowIds: unknown[];
+    fields: string[];
+    selectionMode?: 'rows' | 'cells';
+    rowSelection?: unknown;
+}
+
+interface PaginationState {
+    pageIndex: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+}
+interface PageEvent {
+    pageIndex: number;
+    pageSize: number;
+    previousPageIndex: number;
+    previousPageSize: number;
+}
+
+interface FilterEvent {
+    filters: ActiveFilter[];
+}
+interface ActiveFilter {
+    field: string;
+    label: string;
+    value: unknown;
+    removable: boolean;
+}
+interface GroupEvent {
+    columns: string[];
+    groups: GroupEntry[];
+}
+interface RowSelectionEvent<T = unknown> {
+    selectedIds: unknown[];
+    excludedIds: unknown[];
+    selectedRows: T[];
+    mode: SelectAllMode;
+    count: number;
+}
+type SelectAllMode = 'none' | 'page' | 'all';
+interface CellSelectionEvent<T = unknown> {
+    focusedCell: {
+        row: number;
+        col: number;
+    } | null;
+    selectedCell: {
+        row: number;
+        col: number;
+    } | null;
+    range: {
+        start: {
+            row: number;
+            col: number;
+        };
+        end: {
+            row: number;
+            col: number;
+        };
+    } | null;
+    selectedData: {
+        row: T;
+        column: string;
+        value: unknown;
+    }[];
+}
+interface GridEventMap<T = unknown> {
+    pageChange: PageEvent;
+    sortChange: SortEvent;
+    filterChange: FilterEvent;
+    groupChange: GroupEvent;
+    columnResize: ColumnResizeEvent;
+    columnReorder: ColumnReorderEvent;
+    columnFreeze: ColumnFreezeEvent;
+    columnVisibility: ColumnVisibilityEvent;
+    columnSearchToggle: ColumnSearchToggleEvent;
+    selectionChange: RowSelectionEvent<T>;
+    cellSelectionChange: CellSelectionEvent<T>;
+    rowClick: {
+        row: T;
+        index: number;
+        event: MouseEvent;
+    };
+    rowExpand: {
+        row: T;
+        index: number;
+        expanded: boolean;
+    };
+    cellEdit: CellEditEvent<T>;
+    cellEditCancel: CellEditCancelEvent;
+}
+type GridEventType = keyof GridEventMap;
+type GridDensity = 'small' | 'default' | 'large';
+interface GridSettingsData {
+    columns: {
+        field: string;
+        headerName: string;
+        visible: boolean;
+    }[];
+    density: GridDensity;
+    defaultColumns: {
+        field: string;
+        headerName: string;
+        visible: boolean;
+    }[];
+}
+interface GridSettingsResult {
+    density: GridDensity;
+    columns: {
+        field: string;
+        visible: boolean;
+        order: number;
+    }[];
+}
+interface GroupEntry {
+    field: string;
+    sortDirection: 'asc' | 'desc';
+}
+interface GroupDrawerData {
+    groups: GroupEntry[];
+    availableColumns: {
+        field: string;
+        headerName: string;
+    }[];
+}
+interface GroupDrawerResult {
+    groups: GroupEntry[];
+}
+
+interface FilterDef {
+    field: string;
+    type: 'text' | 'select' | 'range' | 'custom';
+    operator: 'contains' | 'equals' | 'startsWith' | 'gt' | 'lt' | 'between' | 'in';
+    value: unknown;
+}
+declare class FilterEngine<T = unknown> {
+    private readonly state;
+    setFilter(field: string, value: unknown, operator?: FilterDef['operator']): void;
+    removeFilter(field: string): void;
+    clearAllFilters(): void;
+    filterData(data: T[]): T[];
+    private matchFilter;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<FilterEngine<any>>;
+}
+
+declare class GridStateManager<T = unknown> {
+    readonly sourceData: _angular_core.WritableSignal<T[]>;
+    readonly totalItems: _angular_core.WritableSignal<number>;
+    readonly mode: _angular_core.WritableSignal<"client" | "server">;
+    readonly columnDefs: _angular_core.WritableSignal<ColumnDef<T>[]>;
+    readonly columnStates: _angular_core.WritableSignal<ColumnStateEntry[]>;
+    readonly activeSorts: _angular_core.WritableSignal<SortDef[]>;
+    readonly groupColumns: _angular_core.WritableSignal<GroupEntry[]>;
+    readonly expandedGroups: _angular_core.WritableSignal<Set<string>>;
+    readonly activeFilters: _angular_core.WritableSignal<ActiveFilter[]>;
+    readonly filterDefs: _angular_core.WritableSignal<FilterDef[]>;
+    readonly pageIndex: _angular_core.WritableSignal<number>;
+    readonly pageSize: _angular_core.WritableSignal<number>;
+    readonly visibleRowCount: _angular_core.WritableSignal<number>;
+    readonly scrollLeft: _angular_core.WritableSignal<number>;
+    readonly scrollTop: _angular_core.WritableSignal<number>;
+    readonly scrollViewportWidth: _angular_core.WritableSignal<number>;
+    readonly scrollContentTotalWidth: _angular_core.WritableSignal<number>;
+    readonly isLoading: _angular_core.WritableSignal<boolean>;
+    readonly rowHeight: _angular_core.WritableSignal<number>;
+    readonly density: _angular_core.WritableSignal<GridDensity>;
+    readonly selectedRowIds: _angular_core.WritableSignal<Set<unknown>>;
+    readonly excludedRowIds: _angular_core.WritableSignal<Set<unknown>>;
+    readonly selectAllMode: _angular_core.WritableSignal<"none" | "page" | "all">;
+    readonly focusedCell: _angular_core.WritableSignal<CellCoord | null>;
+    readonly selectedCell: _angular_core.WritableSignal<CellCoord | null>;
+    readonly cellRange: _angular_core.WritableSignal<{
+        start: CellCoord;
+        end: CellCoord;
+    } | null>;
+    readonly isDragging: _angular_core.WritableSignal<boolean>;
+    readonly focusSource: _angular_core.WritableSignal<"click" | "keyboard" | null>;
+    readonly expandedRowIds: _angular_core.WritableSignal<Set<unknown>>;
+    readonly rowIdField: _angular_core.WritableSignal<string>;
+    readonly activeSelectionMode: _angular_core.WritableSignal<"none" | "rows" | "cells">;
+    readonly draggingColumn: _angular_core.WritableSignal<string | null>;
+    readonly dropIndicatorIndex: _angular_core.WritableSignal<number | null>;
+    readonly cellEditState: _angular_core.WritableSignal<CellEditState>;
+    readonly visibleColumns: _angular_core.Signal<ColumnStateEntry[]>;
+    readonly pinnedLeftColumns: _angular_core.Signal<ColumnStateEntry[]>;
+    readonly unpinnedColumns: _angular_core.Signal<ColumnStateEntry[]>;
+    readonly pinnedRightColumns: _angular_core.Signal<ColumnStateEntry[]>;
+    readonly pinnedLeftWidth: _angular_core.Signal<number>;
+    readonly pinnedRightWidth: _angular_core.Signal<number>;
+    readonly unpinnedWidth: _angular_core.Signal<number>;
+    readonly columnDefMap: _angular_core.Signal<Map<string, ColumnDef<T>>>;
+    readonly gridTemplateColumns: _angular_core.Signal<string>;
+    readonly totalContentWidth: _angular_core.Signal<number>;
+    readonly totalPages: _angular_core.Signal<number>;
+    initColumns(defs: ColumnDef<T>[]): void;
+    updateColumnState(field: string, updates: Partial<ColumnStateEntry>): void;
+    private resolveWidth;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridStateManager<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GridStateManager<any>>;
+}
+
+declare class RowSelectionEngine<T = unknown> {
+    private readonly state;
+    private readonly engine;
+    readonly selectedIds: _angular_core.Signal<Set<unknown>>;
+    readonly excludedIds: _angular_core.Signal<Set<unknown>>;
+    readonly lastToggledIndex: _angular_core.WritableSignal<number>;
+    readonly count: _angular_core.Signal<number>;
+    readonly pageSelectedCount: _angular_core.Signal<number>;
+    readonly isAllSelected: _angular_core.Signal<boolean>;
+    readonly isIndeterminate: _angular_core.Signal<boolean>;
+    selectRowRange(fromIndex: number, toIndex: number): void;
+    toggleRow(row: T): void;
+    isRowSelected(row: T): boolean;
+    selectAllPage(): void;
+    selectAll(): void;
+    deselectAll(): void;
+    deselectPage(): void;
+    toggleSelectAllPage(): void;
+    getSelectionEvent(): RowSelectionEvent<T>;
+    getRowId(row: T): unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowSelectionEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<RowSelectionEngine<any>>;
+}
+
+interface GridPlugin {
+    name: string;
+    init(state: GridStateManager<never>): void;
+    destroy(): void;
+}
+
+type GridToolbarSlot = 'start' | 'end';
+declare class MozGridToolbarDef {
+    readonly slot: _angular_core.InputSignal<GridToolbarSlot>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridToolbarDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MozGridToolbarDef, "[mozGridToolbarDef]", never, { "slot": { "alias": "mozGridToolbarDef"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MozGridComponent<T = unknown> {
+    protected readonly state: GridStateManager<T>;
+    private readonly gridEngine;
+    private readonly sortEngine;
+    private readonly inlineEditEngine;
+    private readonly resizeEngine;
+    protected readonly rowSelectionEngine: RowSelectionEngine<T>;
+    private readonly cellSelectionEngine;
+    private readonly keyboardEngine;
+    private readonly groupEngine;
+    private readonly filterEngine;
+    private readonly persistenceEngine;
+    private readonly exportEngine;
+    private readonly gridBody;
+    private readonly gridContainer;
+    private readonly ngZone;
+    private readonly drawerService;
+    private readonly columnDefs;
+    private readonly toolbarDefs;
+    readonly data: _angular_core.InputSignal<T[]>;
+    readonly mode: _angular_core.InputSignal<"client" | "server">;
+    readonly totalItems: _angular_core.InputSignal<number>;
+    readonly pagination: _angular_core.InputSignal<boolean>;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    readonly rowHeight: _angular_core.InputSignal<number>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly rowSelection: _angular_core.InputSignal<boolean>;
+    readonly cellSelection: _angular_core.InputSignal<boolean>;
+    readonly expandable: _angular_core.InputSignal<boolean>;
+    readonly rowIdField: _angular_core.InputSignal<string>;
+    readonly detailTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly fullscreen: _angular_core.InputSignal<boolean>;
+    readonly reorderable: _angular_core.InputSignal<boolean>;
+    readonly stateKey: _angular_core.InputSignal<string | null>;
+    readonly exportable: _angular_core.InputSignal<boolean>;
+    readonly plugins: _angular_core.InputSignal<GridPlugin[]>;
+    readonly sortChange: _angular_core.OutputEmitterRef<SortEvent>;
+    readonly pageChange: _angular_core.OutputEmitterRef<PageEvent>;
+    readonly cellEdit: _angular_core.OutputEmitterRef<CellEditEvent<T>>;
+    readonly cellEditCancel: _angular_core.OutputEmitterRef<CellEditCancelEvent>;
+    readonly selectionChange: _angular_core.OutputEmitterRef<RowSelectionEvent<T>>;
+    readonly cellSelectionChange: _angular_core.OutputEmitterRef<CellSelectionEvent<T>>;
+    readonly groupChange: _angular_core.OutputEmitterRef<GroupEvent>;
+    readonly filterChange: _angular_core.OutputEmitterRef<FilterEvent>;
+    readonly bulkEdit: _angular_core.OutputEmitterRef<BulkEditEvent>;
+    readonly bulkCopy: _angular_core.OutputEmitterRef<BulkCopyEvent>;
+    readonly bulkPaste: _angular_core.OutputEmitterRef<BulkPasteEvent>;
+    readonly bulkDelete: _angular_core.OutputEmitterRef<BulkDeleteEvent>;
+    readonly settingsChange: _angular_core.OutputEmitterRef<GridSettingsResult>;
+    protected readonly isFullscreen: _angular_core.WritableSignal<boolean>;
+    protected readonly groupPanelOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly filterPanelOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly hasHiddenColumns: _angular_core.Signal<boolean>;
+    protected readonly hiddenColumnsList: _angular_core.Signal<{
+        field: string;
+        label: string;
+    }[]>;
+    protected readonly toolbarStartDefs: _angular_core.Signal<MozGridToolbarDef[]>;
+    protected readonly toolbarEndDefs: _angular_core.Signal<MozGridToolbarDef[]>;
+    protected readonly selectionBannerVisible: _angular_core.Signal<boolean>;
+    protected readonly selectionTotalCount: _angular_core.Signal<number>;
+    private columnsInitialized;
+    constructor();
+    onSortClick(event: {
+        field: string;
+        isMultiSort: boolean;
+    }): void;
+    onMenuAction(event: {
+        field: string;
+        actionId: HeaderMenuActionId;
+    }): void;
+    onCellEdit(event: CellEditEvent<unknown>): void;
+    onSelectAllToggle(): void;
+    onRowSelectionToggle(): void;
+    private activateRowSelectionMode;
+    onKeydown(event: KeyboardEvent): void;
+    private handleEditModeKeydown;
+    private refocusGrid;
+    onMouseUp(): void;
+    onGroupToggle(groupKey: string): void;
+    onRemoveGroup(field: string): void;
+    onToggleGroupSort(field: string): void;
+    onSelectAllRows(): void;
+    onClearSelection(): void;
+    onRemoveFilter(field: string): void;
+    onRemoveAllFilters(): void;
+    onRestoreColumn(field: string): void;
+    toggleFullscreen(): void;
+    onRestoreAllColumns(): void;
+    getColumnLabel(field: string): string;
+    onResizeStart(event: {
+        field: string;
+        event: MouseEvent;
+    }): void;
+    onExportCsv(): void;
+    onGroupClick(): void;
+    private applyGroupResult;
+    private static readonly DENSITY_ROW_HEIGHT;
+    onSettingsClick(): void;
+    private applySettings;
+    private freezeLeft;
+    private freezeRight;
+    private getRangeRowIds;
+    private getRangeFields;
+    private getRowSelectionIds;
+    private getAllVisibleFields;
+    private clearSelectionAndCloseBar;
+    onBulkEdit(): void;
+    onBulkCopy(): void;
+    onBulkPaste(): Promise<void>;
+    onBulkDelete(): void;
+    private extractRangeData;
+    private applyPasteData;
+    private extractRowSelectionData;
+    private applyPasteToSelectedRows;
+    private deleteSelectedRows;
+    private coerceAndValidate;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridComponent<any>, "moz-grid", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "totalItems": { "alias": "totalItems"; "required": false; "isSignal": true; }; "pagination": { "alias": "pagination"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "rowSelection": { "alias": "rowSelection"; "required": false; "isSignal": true; }; "cellSelection": { "alias": "cellSelection"; "required": false; "isSignal": true; }; "expandable": { "alias": "expandable"; "required": false; "isSignal": true; }; "rowIdField": { "alias": "rowIdField"; "required": false; "isSignal": true; }; "detailTemplate": { "alias": "detailTemplate"; "required": false; "isSignal": true; }; "fullscreen": { "alias": "fullscreen"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "exportable": { "alias": "exportable"; "required": false; "isSignal": true; }; "plugins": { "alias": "plugins"; "required": false; "isSignal": true; }; }, { "sortChange": "sortChange"; "pageChange": "pageChange"; "cellEdit": "cellEdit"; "cellEditCancel": "cellEditCancel"; "selectionChange": "selectionChange"; "cellSelectionChange": "cellSelectionChange"; "groupChange": "groupChange"; "filterChange": "filterChange"; "bulkEdit": "bulkEdit"; "bulkCopy": "bulkCopy"; "bulkPaste": "bulkPaste"; "bulkDelete": "bulkDelete"; "settingsChange": "settingsChange"; }, ["columnDefs", "toolbarDefs"], ["[mozGridFilterTags]"], true, never>;
+}
+
+interface GroupRow<T = unknown> {
+    type: 'group';
+    field: string;
+    value: unknown;
+    displayValue: string;
+    depth: number;
+    count: number;
+    expanded: boolean;
+    groupKey: string;
+    children: (GroupRow<T> | T)[];
+    parent: GroupRow<T> | null;
+}
+type DisplayRow<T = unknown> = {
+    type: 'data';
+    data: T;
+    index: number;
+    depth: number;
+} | {
+    type: 'group';
+    group: GroupRow<T>;
+} | {
+    type: 'detail';
+    data: T;
+    index: number;
+};
+
+interface GridOptions<T = unknown> {
+    /** Data mode */
+    mode: 'client' | 'server';
+    /** Pagination */
+    pagination: boolean;
+    pageSize: number;
+    pageSizeOptions: number[];
+    /** Row height for virtual scroll (px) */
+    rowHeight: number;
+    /** Enable row checkbox selection */
+    rowSelection: boolean;
+    /** Selection mode */
+    selectionMode: 'single' | 'multiple';
+    /** Enable cell selection / navigation */
+    cellSelection: boolean;
+    /** Enable column grouping */
+    grouping: boolean;
+    /** Enable fullscreen toggle */
+    fullscreen: boolean;
+    /** Enable expandable rows */
+    expandableRows: boolean;
+    /** Enable column resize */
+    columnResize: boolean;
+    /** Enable column reorder */
+    columnReorder: boolean;
+    /** Track by function for virtual scroll */
+    trackBy: (index: number, item: T) => unknown;
+}
+declare const DEFAULT_GRID_OPTIONS: GridOptions;
+
+declare class MozGridColumnDef<T = unknown> {
+    readonly field: _angular_core.InputSignal<string>;
+    readonly headerName: _angular_core.InputSignal<string | undefined>;
+    readonly width: _angular_core.InputSignal<string | undefined>;
+    readonly minWidth: _angular_core.InputSignal<string | undefined>;
+    readonly maxWidth: _angular_core.InputSignal<string | undefined>;
+    readonly flex: _angular_core.InputSignal<number | undefined>;
+    readonly sortable: _angular_core.InputSignal<boolean>;
+    readonly resizable: _angular_core.InputSignal<boolean>;
+    readonly reorderable: _angular_core.InputSignal<boolean>;
+    readonly groupable: _angular_core.InputSignal<boolean>;
+    readonly filterable: _angular_core.InputSignal<boolean>;
+    readonly editable: _angular_core.InputSignal<boolean>;
+    readonly visible: _angular_core.InputSignal<boolean>;
+    readonly hideable: _angular_core.InputSignal<boolean>;
+    readonly freezable: _angular_core.InputSignal<boolean>;
+    readonly headerMenuDisabled: _angular_core.InputSignal<boolean>;
+    readonly pinned: _angular_core.InputSignal<"start" | "end" | null>;
+    readonly cellEditor: _angular_core.InputSignal<CellEditorType | undefined>;
+    readonly cellEditorOptions: _angular_core.InputSignal<MozSelectOption[] | undefined>;
+    readonly cellTemplateInput: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly editTemplateInput: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly filterTemplateInput: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly cellTemplateContent: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly editTemplateContent: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    readonly filterTemplateContent: _angular_core.Signal<TemplateRef<unknown> | undefined>;
+    toColumnDef(): ColumnDef<T>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridColumnDef<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MozGridColumnDef<any>, "moz-grid-column-def", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "headerName": { "alias": "headerName"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "flex": { "alias": "flex"; "required": false; "isSignal": true; }; "sortable": { "alias": "sortable"; "required": false; "isSignal": true; }; "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "groupable": { "alias": "groupable"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "hideable": { "alias": "hideable"; "required": false; "isSignal": true; }; "freezable": { "alias": "freezable"; "required": false; "isSignal": true; }; "headerMenuDisabled": { "alias": "headerMenuDisabled"; "required": false; "isSignal": true; }; "pinned": { "alias": "pinned"; "required": false; "isSignal": true; }; "cellEditor": { "alias": "cellEditor"; "required": false; "isSignal": true; }; "cellEditorOptions": { "alias": "cellEditorOptions"; "required": false; "isSignal": true; }; "cellTemplateInput": { "alias": "cellTemplate"; "required": false; "isSignal": true; }; "editTemplateInput": { "alias": "editTemplate"; "required": false; "isSignal": true; }; "filterTemplateInput": { "alias": "filterTemplate"; "required": false; "isSignal": true; }; }, {}, ["cellTemplateContent", "editTemplateContent", "filterTemplateContent"], never, true, never>;
+}
+
+declare class GridEngine<T = unknown> {
+    private readonly state;
+    private readonly sortEngine;
+    private readonly filterEngine;
+    private readonly groupEngine;
+    /**
+     * Pipeline step 1: sorted data.
+     * In server mode, returns source data unchanged.
+     */
+    readonly sortedData: _angular_core.Signal<T[]>;
+    /**
+     * Pipeline step 2: filtered data.
+     * In server mode, returns sorted data unchanged.
+     */
+    readonly filteredData: _angular_core.Signal<T[]>;
+    /**
+     * Pipeline step 3: paginated data.
+     * In server mode, the data is already paginated by the server.
+     * Pagination applies before grouping so groups are per-page.
+     */
+    readonly paginatedData: _angular_core.Signal<T[]>;
+    /**
+     * Pipeline final: display rows (flat array for virtual scroll).
+     * If grouped, produces group header + data rows.
+     * If not grouped, wraps paginated data rows.
+     */
+    readonly displayRows: _angular_core.Signal<DisplayRow<T>[]>;
+    /**
+     * Total items count for pagination.
+     */
+    readonly computedTotalItems: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GridEngine<any>>;
+}
+
+declare class SortEngine<T = unknown> {
+    private readonly state;
+    toggleSort(field: string, isMultiSort: boolean): void;
+    setSort(field: string, direction: SortDirection): void;
+    clearSort(): void;
+    sortData(data: T[]): T[];
+    private syncColumnSortState;
+    private getValue;
+    private defaultCompare;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SortEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SortEngine<any>>;
+}
+
+declare class ColumnResizeEngine<T = unknown> {
+    private readonly state;
+    private readonly ngZone;
+    private resizing;
+    private resizeField;
+    private startX;
+    private startWidth;
+    private invertDelta;
+    private readonly onMouseMove;
+    private readonly onMouseUp;
+    startResize(field: string, event: MouseEvent): void;
+    getResizeEvent(field: string, previousWidth: number): ColumnResizeEvent;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnResizeEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ColumnResizeEngine<any>>;
+}
+
+declare class InlineEditEngine<T = unknown> {
+    private readonly state;
+    startEdit(rowIndex: number, field: string): void;
+    updateDraft(value: unknown): void;
+    commitEdit(): CellEditEvent<T> | null;
+    cancelEdit(): CellEditCancelEvent | null;
+    isEditing(rowIndex: number, colIndex: number): boolean;
+    resolveEditorType(field: string, value: unknown): CellEditorType;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InlineEditEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<InlineEditEngine<any>>;
+}
+
+declare class CellSelectionEngine<T = unknown> {
+    private readonly state;
+    focusCell(row: number, col: number, source?: 'click' | 'keyboard'): void;
+    clearFocus(): void;
+    isCellFocused(row: number, col: number): boolean;
+    isCellInRange(row: number, col: number): boolean;
+    selectRange(start: {
+        row: number;
+        col: number;
+    }, end: {
+        row: number;
+        col: number;
+    }): void;
+    startRangeSelection(row: number, col: number): void;
+    extendRange(row: number, col: number): void;
+    endRangeSelection(): void;
+    moveUp(): void;
+    moveDown(): void;
+    moveLeft(): void;
+    moveRight(): void;
+    moveToNextEditableCell(): void;
+    private moveBy;
+    getNormalizedRange(): CellRange | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CellSelectionEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<CellSelectionEngine<any>>;
+}
+
+declare class KeyboardEngine<T = unknown> {
+    private readonly cellSelection;
+    private readonly inlineEdit;
+    private readonly state;
+    handleKeydown(event: KeyboardEvent): void;
+    private handleNavigationKey;
+    private extendRangeBy;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyboardEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KeyboardEngine<any>>;
+}
+
+declare class GroupEngine<T = unknown> {
+    private readonly state;
+    addGroup(field: string): void;
+    removeGroup(field: string): void;
+    applyGroups(groups: GroupEntry[]): void;
+    clearGroups(): void;
+    toggleGroupExpand(groupKey: string): void;
+    isGroupExpanded(groupKey: string): boolean;
+    groupData(data: T[]): DisplayRow<T>[];
+    private buildGroups;
+    private flattenGroups;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GroupEngine<any>>;
+}
+
+declare class ColumnReorderEngine<T = unknown> {
+    private readonly state;
+    reorder(previousIndex: number, newIndex: number): void;
+    /**
+     * Reorder using indices relative to unpinned columns only.
+     * Translates to global columnStates indices before applying.
+     */
+    reorderUnpinned(unpinnedPrevIndex: number, unpinnedNewIndex: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnReorderEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ColumnReorderEngine<any>>;
+}
+
+declare class ExpandableRowEngine<T = unknown> {
+    private readonly state;
+    readonly hasExpandedRows: _angular_core.Signal<boolean>;
+    toggleRow(rowId: unknown): void;
+    expandRow(rowId: unknown): void;
+    collapseRow(rowId: unknown): void;
+    collapseAll(): void;
+    isRowExpanded(rowId: unknown): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExpandableRowEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ExpandableRowEngine<any>>;
+}
+
+interface PersistedGridState {
+    columns: Array<{
+        field: string;
+        currentWidth: number;
+        order: number;
+        visible: boolean;
+        pinned: 'start' | 'end' | null;
+    }>;
+    sorts: SortDef[];
+}
+declare class StatePersistenceEngine<T = unknown> {
+    private readonly state;
+    save(storageKey: string): void;
+    restore(storageKey: string): boolean;
+    clear(storageKey: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatePersistenceEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<StatePersistenceEngine<any>>;
+}
+
+interface ExportOptions {
+    filename?: string;
+    separator?: string;
+    includeHeaders?: boolean;
+    columns?: string[];
+}
+declare class ExportEngine<T = unknown> {
+    private readonly state;
+    exportCsv(data: T[], options?: ExportOptions): void;
+    exportJson(data: T[], options?: {
+        filename?: string;
+        columns?: string[];
+    }): void;
+    private escapeCsvValue;
+    private downloadFile;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExportEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ExportEngine<any>>;
+}
+
+interface TreeNodeConfig {
+    childrenField: string;
+    hasChildrenField?: string;
+    expandedByDefault?: boolean;
+}
+interface TreeDisplayRow<T = unknown> {
+    type: 'data';
+    data: T;
+    index: number;
+    depth: number;
+    hasChildren: boolean;
+    expanded: boolean;
+    nodeKey: string;
+}
+declare class TreeEngine<T = unknown> {
+    private readonly state;
+    flatten(data: T[], config: TreeNodeConfig, expandedNodes: Set<string>, idField: string): TreeDisplayRow<T>[];
+    toggleNode(nodeKey: string): void;
+    expandAll(data: T[], config: TreeNodeConfig, idField: string): void;
+    collapseAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeEngine<any>, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TreeEngine<any>>;
+}
+
+declare function trackDisplayRow<T>(_index: number, row: DisplayRow<T>): string;
+declare function trackByField(_index: number, col: {
+    field: string;
+}): string;
+
+declare class MozGridHeaderComponent {
+    protected readonly state: GridStateManager<any>;
+    protected readonly rowSelection: RowSelectionEngine<any>;
+    private readonly dragEngine;
+    protected readonly trackByField: typeof trackByField;
+    readonly headerCenter: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
+    readonly showCheckbox: _angular_core.InputSignal<boolean>;
+    readonly showExpand: _angular_core.InputSignal<boolean>;
+    readonly reorderable: _angular_core.InputSignal<boolean>;
+    readonly sortClick: _angular_core.OutputEmitterRef<{
+        field: string;
+        isMultiSort: boolean;
+    }>;
+    readonly menuAction: _angular_core.OutputEmitterRef<{
+        field: string;
+        actionId: HeaderMenuActionId;
+    }>;
+    readonly resizeStart: _angular_core.OutputEmitterRef<{
+        field: string;
+        event: MouseEvent;
+    }>;
+    readonly selectAllToggle: _angular_core.OutputEmitterRef<void>;
+    readonly columnReorder: _angular_core.OutputEmitterRef<{
+        previousIndex: number;
+        currentIndex: number;
+    }>;
+    constructor();
+    protected readonly hasLeftSection: _angular_core.Signal<boolean>;
+    protected readonly leftSectionWidth: _angular_core.Signal<number>;
+    protected readonly hasFilterRow: _angular_core.Signal<boolean>;
+    getFilterTemplate(field: string): TemplateRef<unknown> | null;
+    onSelectAllClick(event: Event): void;
+    onDragStart(event: MouseEvent, colIndex: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridHeaderComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridHeaderComponent, "moz-grid-header", never, { "showCheckbox": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; "showExpand": { "alias": "showExpand"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; }, { "sortClick": "sortClick"; "menuAction": "menuAction"; "resizeStart": "resizeStart"; "selectAllToggle": "selectAllToggle"; "columnReorder": "columnReorder"; }, never, never, true, never>;
+}
+
+declare class MozGridHeaderCellComponent<T = unknown> {
+    private readonly state;
+    readonly columnState: _angular_core.InputSignal<ColumnStateEntry>;
+    readonly def: _angular_core.InputSignal<ColumnDef<T>>;
+    readonly isLast: _angular_core.InputSignal<boolean>;
+    readonly pinnedEnd: _angular_core.InputSignal<boolean>;
+    readonly reorderable: _angular_core.InputSignal<boolean>;
+    readonly resolvedMinWidth: _angular_core.Signal<number>;
+    readonly isDragging: _angular_core.Signal<boolean>;
+    readonly sortClick: _angular_core.OutputEmitterRef<{
+        field: string;
+        isMultiSort: boolean;
+    }>;
+    readonly menuAction: _angular_core.OutputEmitterRef<{
+        field: string;
+        actionId: HeaderMenuActionId;
+    }>;
+    readonly resizeStart: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly label: _angular_core.Signal<string>;
+    readonly menuItems: _angular_core.Signal<MozActionListItem[]>;
+    onHeaderClick(event: MouseEvent): void;
+    onMenuItemClick(item: MozActionListItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridHeaderCellComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridHeaderCellComponent<any>, "moz-grid-header-cell", never, { "columnState": { "alias": "columnState"; "required": true; "isSignal": true; }; "def": { "alias": "def"; "required": true; "isSignal": true; }; "isLast": { "alias": "isLast"; "required": false; "isSignal": true; }; "pinnedEnd": { "alias": "pinnedEnd"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; }, { "sortClick": "sortClick"; "menuAction": "menuAction"; "resizeStart": "resizeStart"; }, never, never, true, never>;
+}
+
+declare class MozGridBodyComponent {
+    protected readonly state: GridStateManager<any>;
+    protected readonly engine: GridEngine<any>;
+    private readonly expandableEngine;
+    protected readonly trackDisplayRow: typeof trackDisplayRow;
+    private readonly ngZone;
+    readonly viewport: _angular_core.Signal<CdkVirtualScrollViewport | undefined>;
+    readonly showCheckbox: _angular_core.InputSignal<boolean>;
+    readonly showExpand: _angular_core.InputSignal<boolean>;
+    readonly detailTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    readonly cellEdit: _angular_core.OutputEmitterRef<CellEditEvent<unknown>>;
+    readonly cellEditCancel: _angular_core.OutputEmitterRef<CellEditCancelEvent>;
+    readonly rowSelectionToggle: _angular_core.OutputEmitterRef<void>;
+    readonly groupToggle: _angular_core.OutputEmitterRef<string>;
+    /** Viewport visible width for constraining detail rows */
+    protected readonly viewportWidth: _angular_core.WritableSignal<number>;
+    protected readonly hasLeftSection: _angular_core.Signal<boolean>;
+    protected readonly leftSectionWidth: _angular_core.Signal<number>;
+    protected readonly unpinnedColOffset: _angular_core.Signal<number>;
+    protected readonly pinnedRightColOffset: _angular_core.Signal<number>;
+    protected isRowExpanded(data: unknown): boolean;
+    constructor();
+    private attachScrollListener;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridBodyComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridBodyComponent, "moz-grid-body", never, { "showCheckbox": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; "showExpand": { "alias": "showExpand"; "required": false; "isSignal": true; }; "detailTemplate": { "alias": "detailTemplate"; "required": false; "isSignal": true; }; }, { "cellEdit": "cellEdit"; "cellEditCancel": "cellEditCancel"; "rowSelectionToggle": "rowSelectionToggle"; "groupToggle": "groupToggle"; }, never, never, true, never>;
+}
+
+declare class MozGridRowComponent<T = unknown> {
+    protected readonly state: GridStateManager<any>;
+    private readonly inlineEdit;
+    private readonly rowSelection;
+    private readonly cellSelectionEngine;
+    private readonly expandableEngine;
+    protected readonly trackByField: typeof trackByField;
+    readonly row: _angular_core.InputSignal<T>;
+    readonly rowIndex: _angular_core.InputSignal<number>;
+    readonly columns: _angular_core.InputSignal<ColumnStateEntry[]>;
+    readonly showCheckbox: _angular_core.InputSignal<boolean>;
+    readonly showExpand: _angular_core.InputSignal<boolean>;
+    readonly pinnedEnd: _angular_core.InputSignal<boolean>;
+    readonly colIndexOffset: _angular_core.InputSignal<number>;
+    readonly cellEdit: _angular_core.OutputEmitterRef<{
+        row: T;
+        rowIndex: number;
+        field: string;
+        oldValue: unknown;
+        newValue: unknown;
+    }>;
+    readonly cellEditCancel: _angular_core.OutputEmitterRef<{
+        rowIndex: number;
+        field: string;
+        originalValue: unknown;
+    }>;
+    readonly rowSelectionToggle: _angular_core.OutputEmitterRef<void>;
+    readonly isSelected: _angular_core.Signal<boolean>;
+    readonly isExpanded: _angular_core.Signal<boolean>;
+    onExpandClick(event: Event): void;
+    onCheckboxClick(event: MouseEvent): void;
+    onCommitEdit(): void;
+    onCancelEdit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridRowComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridRowComponent<any>, "moz-grid-row", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; "isSignal": true; }; "showExpand": { "alias": "showExpand"; "required": false; "isSignal": true; }; "pinnedEnd": { "alias": "pinnedEnd"; "required": false; "isSignal": true; }; "colIndexOffset": { "alias": "colIndexOffset"; "required": false; "isSignal": true; }; }, { "cellEdit": "cellEdit"; "cellEditCancel": "cellEditCancel"; "rowSelectionToggle": "rowSelectionToggle"; }, never, never, true, never>;
+}
+
+declare class MozGridCellComponent<T = unknown> {
+    private readonly state;
+    private readonly inlineEdit;
+    private readonly cellSelectionEngine;
+    private readonly elRef;
+    constructor();
+    private focusEditor;
+    readonly row: _angular_core.InputSignal<T>;
+    readonly rowIndex: _angular_core.InputSignal<number>;
+    readonly colIndex: _angular_core.InputSignal<number>;
+    readonly colState: _angular_core.InputSignal<ColumnStateEntry>;
+    readonly def: _angular_core.InputSignal<ColumnDef<T>>;
+    readonly isLast: _angular_core.InputSignal<boolean>;
+    readonly pinnedEnd: _angular_core.InputSignal<boolean>;
+    readonly resolvedMinWidth: _angular_core.Signal<number>;
+    readonly commitEdit: _angular_core.OutputEmitterRef<void>;
+    readonly cancelEdit: _angular_core.OutputEmitterRef<void>;
+    readonly cellTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown> | null>;
+    readonly editTemplate: _angular_core.Signal<_angular_core.TemplateRef<unknown> | null>;
+    readonly updateDraftFn: (value: unknown) => void;
+    readonly commitEditFn: () => void;
+    readonly value: _angular_core.Signal<unknown>;
+    readonly displayValue: _angular_core.Signal<string>;
+    readonly editState: _angular_core.Signal<_mozaic_ds_angular.CellEditState>;
+    readonly isEditing: _angular_core.Signal<boolean>;
+    readonly editorType: _angular_core.Signal<CellEditorType>;
+    readonly isFocused: _angular_core.Signal<boolean>;
+    readonly isInRange: _angular_core.Signal<boolean>;
+    onCellClick(event: MouseEvent): void;
+    onMouseDown(event: MouseEvent): void;
+    onMouseEnter(): void;
+    onDoubleClick(): void;
+    onEditorInput(event: Event): void;
+    onSelectChange(event: Event): void;
+    onCheckboxChange(event: Event): void;
+    onDateChange(value: string | null): void;
+    onFillHandleMouseDown(event: MouseEvent): void;
+    onEditorBlur(event: FocusEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridCellComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridCellComponent<any>, "moz-grid-cell", never, { "row": { "alias": "row"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; "colIndex": { "alias": "colIndex"; "required": true; "isSignal": true; }; "colState": { "alias": "colState"; "required": true; "isSignal": true; }; "def": { "alias": "def"; "required": true; "isSignal": true; }; "isLast": { "alias": "isLast"; "required": false; "isSignal": true; }; "pinnedEnd": { "alias": "pinnedEnd"; "required": false; "isSignal": true; }; }, { "commitEdit": "commitEdit"; "cancelEdit": "cancelEdit"; }, never, never, true, never>;
+}
+
+declare class MozGridFooterComponent {
+    protected readonly state: GridStateManager<any>;
+    protected readonly engine: GridEngine<any>;
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    readonly pageChange: _angular_core.OutputEmitterRef<PageEvent>;
+    readonly currentPageSizeStr: _angular_core.Signal<string>;
+    readonly pageSizeSelectOptions: _angular_core.Signal<{
+        text: string;
+        value: string;
+    }[]>;
+    readonly paginationOptions: _angular_core.Signal<{
+        text: string;
+        value: number;
+    }[]>;
+    readonly rangeLabel: _angular_core.Signal<string>;
+    onPageChange(newPageIndex: number): void;
+    onPageSizeChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridFooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridFooterComponent, "moz-grid-footer", never, { "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+declare class MozGridGroupRowComponent<T = unknown> {
+    protected readonly state: GridStateManager<any>;
+    readonly groupRow: _angular_core.InputSignal<GroupRow<T>>;
+    readonly toggleExpand: _angular_core.OutputEmitterRef<string>;
+    readonly fieldLabel: _angular_core.Signal<string>;
+    readonly groupValue: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridGroupRowComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridGroupRowComponent<any>, "moz-grid-group-row", never, { "groupRow": { "alias": "groupRow"; "required": true; "isSignal": true; }; }, { "toggleExpand": "toggleExpand"; }, never, never, true, never>;
+}
+
+declare class MozGridDetailRowComponent<T = unknown> {
+    readonly data: _angular_core.InputSignal<T>;
+    readonly rowIndex: _angular_core.InputSignal<number>;
+    readonly detailTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridDetailRowComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridDetailRowComponent<any>, "moz-grid-detail-row", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "rowIndex": { "alias": "rowIndex"; "required": true; "isSignal": true; }; "detailTemplate": { "alias": "detailTemplate"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MozGridColumnVisibilityPanelComponent {
+    private readonly state;
+    readonly restoreColumn: _angular_core.OutputEmitterRef<string>;
+    readonly restoreAll: _angular_core.OutputEmitterRef<void>;
+    readonly hiddenColumns: _angular_core.Signal<{
+        field: string;
+        label: string;
+    }[]>;
+    onRestore(field: string): void;
+    onRestoreAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridColumnVisibilityPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridColumnVisibilityPanelComponent, "moz-grid-column-visibility-panel", never, {}, { "restoreColumn": "restoreColumn"; "restoreAll": "restoreAll"; }, never, never, true, never>;
+}
+
+declare class MozGridHeaderMenuComponent {
+    private readonly state;
+    readonly field: _angular_core.InputSignal<string>;
+    readonly isOpen: _angular_core.InputSignal<boolean>;
+    readonly actionClick: _angular_core.OutputEmitterRef<{
+        field: string;
+        actionId: HeaderMenuActionId;
+    }>;
+    readonly close: _angular_core.OutputEmitterRef<void>;
+    readonly menuItems: _angular_core.Signal<MozActionListItem[]>;
+    onItemClick(item: MozActionListItem): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MozGridHeaderMenuComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MozGridHeaderMenuComponent, "moz-grid-header-menu", never, { "field": { "alias": "field"; "required": true; "isSignal": true; }; "isOpen": { "alias": "isOpen"; "required": false; "isSignal": true; }; }, { "actionClick": "actionClick"; "close": "close"; }, never, never, true, never>;
+}
+
+type SettingsScreen = 'main' | 'density' | 'columns';
+interface DraftColumn {
+    field: string;
+    headerName: string;
+    visible: boolean;
+}
+declare class GridSettingsDrawerComponent {
+    private readonly drawerRef;
+    private readonly data;
+    readonly screen: _angular_core.WritableSignal<SettingsScreen>;
+    readonly draftDensity: _angular_core.WritableSignal<GridDensity>;
+    readonly draftColumns: _angular_core.WritableSignal<DraftColumn[]>;
+    readonly searchQuery: _angular_core.WritableSignal<string>;
+    readonly densityOptions: {
+        text: string;
+        value: string;
+    }[];
+    readonly densityLabel: _angular_core.Signal<string>;
+    readonly columnsLabel: _angular_core.Signal<string>;
+    readonly filteredColumns: _angular_core.Signal<DraftColumn[]>;
+    private readonly defaultColumns;
+    constructor();
+    goTo(screen: SettingsScreen): void;
+    onColumnToggle(field: string, checked: boolean): void;
+    onColumnDrop(event: CdkDragDrop<DraftColumn[]>): void;
+    onSearchInput(event: Event): void;
+    hideAll(): void;
+    showAll(): void;
+    apply(): void;
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridSettingsDrawerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridSettingsDrawerComponent, "moz-grid-settings-drawer", never, {}, {}, never, never, true, never>;
+}
+
+interface DraftGroupItem {
+    field: string;
+    headerName: string;
+    sortDirection: 'asc' | 'desc';
+}
+declare class GridGroupDrawerComponent {
+    private readonly drawerRef;
+    private readonly data;
+    readonly draftGrouped: _angular_core.WritableSignal<DraftGroupItem[]>;
+    private readonly allAvailable;
+    readonly available: _angular_core.Signal<{
+        field: string;
+        headerName: string;
+    }[]>;
+    onDrop(event: CdkDragDrop<DraftGroupItem[]>): void;
+    onSortDirectionChange(index: number, event: Event): void;
+    addGroup(field: string): void;
+    removeGroup(field: string): void;
+    apply(): void;
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridGroupDrawerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridGroupDrawerComponent, "moz-grid-group-drawer", never, {}, {}, never, never, true, never>;
+}
+
 /**
  * McCombobox — Data models & type guards
  *
@@ -2430,5 +3569,5 @@ declare class McComboboxHarness extends ComponentHarness {
     getSelectedCount(): Promise<number>;
 }
 
-export { ACTION_LISTBOX_CONFIG, ActionListboxContainerComponent, ActionListboxRef, BuiltInMenuComponent, DEFAULT_ACTION_LISTBOX_CONFIG, DEFAULT_MODAL_CONFIG, DEFAULT_TOASTER_CONFIG, DRAWER_CONFIG, DRAWER_DATA, DrawerContainerComponent, MODAL_CONFIG, MODAL_DATA, McComboboxComponent, McComboboxHarness, McComboboxOptionHarness, MozAccordionComponent, MozAccordionContentComponent, MozAccordionHeaderComponent, MozAccordionPanelComponent, MozActionBottomBarComponent, MozActionListboxComponent, MozActionListboxTriggerDirective, MozAvatarComponent, MozBreadcrumbComponent, MozButtonComponent, MozCalloutComponent, MozCarouselComponent, MozCheckListMenuComponent, MozCheckboxComponent, MozCheckboxGroupComponent, MozCircularProgressBarComponent, MozDatepickerComponent, MozDividerComponent, MozDrawerComponent, MozDrawerFooterDirective, MozDrawerRef, MozDrawerService, MozFieldComponent, MozFieldGroupComponent, MozFileUploaderComponent, MozFileUploaderItemComponent, MozFlagComponent, MozIconButtonComponent, MozKpiComponent, MozLinearProgressBarBufferComponent, MozLinearProgressBarPercentageComponent, MozLinkComponent, MozLoaderComponent, MozLoadingOverlayComponent, MozModalComponent, MozModalFooterDirective, MozModalRef, MozModalService, MozNavigationIndicatorComponent, MozNumberBadgeComponent, MozOverlayComponent, MozPageHeaderComponent, MozPaginationComponent, MozPasswordInputDirective, MozPhoneNumberComponent, MozPincodeInputComponent, MozPopoverComponent, MozPopoverFooterDirective, MozPopoverTriggerDirective, MozQuantitySelectorComponent, MozRadioComponent, MozRadioGroupComponent, MozSegmentedControlComponent, MozSelectComponent, MozSidebarComponent, MozStarRatingComponent, MozStatusBadgeComponent, MozStatusDotComponent, MozStatusMessageComponent, MozStatusNotificationComponent, MozStepperBottomBarComponent, MozStepperCompactComponent, MozStepperInlineComponent, MozStepperStackedComponent, MozTabComponent, MozTabsComponent, MozTagComponent, MozTextInput, MozTextarea, MozTileComponent, MozTileExpandableComponent, MozTileSelectableComponent, MozToasterComponent, MozToasterRef, MozToasterService, MozToggleComponent, MozTooltipComponent, MozTooltipDirective, POPOVER_CONFIG, POPOVER_DATA, PopoverContainerComponent, PopoverRef, PopoverService, TOASTER_CONFIG, isSection };
-export type { ActionListboxConfig, ActionListboxPosition, McComboboxItem, McComboboxOption, McComboboxSection, McComboboxSize, MozActionListItem, MozActionListItemAppearance, MozAvatarSize, MozBreadcrumbAppearance, MozBreadcrumbLink, MozBuiltInMenuItem, MozBuiltInMenuItemTarget, MozButtonAppearance, MozButtonIconPosition, MozButtonSize, MozButtonType, MozCalloutVariant, MozCheckListMenuItem, MozCircularProgessBarSize, MozDatepickerSize, MozDividerAppearance, MozDividerOrientation, MozDividerSize, MozDrawerConfig, MozDrawerPosition, MozFileUploaderFormat, MozFileUploaderItemFormat, MozFlagType, MozIconButtonAppearance, MozIconButtonSize, MozIconButtonType, MozKpiSize, MozKpiStatus, MozKpiTrend, MozLinearProgressBarBufferSize, MozLinkAppearance, MozLinkIconPosition, MozLinkSize, MozLoaderAppearance, MozLoaderSize, MozNavigationIndicatorAction, MozNumberBadgeAppearance, MozNumberBadgeSize, MozPageHeaderScope, MozPhoneNumberCountry, MozPhoneNumberSize, MozPhoneNumberValue, MozPincodeLength, MozPopoverAppearance, MozPopoverPosition, MozPopoverSize, MozQuantitySelectorSize, MozSegmentedControlSize, MozSegmentedItem, MozSelectOption, MozSelectSize, MozSelectValue, MozSidebarItem, MozSidebarSubItem, MozStarRatingAppearance, MozStarRatingSize, MozStatusBadgeStatus, MozStatusDotSize, MozStatusDotStatus, MozStatusMessageStatus, MozStatusNotificationStatus, MozStepperBottomBarStep, MozStepperInlineStep, MozStepperStackedStep, MozTabItem, MozTagSize, MozTagType, MozTextInputSize, MozTileAppearance, MozTileExpandableTrigger, MozTileInputPosition, MozTileInputVerticalPosition, MozTileSelectableAppearance, MozTileSelectableType, MozToasterPosition, MozToasterRole, MozToasterStatus, MozToggleSize, MozTooltipPosition, PopoverConfig };
+export { ACTION_LISTBOX_CONFIG, ActionListboxContainerComponent, ActionListboxRef, BuiltInMenuComponent, CellSelectionEngine, ColumnReorderEngine, ColumnResizeEngine, DEFAULT_ACTION_LISTBOX_CONFIG, DEFAULT_GRID_OPTIONS, DEFAULT_MODAL_CONFIG, DEFAULT_TOASTER_CONFIG, DRAWER_CONFIG, DRAWER_DATA, DrawerContainerComponent, ExpandableRowEngine, ExportEngine, FilterEngine, GridEngine, GridGroupDrawerComponent, GridSettingsDrawerComponent, GridStateManager, GroupEngine, InlineEditEngine, KeyboardEngine, MODAL_CONFIG, MODAL_DATA, McComboboxComponent, McComboboxHarness, McComboboxOptionHarness, MozAccordionComponent, MozAccordionContentComponent, MozAccordionHeaderComponent, MozAccordionPanelComponent, MozActionBottomBarComponent, MozActionListboxComponent, MozActionListboxTriggerDirective, MozAvatarComponent, MozBreadcrumbComponent, MozButtonComponent, MozCalloutComponent, MozCarouselComponent, MozCheckListMenuComponent, MozCheckboxComponent, MozCheckboxGroupComponent, MozCircularProgressBarComponent, MozDatepickerComponent, MozDividerComponent, MozDrawerComponent, MozDrawerFooterDirective, MozDrawerRef, MozDrawerService, MozFieldComponent, MozFieldGroupComponent, MozFileUploaderComponent, MozFileUploaderItemComponent, MozFlagComponent, MozGridBodyComponent, MozGridCellComponent, MozGridColumnDef, MozGridColumnVisibilityPanelComponent, MozGridComponent, MozGridDetailRowComponent, MozGridFooterComponent, MozGridGroupRowComponent, MozGridHeaderCellComponent, MozGridHeaderComponent, MozGridHeaderMenuComponent, MozGridRowComponent, MozGridToolbarDef, MozIconButtonComponent, MozKpiComponent, MozLinearProgressBarBufferComponent, MozLinearProgressBarPercentageComponent, MozLinkComponent, MozLoaderComponent, MozLoadingOverlayComponent, MozModalComponent, MozModalFooterDirective, MozModalRef, MozModalService, MozNavigationIndicatorComponent, MozNumberBadgeComponent, MozOverlayComponent, MozPageHeaderComponent, MozPaginationComponent, MozPasswordInputDirective, MozPhoneNumberComponent, MozPincodeInputComponent, MozPopoverComponent, MozPopoverFooterDirective, MozPopoverTriggerDirective, MozQuantitySelectorComponent, MozRadioComponent, MozRadioGroupComponent, MozSegmentedControlComponent, MozSelectComponent, MozSidebarComponent, MozStarRatingComponent, MozStatusBadgeComponent, MozStatusDotComponent, MozStatusMessageComponent, MozStatusNotificationComponent, MozStepperBottomBarComponent, MozStepperCompactComponent, MozStepperInlineComponent, MozStepperStackedComponent, MozTabComponent, MozTabsComponent, MozTagComponent, MozTextInput, MozTextarea, MozTileComponent, MozTileExpandableComponent, MozTileSelectableComponent, MozToasterComponent, MozToasterRef, MozToasterService, MozToggleComponent, MozTooltipComponent, MozTooltipDirective, POPOVER_CONFIG, POPOVER_DATA, PopoverContainerComponent, PopoverRef, PopoverService, RowSelectionEngine, SortEngine, StatePersistenceEngine, TOASTER_CONFIG, TreeEngine, isSection, trackByField, trackDisplayRow };
+export type { ActionListboxConfig, ActionListboxPosition, ActiveFilter, BulkCopyEvent, BulkDeleteEvent, BulkEditEvent, BulkPasteEvent, CellCoord, CellEditCancelEvent, CellEditEvent, CellEditState, CellEditorType, CellRange, CellSelectionEvent, ColumnDef, ColumnFreezeEvent, ColumnReorderEvent, ColumnResizeEvent, ColumnSearchToggleEvent, ColumnStateEntry, ColumnVisibilityEvent, DisplayRow, ExportOptions, FilterDef, FilterEvent, GridDensity, GridEventMap, GridEventType, GridOptions, GridPlugin, GridSettingsData, GridSettingsResult, GridToolbarSlot, GroupDrawerData, GroupDrawerResult, GroupEntry, GroupEvent, GroupRow, HeaderMenuActionId, HeaderMenuConfig, McComboboxItem, McComboboxOption, McComboboxSection, McComboboxSize, MozActionListItem, MozActionListItemAppearance, MozAvatarSize, MozBreadcrumbAppearance, MozBreadcrumbLink, MozBuiltInMenuItem, MozBuiltInMenuItemTarget, MozButtonAppearance, MozButtonIconPosition, MozButtonSize, MozButtonType, MozCalloutVariant, MozCheckListMenuItem, MozCircularProgessBarSize, MozDatepickerSize, MozDividerAppearance, MozDividerOrientation, MozDividerSize, MozDrawerConfig, MozDrawerPosition, MozFileUploaderFormat, MozFileUploaderItemFormat, MozFlagType, MozIconButtonAppearance, MozIconButtonSize, MozIconButtonType, MozKpiSize, MozKpiStatus, MozKpiTrend, MozLinearProgressBarBufferSize, MozLinkAppearance, MozLinkIconPosition, MozLinkSize, MozLoaderAppearance, MozLoaderSize, MozNavigationIndicatorAction, MozNumberBadgeAppearance, MozNumberBadgeSize, MozPageHeaderScope, MozPhoneNumberCountry, MozPhoneNumberSize, MozPhoneNumberValue, MozPincodeLength, MozPopoverAppearance, MozPopoverPosition, MozPopoverSize, MozQuantitySelectorSize, MozSegmentedControlSize, MozSegmentedItem, MozSelectOption, MozSelectSize, MozSelectValue, MozSidebarItem, MozSidebarSubItem, MozStarRatingAppearance, MozStarRatingSize, MozStatusBadgeStatus, MozStatusDotSize, MozStatusDotStatus, MozStatusMessageStatus, MozStatusNotificationStatus, MozStepperBottomBarStep, MozStepperInlineStep, MozStepperStackedStep, MozTabItem, MozTagSize, MozTagType, MozTextInputSize, MozTileAppearance, MozTileExpandableTrigger, MozTileInputPosition, MozTileInputVerticalPosition, MozTileSelectableAppearance, MozTileSelectableType, MozToasterPosition, MozToasterRole, MozToasterStatus, MozToggleSize, MozTooltipPosition, PageEvent, PaginationState, PersistedGridState, PopoverConfig, RowSelectionEvent, SelectAllMode, SortDef, SortDirection, SortEvent, TreeDisplayRow, TreeNodeConfig };