@nanahoshi/mona-ui 0.1.0

package/types/nanahoshi-mona-ui-grid.d.ts

@@ -0,0 +1,1114 @@
+import { DataType, PreventableEvent, VirtualScrollOptions } from '@nanahoshi/mona-ui/common';
+import { FieldTree, SchemaOrSchemaFn, ValidationError } from '@angular/forms/signals';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, WritableSignal, OnInit, ElementRef } from '@angular/core';
+import { SortDirection, CompositeFilterDescriptor, SortDescriptor, FilterLogic, FilterOperators } from '@nanahoshi/mona-ui/query';
+import { Selector, ImmutableDictionary, ImmutableList, ImmutableSet } from '@mirei/ts-collections';
+import * as _nanahoshi_mona_ui_grid from '@nanahoshi/mona-ui/grid';
+import { CdkDropList, CdkDragEnter, CdkDragStart, CdkDragDrop } from '@angular/cdk/drag-drop';
+import { PageChangeEvent, PageSizeChangeEvent } from '@nanahoshi/mona-ui/pager';
+import { FilterMenuValue } from '@nanahoshi/mona-ui/filter';
+import * as rxjs from 'rxjs';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { PopupMenuItem } from '@nanahoshi/mona-ui/popup-menu';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { ThemeStyle } from '@nanahoshi/mona-ui/theme';
+import { VariantInputs } from '@nanahoshi/mona-ui/internal';
+
+type AggregateFunction = "sum" | "avg" | "count" | "min" | "max" | "custom";
+
+type GridColumnLockedPosition = "left" | "right";
+
+type ColumnKind = "command" | "data";
+type ColumnFormat = string | ((column: Column) => string);
+interface ColumnConfig {
+    readonly aggregate: AggregateFunction | null;
+    readonly cellTemplate: TemplateRef<unknown> | null;
+    readonly commandTemplate: TemplateRef<unknown> | null;
+    readonly dataType: DataType;
+    readonly editTemplate: TemplateRef<unknown> | null;
+    readonly editable: boolean;
+    readonly field: string;
+    readonly format: ColumnFormat | null;
+    readonly footerTemplate: TemplateRef<unknown> | null;
+    readonly groupFooterTemplate: TemplateRef<unknown> | null;
+    readonly headerTemplate: TemplateRef<unknown> | null;
+    readonly hidden: boolean;
+    readonly id: string;
+    readonly kind: ColumnKind;
+    readonly locked: boolean;
+    readonly lockedPosition: GridColumnLockedPosition;
+    readonly maxWidth: number | null;
+    readonly minWidth: number | null;
+    readonly removeConfirmation: boolean;
+    readonly stateKey: string | null;
+    readonly title: string;
+    readonly titleTemplate: TemplateRef<unknown> | null;
+    readonly width: number | null;
+}
+interface Column extends ColumnConfig {
+    readonly calculatedWidth: number | null;
+    readonly columnSortDirection: SortDirection | null;
+    readonly configuredHidden: boolean;
+    readonly filtered: boolean;
+    readonly groupSortDirection: SortDirection | null;
+    readonly hidden: boolean;
+    readonly index: number;
+    readonly sortIndex: number | null;
+}
+
+type GridEditOperation = "create" | "update";
+
+declare class Row {
+    readonly data: Record<PropertyKey, unknown>;
+    readonly uid: string;
+    constructor(data: Record<PropertyKey, unknown>, uid?: string);
+}
+
+interface GridEditSession {
+    readonly column: Column | null;
+    readonly field: string | null;
+    readonly form: FieldTree<Record<PropertyKey, unknown>>;
+    readonly isNew: boolean;
+    readonly mode: "cell" | "row";
+    readonly model: WritableSignal<Record<PropertyKey, unknown>>;
+    readonly operation: GridEditOperation;
+    readonly originalRowData: Record<PropertyKey, unknown> | null;
+    readonly row: Row | null;
+    readonly rowUid: string | null;
+}
+
+declare class CellEditEvent extends PreventableEvent {
+    #private;
+    constructor(options: CellEditEventOptions);
+    get field(): string;
+    get newValue(): unknown;
+    get oldValue(): unknown;
+    get rowData(): Record<PropertyKey, unknown>;
+    get session(): GridEditSession;
+}
+interface CellEditEventOptions {
+    field: string;
+    newValue: unknown;
+    oldValue: unknown;
+    rowData: Record<PropertyKey, unknown>;
+    session: GridEditSession;
+}
+
+declare class RowEditEvent extends PreventableEvent {
+    #private;
+    constructor(options: RowEditEventOptions);
+    get rowData(): Record<PropertyKey, unknown>;
+    get originalRowData(): Record<PropertyKey, unknown> | null;
+    get session(): GridEditSession;
+}
+interface RowEditEventOptions {
+    originalRowData?: Record<PropertyKey, unknown> | null;
+    rowData: Record<PropertyKey, unknown>;
+    session: GridEditSession;
+}
+
+declare class GridAddEvent extends PreventableEvent {
+    #private;
+    constructor(options: GridAddEventOptions);
+    get rowData(): Record<PropertyKey, unknown>;
+    get session(): GridEditSession;
+}
+interface GridAddEventOptions {
+    originalEvent?: Event;
+    rowData: Record<PropertyKey, unknown>;
+    session: GridEditSession;
+}
+
+type GridSaveOperation = GridEditOperation;
+declare class GridSaveEvent extends PreventableEvent {
+    #private;
+    constructor(options: GridSaveEventOptions);
+    get operation(): GridSaveOperation;
+    get originalRowData(): Record<PropertyKey, unknown> | null;
+    get rowData(): Record<PropertyKey, unknown>;
+    get session(): GridEditSession;
+}
+interface GridSaveEventOptions {
+    operation: GridSaveOperation;
+    originalEvent?: Event;
+    originalRowData?: Record<PropertyKey, unknown> | null;
+    rowData: Record<PropertyKey, unknown>;
+    session: GridEditSession;
+}
+
+declare class GridCancelEvent extends PreventableEvent {
+    #private;
+    constructor(options: GridCancelEventOptions);
+    get operation(): GridSaveOperation;
+    get rowData(): Record<PropertyKey, unknown>;
+    get session(): GridEditSession;
+}
+interface GridCancelEventOptions {
+    operation: GridSaveOperation;
+    originalEvent?: Event;
+    rowData: Record<PropertyKey, unknown>;
+    session: GridEditSession;
+}
+
+interface GridEditFormContext {
+    readonly column: Column | null;
+    readonly field: string | null;
+    readonly isNew: boolean;
+    readonly mode: "cell" | "row";
+    readonly operation: GridEditOperation;
+    readonly originalRowData: Record<PropertyKey, unknown> | null;
+    readonly rowData: Record<PropertyKey, unknown>;
+}
+type GridEditSchemaFactory = (context: GridEditFormContext) => SchemaOrSchemaFn<Record<PropertyKey, unknown>> | null | undefined;
+
+declare class GridEditEvent extends PreventableEvent {
+    #private;
+    constructor(options: GridEditEventOptions);
+    get rowData(): Record<PropertyKey, unknown>;
+    get session(): GridEditSession;
+}
+interface GridEditEventOptions {
+    originalEvent?: Event;
+    rowData: Record<PropertyKey, unknown>;
+    session: GridEditSession;
+}
+
+interface GridEditTemplateContext {
+    readonly cancel: () => void;
+    readonly column: string;
+    readonly commit: () => void;
+    readonly dataField: string;
+    readonly dataItem: Record<PropertyKey, unknown>;
+    readonly errors: readonly ValidationError.WithFieldTree[];
+    readonly field: FieldTree<unknown>;
+    readonly form: GridEditSession["form"];
+    readonly invalid: boolean;
+    readonly isNew: boolean;
+    readonly session: GridEditSession;
+    readonly setValue: (value: unknown) => void;
+    readonly touched: boolean;
+    readonly value: unknown;
+}
+
+declare class GridRemoveEvent extends PreventableEvent {
+    #private;
+    constructor(options: GridRemoveEventOptions);
+    get rowData(): Record<PropertyKey, unknown>;
+}
+interface GridRemoveEventOptions {
+    originalEvent?: Event;
+    rowData: Record<PropertyKey, unknown>;
+}
+
+interface SelectableOptions {
+    enabled?: boolean;
+    mode?: "single" | "multiple";
+}
+
+interface GroupDescriptor {
+    field: string;
+    dir?: SortDirection;
+}
+
+interface GroupableOptions {
+    enabled: boolean;
+    showFooter: boolean;
+}
+
+interface FilterableOptions {
+    enabled: boolean;
+    type: "menu" | "row" | "menu, row";
+}
+
+interface SortableOptions {
+    allowUnsort?: boolean;
+    enabled?: boolean;
+    mode?: "single" | "multiple";
+    showIndices?: boolean;
+}
+
+declare class GridCellTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridCellTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridCellTemplateDirective, "ng-template[monaGridCellTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridAddCommandDirective {
+    #private;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridAddCommandDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridAddCommandDirective, "button[monaGridAddCommand]", never, {}, {}, never, never, true, never>;
+}
+declare class GridEditCommandDirective {
+    #private;
+    readonly row: _angular_core.InputSignal<Row | null>;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridEditCommandDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridEditCommandDirective, "button[monaGridEditCommand]", never, { "row": { "alias": "monaGridEditCommand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class GridRemoveCommandDirective {
+    #private;
+    readonly row: _angular_core.InputSignal<Row | null>;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridRemoveCommandDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridRemoveCommandDirective, "button[monaGridRemoveCommand]", never, { "row": { "alias": "monaGridRemoveCommand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare class GridSaveCommandDirective {
+    #private;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridSaveCommandDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridSaveCommandDirective, "button[monaGridSaveCommand]", never, {}, {}, never, never, true, never>;
+}
+declare class GridCancelCommandDirective {
+    #private;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridCancelCommandDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridCancelCommandDirective, "button[monaGridCancelCommand]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridColumnTitleTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridColumnTitleTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridColumnTitleTemplateDirective, "[monaGridColumnTitleTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridContextMenuDirective {
+    #private;
+    private readonly menuItemComponents;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridContextMenuDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridContextMenuDirective, "[monaGridContextMenu]", never, {}, {}, ["menuItemComponents"], never, true, never>;
+}
+
+declare class GridDetailTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridDetailTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridDetailTemplateDirective, "ng-template[monaGridDetailTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridEditTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridEditTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridEditTemplateDirective, "ng-template[monaGridEditTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+interface EditableOptions {
+    enabled?: boolean;
+    mode: "cell" | "row";
+    schema?: GridEditSchemaFactory;
+}
+
+type GridKeySelector<TData, TKey = unknown> = string | Selector<TData, TKey> | null;
+
+declare class GridEditableDirective {
+    #private;
+    /**
+     * @description Emitted before the grid displays the new-row editor.
+     */
+    readonly add: _angular_core.OutputEmitterRef<GridAddEvent>;
+    /**
+     * @description Emitted before an edit operation is canceled.
+     */
+    readonly cancel: _angular_core.OutputEmitterRef<GridCancelEvent>;
+    /**
+     * @description Emitted when a cell is edited.
+     */
+    readonly cellEdit: _angular_core.OutputEmitterRef<CellEditEvent>;
+    /**
+     * @description Emitted before a row enters edit mode.
+     */
+    readonly edit: _angular_core.OutputEmitterRef<GridEditEvent>;
+    /**
+     * @description Creates the initial data object used by the add-row editor.
+     */
+    readonly newRowFactory: _angular_core.InputSignal<() => Record<PropertyKey, unknown>>;
+    readonly options: _angular_core.InputSignal<"" | EditableOptions>;
+    /**
+     * @description Emitted when a row remove command is triggered.
+     */
+    readonly remove: _angular_core.OutputEmitterRef<GridRemoveEvent>;
+    /**
+     * @description Emitted when a row edit is committed (row mode only).
+     */
+    readonly rowEdit: _angular_core.OutputEmitterRef<RowEditEvent>;
+    /**
+     * @description Field name or selector used to keep edited row identity stable when data is rebound.
+     */
+    readonly rowKey: _angular_core.InputSignal<GridKeySelector<unknown>>;
+    /**
+     * @description Emitted before an edited or new row is saved.
+     */
+    readonly save: _angular_core.OutputEmitterRef<GridSaveEvent>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridEditableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridEditableDirective, "mona-grid[monaGridEditable]", never, { "newRowFactory": { "alias": "newRowFactory"; "required": false; "isSignal": true; }; "options": { "alias": "monaGridEditable"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; }, { "add": "add"; "cancel": "cancel"; "cellEdit": "cellEdit"; "edit": "edit"; "remove": "remove"; "rowEdit": "rowEdit"; "save": "save"; }, never, never, true, never>;
+}
+
+declare class GridFilterableDirective {
+    #private;
+    /**
+     * @description Current filter descriptors applied to the grid.
+     * @default []
+     */
+    readonly filter: _angular_core.ModelSignal<CompositeFilterDescriptor[]>;
+    /**
+     * @description Enables column filtering on the grid. Pass a `FilterableOptions` object to configure whether filters render in the header menu, a filter row, or both.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | FilterableOptions>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridFilterableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridFilterableDirective, "mona-grid[monaGridFilterable]", never, { "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "options": { "alias": "monaGridFilterable"; "required": false; "isSignal": true; }; }, { "filter": "filterChange"; }, never, never, true, never>;
+}
+
+declare class GridFooterTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridFooterTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridFooterTemplateDirective, "ng-template[monaGridFooterTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridGroupableDirective implements OnInit {
+    #private;
+    /**
+     * @description Emitted when the applied group descriptors change, whether from dragging a column into the group panel or from a group sort change.
+     */
+    readonly groupChange: _angular_core.OutputEmitterRef<GroupDescriptor[]>;
+    /**
+     * @description Current group descriptors applied to the grid.
+     * @default []
+     */
+    group: _angular_core.InputSignal<Iterable<GroupDescriptor>>;
+    /**
+     * @description Enables column grouping on the grid. Pass a `GroupableOptions` object to configure group footer display.
+     */
+    options: _angular_core.InputSignal<"" | GroupableOptions | undefined>;
+    constructor();
+    ngOnInit(): void;
+    private setSubscriptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridGroupableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridGroupableDirective, "mona-grid[monaGridGroupable]", never, { "group": { "alias": "group"; "required": false; "isSignal": true; }; "options": { "alias": "monaGridGroupable"; "required": false; "isSignal": true; }; }, { "groupChange": "groupChange"; }, never, never, true, never>;
+}
+
+declare class GridGroupFooterTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridGroupFooterTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridGroupFooterTemplateDirective, "ng-template[monaGridGroupFooterTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridHeaderTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridHeaderTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridHeaderTemplateDirective, "ng-template[monaGridHeaderTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridNoDataTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridNoDataTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridNoDataTemplateDirective, "ng-template[monaGridNoDataTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class ColumnReorderEvent extends PreventableEvent {
+    #private;
+    constructor(column: Column, oldIndex: number, newIndex: number);
+    get column(): Column;
+    get newIndex(): number;
+    get oldIndex(): number;
+}
+
+interface ReorderableOptions {
+    enabled: boolean;
+}
+
+declare class GridReorderableDirective {
+    #private;
+    /**
+     * @description Emitted when a column is dropped into a new position. Call `preventDefault()` on the event to cancel the reorder.
+     */
+    readonly columnReorder: _angular_core.OutputEmitterRef<ColumnReorderEvent>;
+    /**
+     * @description Enables column reordering via drag and drop. Pass a `ReorderableOptions` object to configure it explicitly.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | ReorderableOptions>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridReorderableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridReorderableDirective, "mona-grid[monaGridReorderable]", never, { "options": { "alias": "monaGridReorderable"; "required": false; "isSignal": true; }; }, { "columnReorder": "columnReorder"; }, never, never, true, never>;
+}
+
+interface ColumnResizeEvent {
+    column: Column;
+    newWidth: number;
+    oldWidth: number;
+}
+
+interface ResizableOptions {
+    enabled: boolean;
+}
+
+declare class GridResizableDirective {
+    #private;
+    /**
+     * @description Emitted when a column resize completes, with the column and its old and new widths.
+     */
+    readonly columnResize: _angular_core.OutputEmitterRef<ColumnResizeEvent>;
+    /**
+     * @description Enables column resizing on the grid. Pass a `ResizableOptions` object to configure it explicitly.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | ResizableOptions>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridResizableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridResizableDirective, "mona-grid[monaGridResizable]", never, { "options": { "alias": "monaGridResizable"; "required": false; "isSignal": true; }; }, { "columnResize": "columnResize"; }, never, never, true, never>;
+}
+
+declare class GridSelectableDirective {
+    #private;
+    /**
+     * @description Enables row selection on the grid. Pass a `GridSelectableOptions` object to configure single or multiple selection mode.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | SelectableOptions>;
+    /**
+     * @description Field name or selector used to derive a row's selection key.
+     * @default ""
+     */
+    readonly selectBy: _angular_core.InputSignal<string>;
+    /**
+     * @description Currently selected row keys.
+     * @default []
+     */
+    readonly selectedKeys: _angular_core.InputSignal<Iterable<unknown>>;
+    /**
+     * @description Emitted when the set of selected row keys changes.
+     */
+    readonly selectedKeysChange: _angular_core.OutputEmitterRef<unknown[]>;
+    constructor();
+    private setSubscriptions;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridSelectableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridSelectableDirective, "mona-grid[monaGridSelectable]", never, { "options": { "alias": "monaGridSelectable"; "required": false; "isSignal": true; }; "selectBy": { "alias": "selectBy"; "required": false; "isSignal": true; }; "selectedKeys": { "alias": "selectedKeys"; "required": false; "isSignal": true; }; }, { "selectedKeysChange": "selectedKeysChange"; }, never, never, true, never>;
+}
+
+declare class ColumnSortEvent extends PreventableEvent {
+    #private;
+    constructor(column: Column);
+    get column(): Column;
+}
+
+declare class GridSortableDirective {
+    #private;
+    private readonly columnDefinitions;
+    /**
+     * @description Emitted when a column header is activated to change its sort direction. Call `preventDefault()` on the event to cancel the sort.
+     */
+    readonly columnSort: _angular_core.OutputEmitterRef<ColumnSortEvent>;
+    /**
+     * @description Enables column sorting on the grid. Pass a `SortableOptions` object to configure sort mode, unsort behavior, or sort-index display.
+     * @default ""
+     */
+    readonly options: _angular_core.InputSignal<"" | SortableOptions>;
+    /**
+     * @description Current sort descriptors applied to the grid.
+     * @default []
+     */
+    readonly sort: _angular_core.ModelSignal<SortDescriptor<any>[]>;
+    constructor();
+    private applyColumnSort;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridSortableDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridSortableDirective, "mona-grid[monaGridSortable]", never, { "options": { "alias": "monaGridSortable"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; }, { "columnSort": "columnSort"; "sort": "sortChange"; }, ["columnDefinitions"], never, true, never>;
+}
+
+type GridStateVersion = 1;
+type GridStateFilterValue = boolean | number | string | null | readonly (boolean | number | string | null)[];
+interface GridStateFilterDescriptor {
+    field: string;
+    operator: Exclude<FilterOperators, "function">;
+    value?: GridStateFilterValue;
+}
+interface GridStateCompositeFilterDescriptor {
+    logic: FilterLogic;
+    filters: readonly (GridStateFilterDescriptor | GridStateCompositeFilterDescriptor)[];
+}
+interface GridStateSortDescriptor {
+    dir: SortDirection;
+    field: string;
+}
+interface GridColumnState {
+    hidden: boolean;
+    id: string;
+    order: number;
+    width: number | null;
+}
+interface GridState {
+    columns: readonly GridColumnState[];
+    filter: readonly GridStateCompositeFilterDescriptor[];
+    group: readonly GroupDescriptor[];
+    pageSize?: number;
+    schemaVersion?: number | string;
+    sort: readonly GridStateSortDescriptor[];
+    version: GridStateVersion;
+}
+interface GridStatePersistenceOptions {
+    enabled?: boolean;
+    persistPageSize?: boolean;
+    schemaVersion?: number | string;
+}
+type GridStateLoadStatus = "applied" | "empty" | "rejected-schema" | "rejected-version";
+interface GridStateLoadResult {
+    ignoredColumns: readonly string[];
+    missingColumns: readonly string[];
+    status: GridStateLoadStatus;
+}
+
+declare class GridStatePersistenceDirective {
+    #private;
+    /**
+     * @description State persistence options such as schema version and page size persistence.
+     */
+    readonly options: _angular_core.InputSignal<"" | GridStatePersistenceOptions>;
+    /**
+     * @description The persisted grid state to apply and update when the grid state changes.
+     */
+    readonly state: _angular_core.ModelSignal<GridState | null>;
+    constructor();
+    captureState(): GridState;
+    loadState(state: GridState | null, options?: GridStatePersistenceOptions): GridStateLoadResult;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridStatePersistenceDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridStatePersistenceDirective, "mona-grid[monaGridStatePersistence]", ["monaGridStatePersistence"], { "options": { "alias": "monaGridStatePersistence"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; }, { "state": "stateChange"; }, never, never, true, never>;
+}
+
+declare class GridToolbarTemplateDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridToolbarTemplateDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridToolbarTemplateDirective, "ng-template[monaGridToolbarTemplate]", never, {}, {}, never, never, true, never>;
+}
+
+declare class GridExportDirective {
+    #private;
+    exportCsv(filename?: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridExportDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridExportDirective, "mona-grid[monaGridExport]", ["monaGridExport"], {}, {}, never, never, true, never>;
+}
+
+declare class GridVirtualScrollDirective {
+    #private;
+    /**
+     * @description Enables row virtualization on the grid. Pass a `VirtualScrollOptions` object to configure the fixed row height.
+     */
+    readonly options: _angular_core.InputSignal<"" | Partial<VirtualScrollOptions> | undefined>;
+    /**
+     * @description Emitted when the scroll position reaches the configured threshold from the bottom of the virtualized list.
+     */
+    readonly scrollEnd: _angular_core.OutputEmitterRef<void>;
+    /**
+     * @description Distance, in rows, from the bottom of the virtualized list at which `scrollEnd` is emitted.
+     * @default 5
+     */
+    readonly scrollEndThreshold: _angular_core.InputSignal<number>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridVirtualScrollDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<GridVirtualScrollDirective, "mona-grid[monaGridVirtualScroll]", never, { "options": { "alias": "monaGridVirtualScroll"; "required": false; "isSignal": true; }; "scrollEndThreshold": { "alias": "scrollEndThreshold"; "required": false; "isSignal": true; }; }, { "scrollEnd": "scrollEnd"; }, never, never, true, never>;
+}
+
+interface GridColumnDefinition {
+    getColumn(): Column;
+}
+
+declare class GridCommandColumnComponent implements GridColumnDefinition {
+    #private;
+    private readonly commandTemplate;
+    /**
+     * @description Whether this command column is hidden from the rendered grid.
+     */
+    readonly hidden: _angular_core.InputSignal<boolean>;
+    /**
+     * @description Whether this command column remains fixed while the grid scrolls horizontally.
+     */
+    readonly locked: _angular_core.InputSignal<boolean>;
+    /**
+     * @description The side of the grid where this locked command column is fixed.
+     */
+    readonly lockedPosition: _angular_core.InputSignal<GridColumnLockedPosition>;
+    /**
+     * @description The maximum width of this command column in pixels.
+     */
+    readonly maxWidth: _angular_core.InputSignal<number | null>;
+    /**
+     * @description The minimum width of this command column in pixels.
+     */
+    readonly minWidth: _angular_core.InputSignal<number | null>;
+    /**
+     * @description Whether the built-in remove command asks for confirmation before emitting remove.
+     */
+    readonly removeConfirmation: _angular_core.InputSignal<boolean>;
+    /**
+     * @description A stable key used to persist state for this command column.
+     */
+    readonly stateKey: _angular_core.InputSignal<string | null>;
+    /**
+     * @description The title displayed in the command column header.
+     */
+    readonly title: _angular_core.InputSignal<string>;
+    /**
+     * @description The fixed width of this command column in pixels.
+     */
+    readonly width: _angular_core.InputSignal<number | null>;
+    getColumn(): Column;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridCommandColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridCommandColumnComponent, "mona-grid-command-column", never, { "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "locked": { "alias": "locked"; "required": false; "isSignal": true; }; "lockedPosition": { "alias": "lockedPosition"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "removeConfirmation": { "alias": "removeConfirmation"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, ["commandTemplate"], never, true, never>;
+}
+
+declare class GridColumnComponent implements GridColumnDefinition {
+    #private;
+    private readonly cellTemplate;
+    private readonly editTemplate;
+    private readonly footerTemplate;
+    private readonly groupFooterTemplate;
+    private readonly headerTemplate;
+    private readonly titleTemplate;
+    /**
+     * @description The aggregate shown in the grid footer for this column.
+     */
+    readonly aggregate: _angular_core.InputSignal<AggregateFunction | null>;
+    /**
+     * @description Whether this column is editable when the grid is in edit mode.
+     */
+    readonly editable: _angular_core.InputSignal<boolean>;
+    /**
+     * @description The field name of the data property to display in this column.
+     */
+    readonly field: _angular_core.InputSignal<string>;
+    /**
+     * @description Formats the displayed cell value. String formats apply to date, datetime, and time columns; formatter functions replace the cell text.
+     */
+    readonly format: _angular_core.InputSignal<ColumnFormat | null | undefined>;
+    /**
+     * @description Whether this column is hidden from the rendered grid.
+     */
+    readonly hidden: _angular_core.InputSignal<boolean>;
+    /**
+     * @description Whether this column remains fixed while the grid scrolls horizontally.
+     */
+    readonly locked: _angular_core.InputSignal<boolean>;
+    /**
+     * @description The side of the grid where this locked column is fixed.
+     */
+    readonly lockedPosition: _angular_core.InputSignal<GridColumnLockedPosition>;
+    /**
+     * @description The maximum width of this column in pixels.
+     */
+    readonly maxWidth: _angular_core.InputSignal<number | null>;
+    /**
+     * @description The minimum width of this column in pixels.
+     */
+    readonly minWidth: _angular_core.InputSignal<number>;
+    /**
+     * @description A stable key used to persist state for columns whose field is empty or unstable.
+     */
+    readonly stateKey: _angular_core.InputSignal<string | null>;
+    /**
+     * @description The title displayed in the column header.
+     */
+    readonly title: _angular_core.InputSignal<string>;
+    /**
+     * @description The data type of the column. Determines the edit component and filter behavior.
+     */
+    readonly type: _angular_core.InputSignal<DataType>;
+    /**
+     * @description The fixed width of this column in pixels. If not set, the column width is calculated automatically.
+     */
+    readonly width: _angular_core.InputSignal<number | null | undefined>;
+    getColumn(): Column;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridColumnComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridColumnComponent, "mona-grid-column", never, { "aggregate": { "alias": "aggregate"; "required": false; "isSignal": true; }; "editable": { "alias": "editable"; "required": false; "isSignal": true; }; "field": { "alias": "field"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "hidden": { "alias": "hidden"; "required": false; "isSignal": true; }; "locked": { "alias": "locked"; "required": false; "isSignal": true; }; "lockedPosition": { "alias": "lockedPosition"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; }, {}, ["cellTemplate", "editTemplate", "footerTemplate", "groupFooterTemplate", "headerTemplate", "titleTemplate"], never, true, never>;
+}
+
+interface ColumnFilterState {
+    filter?: CompositeFilterDescriptor;
+    filterMenuValue?: FilterMenuValue;
+}
+
+type ResizeMethod = "auto" | "fitView" | number;
+
+interface ColumnSortState {
+    sort: SortDescriptor;
+}
+
+interface GridAggregateBucket {
+    readonly field: string;
+    readonly avg?: number;
+    readonly count?: number;
+    readonly max?: unknown;
+    readonly min?: unknown;
+    readonly sum?: number;
+}
+interface GridGroupAggregate {
+    readonly aggregates: ImmutableDictionary<string, GridAggregateBucket>;
+    readonly count: number;
+    readonly depth: number;
+    readonly groupKey: string;
+    readonly groupValue: unknown;
+    readonly rows: readonly Record<PropertyKey, unknown>[];
+}
+
+interface CellEditContext {
+    readonly cellUid: string;
+    readonly columnId: string;
+    readonly mode: "cell";
+    readonly row: Row;
+    readonly rowUid: string;
+    readonly session: GridEditSession;
+}
+interface RowEditContext {
+    readonly mode: "row";
+    readonly row: Row;
+    readonly rowUid: string;
+    readonly session: GridEditSession;
+}
+type GridEditContext = CellEditContext | RowEditContext;
+
+interface GridLockedColumnState {
+    readonly edge: boolean;
+    readonly offset: number;
+    readonly side: GridColumnLockedPosition;
+}
+
+interface PaginationState {
+    readonly page: number;
+    readonly skip: number;
+    readonly take: number;
+}
+
+interface RowEditDataItem extends Record<string, unknown> {
+    readonly $rowId: string;
+}
+declare class GridService {
+    #private;
+    readonly addRowData: _angular_core.Signal<Record<PropertyKey, unknown> | null>;
+    readonly addRowVisible: _angular_core.Signal<boolean>;
+    readonly add$: Subject<GridAddEvent>;
+    readonly aggregateColumns: _angular_core.Signal<ImmutableList<Column>>;
+    readonly aggregateMap: _angular_core.Signal<ImmutableDictionary<string, GridAggregateBucket>>;
+    readonly aggregateRows: _angular_core.Signal<Record<PropertyKey, unknown>[]>;
+    readonly appliedFilters: _angular_core.WritableSignal<ImmutableDictionary<string, ColumnFilterState>>;
+    readonly appliedGroupSorts: _angular_core.WritableSignal<ImmutableDictionary<string, ColumnSortState>>;
+    readonly appliedSorts: _angular_core.WritableSignal<ImmutableDictionary<string, ColumnSortState>>;
+    readonly bodyScrollElement: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly bodyTableElement: _angular_core.WritableSignal<HTMLTableElement | null>;
+    readonly cellEdit$: Subject<CellEditEvent>;
+    readonly cancel$: Subject<GridCancelEvent>;
+    /** Set of currently collapsed group keys (global, shared by both paginated and virtual list). */
+    readonly collapsedGroupKeys: _angular_core.WritableSignal<ImmutableSet<string>>;
+    readonly columnReorder$: Subject<ColumnReorderEvent>;
+    readonly columnResize$: Subject<ColumnResizeEvent>;
+    readonly columnSort$: Subject<ColumnSortEvent>;
+    readonly columns: _angular_core.WritableSignal<ImmutableList<Column>>;
+    readonly contextMenuItems: _angular_core.WritableSignal<ImmutableSet<PopupMenuItem>>;
+    readonly detailColumnWidth = 36;
+    readonly editBaseDict: _angular_core.Signal<ImmutableDictionary<string, RowEditDataItem>>;
+    readonly editContext: _angular_core.Signal<GridEditContext | null>;
+    readonly edit$: Subject<GridEditEvent>;
+    readonly editViewDict: _angular_core.Signal<ImmutableDictionary<string, RowEditDataItem>>;
+    readonly editSession: _angular_core.Signal<GridEditSession | null>;
+    readonly editableOptions: _angular_core.WritableSignal<EditableOptions>;
+    readonly editableRowKey: _angular_core.WritableSignal<GridKeySelector<unknown>>;
+    readonly editingRowUid: _angular_core.Signal<string | null>;
+    readonly expandedKeys: _angular_core.WritableSignal<ImmutableSet<unknown>>;
+    readonly filterChange$: Subject<CompositeFilterDescriptor[]>;
+    readonly filterableOptions: _angular_core.Signal<FilterableOptions>;
+    readonly footerScrollElement: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly gridHeaderElement: _angular_core.WritableSignal<HTMLDivElement | null>;
+    readonly groupAggregateMap: _angular_core.Signal<ImmutableDictionary<string, GridGroupAggregate>>;
+    readonly groupColumnWidth = 36;
+    readonly groupColumns: _angular_core.Signal<ImmutableList<Column>>;
+    readonly groupableOptions: _angular_core.WritableSignal<GroupableOptions>;
+    readonly hasLeftLockedColumns: _angular_core.Signal<boolean>;
+    readonly hasFooter: _angular_core.Signal<boolean>;
+    readonly hasLiveScrollbarGutterWidth: _angular_core.Signal<boolean>;
+    readonly headerTableElement: _angular_core.WritableSignal<HTMLTableElement | null>;
+    readonly horizontalScrollLeft: _angular_core.Signal<number>;
+    readonly isInEditMode: _angular_core.Signal<boolean>;
+    readonly leftLockedStructuralWidth: _angular_core.Signal<number>;
+    readonly lockedColumnStates: _angular_core.Signal<ReadonlyMap<string, GridLockedColumnState>>;
+    readonly masterDetailEmptyCellWidth: _angular_core.Signal<number>;
+    readonly masterDetailRowWidth: _angular_core.Signal<number>;
+    readonly masterDetailTemplate: _angular_core.WritableSignal<TemplateRef<unknown> | null>;
+    readonly newRowFactory: _angular_core.WritableSignal<() => Record<PropertyKey, unknown>>;
+    readonly paginationState: _angular_core.WritableSignal<PaginationState>;
+    readonly remove$: Subject<GridRemoveEvent>;
+    readonly reorderableOptions: _angular_core.Signal<ReorderableOptions>;
+    readonly resizableOptions: _angular_core.Signal<ResizableOptions>;
+    readonly rowEdit$: Subject<RowEditEvent>;
+    readonly rows: _angular_core.WritableSignal<ImmutableSet<Row>>;
+    readonly save$: Subject<GridSaveEvent>;
+    readonly scrollEnd$: Subject<void>;
+    readonly scrollEndThreshold: _angular_core.WritableSignal<number>;
+    readonly scrollbarGutterWidth: _angular_core.Signal<number>;
+    readonly selectBy: _angular_core.WritableSignal<GridKeySelector<unknown>>;
+    readonly selectableOptions: _angular_core.WritableSignal<SelectableOptions>;
+    readonly selectedKeys: _angular_core.WritableSignal<ImmutableSet<unknown>>;
+    readonly selectedKeysChange$: rxjs.Observable<ImmutableSet<unknown>>;
+    readonly selectedKeysLoad$: BehaviorSubject<ImmutableSet<unknown>>;
+    readonly selectedRows: _angular_core.Signal<ImmutableSet<Row>>;
+    readonly sortableOptions: _angular_core.WritableSignal<SortableOptions>;
+    readonly tableWidth: _angular_core.Signal<number | null>;
+    readonly viewPageRows: _angular_core.Signal<ImmutableSet<Row>>;
+    readonly viewRowCount: _angular_core.Signal<number>;
+    readonly viewRows: _angular_core.Signal<ImmutableSet<Row>>;
+    readonly virtualGridMaxBuffer: _angular_core.Signal<number>;
+    readonly virtualGridMinBuffer: _angular_core.WritableSignal<number>;
+    readonly virtualScrollOptions: _angular_core.WritableSignal<VirtualScrollOptions>;
+    readonly visibleColumns: _angular_core.Signal<ImmutableList<Column>>;
+    constructor();
+    addGroupColumn(column: Column): void;
+    applyState(state: GridState | null, options?: GridStatePersistenceOptions): GridStateLoadResult;
+    cancelAddRow(originalEvent?: Event): boolean;
+    cancelEdit(originalEvent?: Event): boolean;
+    captureState(options?: GridStatePersistenceOptions): GridState;
+    clearCollapsedGroups(predicate?: (key: string) => boolean): void;
+    clearColumnGrouping(column: Column): void;
+    commitRowEdit(originalEvent?: Event): boolean;
+    deselectAllRows(): void;
+    findTextWidthOfColumn(column: Column, element: HTMLTableCellElement): number;
+    getColumnStateId(column: Column): string | null;
+    getColumnWidth(column: Column): number;
+    getGroupDescriptors(columns: Iterable<Column>): GroupDescriptor[];
+    handleMultipleSelection(event: MouseEvent, row: Row): void;
+    handleRowClick(event: MouseEvent, row: Row): void;
+    handleSingleSelection(event: MouseEvent, row: Row): void;
+    isGroupCollapsed(groupKey: string): boolean;
+    isRowExpanded(row: Row): boolean;
+    isRowSelected(row: Row): boolean;
+    isSelectableGrid(): boolean;
+    loadFilters(filters: CompositeFilterDescriptor[]): void;
+    loadGroupColumns(descriptors: Iterable<GroupDescriptor>): void;
+    loadSelectedKeys(selectedKeys: Iterable<unknown>): void;
+    loadSorts(sorts: SortDescriptor[]): void;
+    moveGroupColumn(column: Column, moveAs: "prev" | "next"): void;
+    normalizeRenderedWidth(width: number): number;
+    patchAddCell(field: string, value: unknown): void;
+    patchCellEdit(rowUid: string, field: string, value: unknown): void;
+    removeRow(row: Row, originalEvent?: Event): boolean;
+    resolveAggregateValue(bucket: GridAggregateBucket | null, aggregateFunction: AggregateFunction | null): unknown;
+    saveAddRow(originalEvent?: Event): boolean;
+    selectRow(row: Row): void;
+    setCalculatedWidth(columnId: string, value: number | null): void;
+    setCalculatedWidths(widthByColumnId: ReadonlyMap<string, number | null>): void;
+    setColumnDefinitions(configs: readonly ColumnConfig[]): void;
+    setColumnFiltered(columnId: string, value: boolean): void;
+    setColumnGroupSortDirection(columnId: string, value: SortDirection | null): void;
+    setColumnHidden(columnId: string, value: boolean): void;
+    setColumnOrder(columnIds: readonly string[]): void;
+    setColumnSortDirection(columnId: string, value: SortDirection | null): void;
+    setColumnSortIndex(columnId: string, value: number | null): void;
+    setColumnVisibilityByFields(visibleFields: ImmutableSet<string>): void;
+    setEditableOptions(options: EditableOptions): void;
+    setFilterableOptions(options: Partial<FilterableOptions>): void;
+    setGroupableOptions(options: Partial<GroupableOptions>): void;
+    setNewRowFactory(factory: () => Record<PropertyKey, unknown>): void;
+    setPageState(state: Partial<PaginationState>): void;
+    setReorderableOptions(options: Partial<ReorderableOptions>): void;
+    setResizableOptions(options: Partial<ResizableOptions>): void;
+    setRowExpanded(row: Row, expanded: boolean): void;
+    setRows(value: Iterable<Record<PropertyKey, unknown>>, rowKey?: GridKeySelector<unknown> | null): void;
+    setSelectableOptions(options: SelectableOptions): void;
+    setSortableOptions(options: Partial<SortableOptions>): void;
+    setScrollEndThreshold(threshold: number): void;
+    setVirtualScrollOptions(options: VirtualScrollOptions): void;
+    startAddRow(originalEvent?: Event): boolean;
+    startCellEdit(uid: string, row: Row, column: Column, originalEvent?: Event): boolean;
+    startRowEdit(row: Row, originalEvent?: Event): boolean;
+    stopCellEdit(originalEvent?: Event): boolean;
+    toggleGroupCollapse(groupKey: string): void;
+    updateColumn(columnId: string, patch: Partial<Omit<Column, "id">>): void;
+    private applyColumnIndexes;
+    private buildGroupAggregates;
+    private buildGroupKey;
+    private compareComparableValues;
+    private createAggregateBucket;
+    private createAggregateMap;
+    private deserializeCompositeFilter;
+    private deserializeFilterDescriptor;
+    private deserializeFilterValue;
+    private deserializeFilters;
+    private findLongestCellContentOfColumn;
+    private getColumnById;
+    private getColumnLockBucket;
+    private getRowDataItemSelectionKey;
+    private getRowSelectionKey;
+    private getRowUid;
+    private getRowUidKey;
+    private groupRowsByColumn;
+    private measureElementScrollbarGutter;
+    private measureFallbackScrollbarGutter;
+    private orderColumnsByLockBucket;
+    private reconcileColumn;
+    private clearEditSession;
+    private createEditSession;
+    private patchSessionField;
+    private resolveEditedRowData;
+    private resolveSessionRowData;
+    private validateSessionForSave;
+    private serializeFilter;
+    private serializeFilterDescriptor;
+    private serializeFilterValue;
+    private setElementScrollLeft;
+    private setHorizontalScrollLeft;
+    private setHorizontalScrollSyncEffects;
+    private setScrollbarGutterEffects;
+    private toComparableValue;
+    private updateColumns;
+    private withColumnIndices;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GridService>;
+}
+
+declare const gridBaseThemeVariants: (theme: ThemeStyle) => (props?: ({
+    rounded?: "small" | "none" | "medium" | "large" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+declare const gridHeaderTableCellThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const gridHeaderTableColumnTitleThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const gridHeaderTableColumnWrapThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const gridHeaderTableRowThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const gridHeaderTableThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+declare const gridHeaderThemeVariants: (theme: ThemeStyle) => (props?: class_variance_authority_types.ClassProp | undefined) => string;
+type GridBaseVariantProps = VariantProps<ReturnType<typeof gridBaseThemeVariants>>;
+type GridBaseVariantInput = VariantInputs<GridBaseVariantProps>;
+type GridHeaderTableCellVariantProps = VariantProps<ReturnType<typeof gridHeaderTableCellThemeVariants>>;
+type GridHeaderTableCellVariantInput = VariantInputs<GridHeaderTableCellVariantProps>;
+type GridHeaderTableColumnTitleVariantProps = VariantProps<ReturnType<typeof gridHeaderTableColumnTitleThemeVariants>>;
+type GridHeaderTableColumnTitleVariantInput = VariantInputs<GridHeaderTableColumnTitleVariantProps>;
+type GridHeaderTableColumnWrapVariantProps = VariantProps<ReturnType<typeof gridHeaderTableColumnWrapThemeVariants>>;
+type GridHeaderTableColumnWrapVariantInput = VariantInputs<GridHeaderTableColumnWrapVariantProps>;
+type GridHeaderTableRowVariantProps = VariantProps<ReturnType<typeof gridHeaderTableRowThemeVariants>>;
+type GridHeaderTableRowVariantInput = VariantInputs<GridHeaderTableRowVariantProps>;
+type GridHeaderTableVariantProps = VariantProps<ReturnType<typeof gridHeaderTableThemeVariants>>;
+type GridHeaderTableVariantInput = VariantInputs<GridHeaderTableVariantProps>;
+type GridHeaderVariantProps = VariantProps<ReturnType<typeof gridHeaderThemeVariants>>;
+type GridHeaderVariantInput = VariantInputs<GridHeaderVariantProps>;
+type GridVariantInput = GridBaseVariantInput & GridHeaderTableCellVariantInput & GridHeaderTableColumnTitleVariantInput & GridHeaderTableColumnWrapVariantInput & Omit<GridHeaderTableRowVariantInput, "isFilterRow"> & GridHeaderTableVariantInput & GridHeaderVariantInput;
+
+declare class GridComponent<T> implements GridVariantInput {
+    #private;
+    private readonly footerScrollElement;
+    protected readonly baseClass: _angular_core.Signal<string>;
+    protected readonly columnActionsClass: _angular_core.Signal<string>;
+    protected readonly columnDragPreviewClass: _angular_core.Signal<string>;
+    protected readonly columnDragging: _angular_core.WritableSignal<boolean>;
+    protected readonly columnDropHintClass: _angular_core.Signal<string>;
+    protected readonly columnResizerClass: _angular_core.Signal<string>;
+    protected readonly dragColumn: _angular_core.WritableSignal<Column | null>;
+    protected readonly dropColumn: _angular_core.WritableSignal<Column | null>;
+    protected readonly filterMenuEnabled: _angular_core.Signal<boolean>;
+    protected readonly filterRowEnabled: _angular_core.Signal<boolean>;
+    protected readonly footerClass: _angular_core.Signal<string>;
+    protected readonly footerTableClass: _angular_core.Signal<string>;
+    protected readonly footerTableRowClass: _angular_core.Signal<string>;
+    protected readonly footerVisible: _angular_core.Signal<boolean>;
+    protected readonly gridDetailTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly gridHeaderElement: _angular_core.Signal<ElementRef<HTMLDivElement>>;
+    protected readonly gridHeaderTableElement: _angular_core.Signal<ElementRef<HTMLTableElement>>;
+    protected readonly gridService: GridService;
+    protected readonly gridWidthSet: _angular_core.WritableSignal<boolean>;
+    protected readonly groupColumnList: _angular_core.Signal<CdkDropList<any> | undefined>;
+    protected readonly groupPanelPlaceholderClass: _angular_core.Signal<string>;
+    protected readonly groupPanelClass: _angular_core.Signal<string>;
+    protected readonly groupPanelPlaceholderVisible: _angular_core.WritableSignal<boolean>;
+    protected readonly groupable: _angular_core.Signal<boolean>;
+    protected readonly groupingInProgress: _angular_core.WritableSignal<boolean>;
+    protected readonly headerClass: _angular_core.Signal<string>;
+    protected readonly headerMarginRight: _angular_core.Signal<number>;
+    protected readonly headerTableClass: _angular_core.Signal<string>;
+    protected readonly headerTableCellClass: _angular_core.Signal<string>;
+    protected readonly headerTableColumnTitleClass: _angular_core.Signal<string>;
+    protected readonly headerTableColumnWrapClass: _angular_core.Signal<string>;
+    protected readonly headerTableRowClass: _angular_core.Signal<string>;
+    protected readonly noDataClass: _angular_core.Signal<string>;
+    protected readonly noDataTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly resizing: _angular_core.WritableSignal<boolean>;
+    protected readonly toolbarContext: _angular_core.Signal<{
+        $implicit: GridService;
+        addRowData: Record<PropertyKey, unknown> | null;
+        addRowVisible: boolean;
+        cancelAdd: () => boolean;
+        editSession: _nanahoshi_mona_ui_grid.GridEditSession | null;
+        saveAdd: () => boolean;
+        startAdd: () => boolean;
+    }>;
+    protected readonly toolbarElement: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
+    protected readonly toolbarTemplate: _angular_core.Signal<TemplateRef<any> | undefined>;
+    protected readonly uid: string;
+    /**
+     * @description The row data to be displayed in the grid.
+     */
+    readonly data: _angular_core.InputSignal<Iterable<T>>;
+    /**
+     * @description The number of items to be displayed on a page.
+     */
+    readonly pageSize: _angular_core.InputSignal<number | undefined>;
+    /**
+     * @description The page sizes that the user can select from.
+     * These values will be displayed in the page size dropdown.
+     * @default []
+     */
+    readonly pageSizeValues: _angular_core.InputSignal<number[]>;
+    /**
+     * @description The method to be used to set initial column widths.
+     * It can be the following values:
+     * - `fitView`: The columns will be resized to fit the available width.
+     * - `auto`: The columns will be resized based on the content.
+     * - A number representing the width of the columns. All columns except the columns with a specified width
+     *   will have the same width.
+     * @default "fitView"
+     */
+    readonly resizeMethod: _angular_core.InputSignal<ResizeMethod>;
+    /**
+     * @description Whether the pager is responsive.
+     * If set to `true`, the pager will be displayed as a dropdown when the grid width gets smaller.
+     * @default true
+     */
+    readonly responsivePager: _angular_core.InputSignal<boolean>;
+    /**
+     * @description The border radius of the grid.
+     * @default "medium"
+     */
+    readonly rounded: _angular_core.InputSignal<"small" | "none" | "medium" | "large" | null | undefined>;
+    /**
+     * @description Additional CSS classes merged onto the host element via `tailwind-merge`.
+     * @default ""
+     */
+    readonly userClass: _angular_core.InputSignal<string>;
+    constructor();
+    protected isColumnDragDisabled(column: Column): boolean;
+    protected onColumnDragEnter(event: CdkDragEnter<void, Column>): void;
+    protected onColumnDragEnterForGrouping(): void;
+    protected onColumnDragExitForGrouping(): void;
+    protected onColumnDragStart(event: CdkDragStart<Column>): void;
+    protected onColumnDrop(): void;
+    protected onColumnDropForGrouping(event: CdkDragDrop<Column, void, Column>): void;
+    protected onColumnFilter(column: Column, state: ColumnFilterState): void;
+    protected onColumnMouseEnter(column: Column): void;
+    protected onColumnResizeEnd(event: ColumnResizeEvent): void;
+    protected onColumnResizeStart(): void;
+    protected onColumnSort(column: Column): void;
+    protected onGroupingColumnRemove(event: Event, column: Column): void;
+    protected onGroupColumnReorder(column: Column, moveAs: "prev" | "next"): void;
+    protected onGroupingColumnSort(column: Column): void;
+    protected onPageChange(event: PageChangeEvent): void;
+    protected onPageSizeChange(data: PageSizeChangeEvent): void;
+    protected onToolbarKeydown(event: KeyboardEvent): void;
+    private adjustPageAfterFilter;
+    private clampCalculatedWidth;
+    private clearDragState;
+    private createFitViewWidthMap;
+    private getTableColumnHeaderCellList;
+    private getColumnLockBucket;
+    private getToolbarFocusTargets;
+    private isElementDisabled;
+    private isElementHidden;
+    private setDataEffect;
+    private setFitViewScrollbarSyncEffect;
+    private setFooterScrollElementEffect;
+    private setGridDetailEffect;
+    private setInitialCalculatedWidthOfColumns;
+    private setPageSizeEffect;
+    private setResizeObserver;
+    private syncToolbarFocusTargets;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridComponent<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridComponent<any>, "mona-grid", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeValues": { "alias": "pageSizeValues"; "required": false; "isSignal": true; }; "resizeMethod": { "alias": "resizeMethod"; "required": false; "isSignal": true; }; "responsivePager": { "alias": "responsivePager"; "required": false; "isSignal": true; }; "rounded": { "alias": "rounded"; "required": false; "isSignal": true; }; "userClass": { "alias": "class"; "required": false; "isSignal": true; }; }, {}, ["gridDetailTemplate", "noDataTemplate", "toolbarTemplate"], never, true, never>;
+}
+
+export { CellEditEvent, ColumnReorderEvent, ColumnSortEvent, GridAddCommandDirective, GridAddEvent, GridCancelCommandDirective, GridCancelEvent, GridCellTemplateDirective, GridColumnComponent, GridColumnTitleTemplateDirective, GridCommandColumnComponent, GridComponent, GridContextMenuDirective, GridDetailTemplateDirective, GridEditCommandDirective, GridEditEvent, GridEditTemplateDirective, GridEditableDirective, GridExportDirective, GridFilterableDirective, GridFooterTemplateDirective, GridGroupFooterTemplateDirective, GridGroupableDirective, GridHeaderTemplateDirective, GridNoDataTemplateDirective, GridRemoveCommandDirective, GridRemoveEvent, GridReorderableDirective, GridResizableDirective, GridSaveCommandDirective, GridSaveEvent, GridSelectableDirective, GridSortableDirective, GridStatePersistenceDirective, GridToolbarTemplateDirective, GridVirtualScrollDirective, RowEditEvent };
+export type { AggregateFunction, Column, ColumnConfig, ColumnFormat, ColumnKind, ColumnResizeEvent, EditableOptions, FilterableOptions, GridColumnLockedPosition, GridColumnState, GridEditFormContext, GridEditOperation, GridEditSchemaFactory, GridEditSession, GridEditTemplateContext, GridSaveOperation, GridState, GridStateCompositeFilterDescriptor, GridStateFilterDescriptor, GridStateFilterValue, GridStateLoadResult, GridStateLoadStatus, GridStatePersistenceOptions, GridStateSortDescriptor, GridStateVersion, GroupDescriptor, GroupableOptions, ReorderableOptions, ResizableOptions, ResizeMethod, SelectableOptions, SortableOptions };