persian-data-grid 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,2487 @@
+import * as React from 'react';
+import React__default, { ReactNode } from 'react';
+
+type AuditEvent = {
+    message: string;
+    payload?: unknown;
+    type: 'INFORMATION' | 'ERROR' | 'FORBIDDEN' | 'CELL_CHANGED' | 'CELL_DISPLAY_CHANGED' | 'ROW_ADDED' | 'NEW_ROW_ADDED' | 'ROW_DELETED' | 'ROW_RESTORED' | 'ROW_REORDERED' | 'COLUMN_REORDERED' | 'UNIT_COLUMN_ADDED' | 'PAGE_CHANGED' | 'PAGE_SIZE_CHANGED' | 'TABLE_DELETED' | 'TABLE_RESET' | 'ROWS_LOADED' | 'DYNAMIC_DATA_REQUESTED' | 'VALIDATION_FAILED' | 'ROW_NOT_FOUND' | 'PAGE_NOT_CHANGED' | 'COLUMN_NOT_FOUND' | 'CELL_NOT_FOUND' | 'NOT_EDITABLE' | 'FORBIDDEN' | 'INVALID_VALUE' | 'DUPLICATE_ROW' | 'INVARIANT_VIOLATION' | 'ROW_NOT_EXPANDED' | 'ACTIVE_COLLECTION_CHANGED' | 'DRAG_OR_DROP_ROW_NOT_FOUND';
+};
+interface AuditLogger {
+    log(event: AuditEvent): void;
+    error(event: AuditEvent): void;
+    warn(event: AuditEvent): void;
+    info(event: AuditEvent): void;
+}
+
+interface RemoteApi {
+    request<TResponse = any>(input: {
+        endpoint: string;
+        params?: Record<string, any>;
+        method?: 'GET' | 'POST';
+    }): Promise<TResponse>;
+}
+
+type Actor$1 = {
+    userId: string;
+    roles: string[];
+};
+interface PermissionPolicy {
+    canChangeCell(input: {
+        actor: Actor$1;
+        rowId: number;
+        columnId: string;
+    }): boolean;
+    canEdit?: (input: {
+        actor: Actor$1;
+        rowId: number;
+        columnId: string;
+    }) => boolean;
+    canAddRow?: (input: {
+        actor: Actor$1;
+    }) => boolean;
+    canCopyRow?: (input: {
+        actor: Actor$1;
+        rowId: number;
+    }) => boolean;
+    canDeleteRow?: (input: {
+        actor: Actor$1;
+        rowId: number;
+    }) => boolean;
+    canReorderRow?: (input: {
+        actor: Actor$1;
+        rowId: number;
+    }) => boolean;
+}
+
+/**
+ * View-state value object for virtual scrolling.
+ * Lives in Domain types but is NOT an accounting invariant — Adapters drive it.
+ */
+declare class Viewport {
+    /** Vertical scroll offset in pixels. */
+    readonly scrollOffset: number;
+    /** Visible viewport height in pixels. */
+    readonly viewportSize: number;
+    /** Fixed row height in pixels (variable-height later). */
+    readonly rowHeight: number;
+    /** Extra rows rendered above/below the window. */
+    readonly overscan: number;
+    constructor(
+    /** Vertical scroll offset in pixels. */
+    scrollOffset: number, 
+    /** Visible viewport height in pixels. */
+    viewportSize: number, 
+    /** Fixed row height in pixels (variable-height later). */
+    rowHeight: number, 
+    /** Extra rows rendered above/below the window. */
+    overscan?: number);
+    equals(other: Viewport): boolean;
+    withScrollOffset(scrollOffset: number): Viewport;
+    withViewportSize(viewportSize: number): Viewport;
+    toJSON(): {
+        scrollOffset: number;
+        viewportSize: number;
+        rowHeight: number;
+        overscan: number;
+    };
+}
+/** Inclusive start, exclusive end — indices into the ordered row list. */
+type VisibleRange = {
+    readonly startIndex: number;
+    readonly endIndex: number;
+    readonly startOffset: number;
+    readonly endOffset: number;
+    readonly totalHeight: number;
+    readonly visibleCount: number;
+};
+
+declare class CellValue {
+    readonly value: unknown;
+    constructor(value: unknown);
+    equals(other: CellValue): boolean;
+}
+declare class CellDisplay {
+    readonly value: unknown;
+    constructor(value: unknown);
+    equals(other: CellDisplay): boolean;
+}
+declare class ColumnId {
+    readonly value: string;
+    constructor(value: string);
+    equals(other: ColumnId): boolean;
+}
+type KeyValue = {
+    key: string;
+    value: unknown;
+    display: unknown;
+};
+type IRule = {
+    type?: string | 'array' | 'object' | 'enum' | 'date' | 'number' | 'integer' | 'float' | 'boolean' | 'email' | 'url' | 'hex' | RegExp;
+    required?: boolean;
+    whitespace?: boolean;
+    message?: string;
+    transform?: (value: any) => any;
+    pattern?: string | RegExp;
+    min?: number;
+    max?: number;
+    len?: number;
+    enum?: any[];
+    validator?: (rule: IRule, value: any, callback: (error?: string[]) => void) => void | Promise<void>;
+    asyncValidator?: (rule: IRule, value: any) => Promise<void>;
+    warningOnly?: boolean;
+    validateTrigger?: string | string[];
+};
+declare class RowId {
+    value: number;
+    constructor(value: number);
+    equals(other: RowId): boolean;
+    set(id: RowId): void;
+}
+declare class RowState {
+    value: RowStateEnum;
+    constructor(value: RowStateEnum);
+    equals(other: RowStateEnum): boolean;
+    set(rowState: RowStateEnum): void;
+}
+declare enum RowStateEnum {
+    Added = "Add",
+    Modified = "Update",
+    Deleted = "Delete",
+    Unchanged = "None"
+}
+type TableActions = "copy" | "cut" | "paste" | "pasteInsert" | null;
+
+declare class Pagination {
+    readonly page: number;
+    readonly pageSize: number;
+    readonly totalRows: number;
+    readonly totalPages: number;
+    readonly canPrev: boolean;
+    readonly canNext: boolean;
+    constructor(page: number, pageSize: number, totalRows: number);
+    changePage(page: number): Pagination;
+    changePageSize(size: number): Pagination;
+    toJSON(): {
+        page: number;
+        pageSize: number;
+        totalRows: number;
+        totalPages: number;
+        canPrev: boolean;
+        canNext: boolean;
+    };
+}
+
+declare class CellChanged {
+    readonly rowId: RowId;
+    readonly columnId: ColumnId;
+    readonly newValue: unknown;
+    readonly previousValue: unknown;
+    readonly type = "CELL_CHANGED";
+    constructor(rowId: RowId, columnId: ColumnId, newValue: unknown, previousValue: unknown);
+}
+declare class DisplayChanged {
+    readonly rowId: RowId;
+    readonly columnId: ColumnId;
+    readonly newValue: unknown;
+    readonly type = "DISPLAY_CHANGED";
+    constructor(rowId: RowId, columnId: ColumnId, newValue: unknown);
+}
+declare class DescriptionSaved {
+    readonly rowId: RowId;
+    readonly flag: boolean;
+    readonly type = "DESCRIPTION_SAVED";
+    constructor(rowId: RowId, flag: boolean);
+}
+declare class ColumnReordered {
+    readonly sourceIndex: number;
+    readonly destIndex: number;
+    readonly type = "COLUMN_REORDERED";
+    constructor(sourceIndex: number, destIndex: number);
+}
+declare class RowAdded {
+    readonly rowId: RowId;
+    readonly type = "ROW_ADDED";
+    constructor(rowId: RowId);
+}
+declare class RowDeleted {
+    readonly rowId: RowId;
+    readonly type = "ROW_DELETED";
+    constructor(rowId: RowId);
+}
+declare class RowRemoved {
+    readonly rowId: RowId;
+    readonly type = "NEW_ROW_REMOVED";
+    constructor(rowId: RowId);
+}
+declare class MinimumRowConstraintViolated {
+    readonly rowId: RowId;
+    readonly type = "NEW_AND_FIRST_ROW_CAN_NOT_BE_REMOVE";
+    constructor(rowId: RowId);
+}
+declare class RowRestored {
+    readonly rowId: RowId;
+    readonly type = "ROW_RESTORED";
+    constructor(rowId: RowId);
+}
+declare class RowReordered {
+    readonly draggedRowNum: number;
+    readonly droppedRowNum: number;
+    readonly type = "ROW_REORDERED";
+    constructor(draggedRowNum: number, droppedRowNum: number);
+}
+
+declare class Cell {
+    readonly rowId: RowId;
+    readonly columnId: ColumnId;
+    private value;
+    private originalValue;
+    private display;
+    constructor(rowId: RowId, columnId: ColumnId, value: CellValue, originalValue: CellValue, display: CellDisplay);
+    changeValue(newValue: unknown): CellChanged | null;
+    changeDisplay(newValue: unknown): DisplayChanged | null;
+    changeOriginalValue(newValue: unknown): CellChanged | null;
+    getValue(): unknown;
+    getValueObject(): CellValue;
+    getDisplay(): unknown;
+    getDisplayObject(): CellDisplay;
+    getOriginalValue(): CellValue;
+    clone(): Cell;
+}
+
+declare class Row {
+    id: RowId;
+    cells: Map<string, Cell>;
+    rowState: RowState;
+    changeFields: Set<string>;
+    visibilityCondition: Record<string, boolean>;
+    collection: string;
+    isSaveDescription: boolean;
+    constructor(id: RowId, cells: Map<string, Cell>, rowState: RowState, changeFields: Set<string> | undefined, visibilityCondition: Record<string, boolean>, collection: string | undefined, isSaveDescription: boolean);
+    updateChangeFields(columnId: ColumnId): void;
+    getCollection(): string;
+    setCollection(collection: string): void;
+    getChangeFields(): readonly string[];
+    getSnapshotChangeFields(): readonly string[];
+    changeCell(columnId: ColumnId, value: unknown): CellChanged | null;
+    saveDescription(flag: boolean): DescriptionSaved;
+    changeDisplay(columnId: ColumnId, value: unknown): DisplayChanged | null;
+    getCells(): ReadonlyMap<string, Cell>;
+    getCell(columnId: string): Cell | undefined;
+    ensureCell(columnId: ColumnId, defaultValue: CellValue, displayValue: CellDisplay): void;
+    setRowId(rowId: RowId): void;
+    setVisibilityCondition(Condition: Record<string, boolean>): void;
+    getVisibilityCondition(): Record<string, boolean>;
+    removeCell(columnId: ColumnId): void;
+    clone(): Row;
+}
+
+type FieldType = 'index' | 'text' | 'number' | 'price' | 'select' | 'selectOption' | 'date' | 'static' | 'description' | 'checkbox';
+type ColumnVisibilityRule = {
+    kind: 'always';
+} | {
+    kind: 'never';
+} | {
+    kind: 'showUnitLevelConditionally';
+    fieldName: string;
+} | {
+    kind: 'whenFieldTruthy';
+    fieldName: string;
+} | {
+    kind: 'whenRemoteFlag';
+    sourceFieldName: string;
+    flag: string;
+} | {
+    kind: 'whenCollection';
+    collection: string;
+} | {
+    kind: 'whenTableType';
+    tableType: string;
+};
+interface ResolveOnConfig<K = unknown, TResponse = unknown> {
+    endpoint: string;
+    fieldName: string;
+    buildParams: (row: Record<string, unknown>) => Record<string, unknown>;
+    getResponse?: (response: TResponse, row: Row) => unknown;
+    mapFlags?: (response: TResponse) => Record<string, boolean>;
+}
+type ColumnAccessControl = {
+    allowRoles?: string[];
+    denyRoles?: string[];
+    rule?: (ctx: {
+        actor: Actor$1;
+        row: Row;
+        table: Table;
+    }) => boolean;
+};
+interface IDependOn {
+    fieldName: string;
+    value: any;
+}
+type DefaultOptionType = {
+    value?: string | number;
+    label?: any;
+    title?: string;
+    [key: string]: unknown;
+};
+interface ColumnSchema<T = unknown, K = unknown> {
+    fieldName: string;
+    fieldCaption: string;
+    fieldType: FieldType;
+    fieldCollection?: string;
+    order?: number;
+    rules?: IRule[];
+    options?: DefaultOptionType[];
+    editable?: boolean;
+    isUnique?: boolean;
+    noCache?: boolean;
+    expandable?: boolean;
+    returnValue?: (values: T, colId: string) => unknown;
+    returnDisplayValue?: (values: T, colId: string) => unknown;
+    enableDeleteButton?: boolean;
+    enableExpandButton?: boolean;
+    enableMoveButton?: boolean;
+    enableOptionsButton?: boolean;
+    disable?: boolean;
+    colAccess?: ColumnAccessControl;
+    dynamicSource?: {
+        endpoint: string;
+        dependsOn?: string[];
+        dependOn?: IDependOn | IDependOn[];
+        params?: Record<string, string>;
+        [key: string]: unknown;
+    };
+    hidden?: boolean;
+    className?: string;
+    visibility: ColumnVisibilityRule;
+    resolveOn?: ResolveOnConfig<K>;
+    computed?: {
+        dependsOn: readonly string[];
+        compute: (row: Record<string, unknown>, remoteApi: RemoteApi) => Promise<unknown>;
+        children?: [] | undefined;
+    };
+    selectOptions?: {
+        label: string;
+        value: string | number;
+    }[];
+    indexOptions?: (...args: any[]) => any[];
+    onChange?: (...args: any[]) => void;
+    displayFormat?: (value: unknown) => unknown;
+    minWidth?: number;
+    style?: any;
+    popUpWidth?: number;
+    dynamicSelectFilterOption?: (inputValue: string, option: any) => boolean;
+    labelValue?: 'selectDisplay' | 'selectValue';
+}
+
+declare class Collection {
+    name: string;
+    private rows;
+    private columns;
+    constructor(name: string | undefined, rows: Map<number, Row>, columns: Map<string, ColumnSchema>);
+    setCollectionName(name: string): void;
+    getCollectionName(): string;
+    getRows(): Map<number, Row>;
+    setRows(rows: Map<number, Row>): void;
+    getColumns(): Map<string, ColumnSchema>;
+}
+
+type CollectionScope = 'active' | 'all' | string[];
+declare class Table {
+    readonly id: string;
+    private collection;
+    private pagination;
+    private action;
+    private activeCollection;
+    constructor(id: string, collection: Map<string, Collection>, pagination: Pagination, action: TableActions, activeCollection?: string);
+    private getActiveCollection;
+    private getCollection;
+    /** Finds which Collection currently owns a given column id (if any). */
+    private findCollectionForColumn;
+    getCollections(): Map<string, Collection>;
+    getColumnSchema(columnId: ColumnId): ColumnSchema | undefined;
+    getActiveCollectionName(): string;
+    setActiveCollection(activeCollection: string): void;
+    getRowCollection(rowId: number): string | undefined;
+    setRowCollection(rowId: number, collection: string): void;
+    setColumnSchema(columnId: ColumnId, DetailColumnConfig: ColumnSchema): ColumnSchema | undefined;
+    getColumns(): ColumnSchema[];
+    getActiveCollectionColumns(): ColumnSchema[];
+    getColumnsForCollectionScope(collectionScope?: CollectionScope): ColumnSchema[];
+    getColumnValues(colId: string): unknown[];
+    setColumns(newColumns: ColumnSchema[]): void;
+    changeCell(rowId: RowId, columnId: ColumnId, value: unknown): CellChanged | null;
+    changeDisplay(rowId: RowId, columnId: ColumnId, value: unknown): DisplayChanged | null;
+    saveDescription(rowId: RowId, flag: boolean): DescriptionSaved | null;
+    duplicateRow(rowId: RowId): RowAdded;
+    addRow(targetRowId: number, placedRowId?: number): RowAdded;
+    addNewRow(data?: KeyValue[]): RowAdded;
+    addNewRows(cmd: {
+        rows: KeyValue[][];
+        detailFieldKey: string;
+    }): RowAdded[];
+    addColumns(newColumns: ColumnSchema[]): {
+        added: ColumnId[];
+    };
+    removeColumns(columnIds: ColumnId[]): {
+        removed: ColumnId[];
+    };
+    getRows(collectionScope?: CollectionScope): Row[];
+    getCollectionsRows(collections: string[]): Row[];
+    getRow(rowId: number): Row | undefined;
+    addRows(newRows: Row[]): void;
+    getPagination(): Pagination;
+    setPagination(pagination: Pagination): void;
+    changePage(page: number): void;
+    changePageSize(size: number): void;
+    getVisibleRows(): Row[];
+    setTableAction(action: TableActions): void;
+    getTableAction(): TableActions;
+    /**
+     * Re-inserts a previously Added row after hard-remove (undo of ADD → redo).
+     * Preserves rowId and cell values; no-ops if the id already exists.
+     */
+    restoreAddedRow(params: {
+        rowId: number;
+        cells: Readonly<Record<string, {
+            readonly value: unknown;
+            readonly display?: unknown;
+            readonly originalValue?: unknown;
+        }>>;
+        collection?: string;
+        isSaveDescription?: boolean;
+    }): RowAdded;
+    deleteRow(rowId: RowId): RowDeleted | RowRestored | RowRemoved | MinimumRowConstraintViolated | null;
+    reorderRows(draggedRowNum: number, droppedRowNum: number, position?: 'before' | 'after'): RowReordered;
+    reorderColumns(sourceIndex: number, destIndex: number): ColumnReordered;
+    clone(): Table;
+}
+
+interface TableRepository {
+    getById(store: string, tableKey: string): Promise<Table>;
+    save(store: string, table: Table): Promise<void>;
+    delete(store: string, tableKey: string): Promise<void>;
+    resetTable(store: string, tableKey: string): Promise<void>;
+    exists(store: string, tableKey: string): Promise<boolean>;
+    getFromDbById?(store: string, tableKey: string): Promise<Table>;
+}
+
+/**
+ * Host-agnostic request config shape used by UI multi-select bindings.
+ * Host apps may narrow this to their own IRequestConfig.
+ */
+type IRequestConfig = {
+    endpoint?: string;
+    params?: Record<string, unknown>;
+    method?: 'GET' | 'POST';
+    [key: string]: unknown;
+};
+
+interface UIRow {
+    id: number;
+    cells: Record<string, TCell>;
+    rowState: RowStateEnum;
+    isExpanded: boolean;
+    changeFields: readonly string[];
+    visibilityCondition: Record<string, boolean>;
+}
+type MultiSelectDependOn = {
+    fieldName: string;
+    value: unknown;
+};
+interface IMultiSelectConfig {
+    dynamicValue: IRequestConfig & {
+        dependsOn?: string[];
+        dependOn?: MultiSelectDependOn | MultiSelectDependOn[];
+    };
+    fieldKey: string;
+    detailFieldKey: string;
+    onAdd: (e: any) => void;
+    ListConfig: {
+        fieldName: string;
+        fieldCaption: string;
+        fieldType: FieldType;
+        hidden?: boolean;
+        returnValue?: (row: Record<string, unknown>[], colId: string) => unknown;
+        returnDisplayValue?: (row: Record<string, unknown>[], colId: string) => unknown;
+    }[];
+}
+
+type GridSearchMatch = {
+    rowId: number;
+    columnId: string;
+};
+type GridSearchState = {
+    columnId: string;
+    query: string;
+    matches: GridSearchMatch[];
+    currentIndex: number;
+} | null;
+type MobileEditorState = {
+    mode: 'add' | 'edit';
+    rowId: number;
+} | null;
+type TableViewState = {
+    activeCell: ActiveCell;
+    selectedRows: Record<number, true>;
+    rows: UIRow[];
+    deletedRows: Array<{
+        id: string;
+        cells: Record<string, unknown>;
+        isExpanded: boolean;
+    }>;
+    columns: ColumnSchema[];
+    activeCollectionColumn: ColumnSchema[];
+    pagination: {
+        page: number;
+        pageSize: number;
+        totalRows: number;
+        totalPages: number;
+        canPrev: boolean;
+        canNext: boolean;
+    };
+    action: TableActions;
+    gridSearch: GridSearchState;
+    mobileEditor: MobileEditorState;
+};
+type MobileTableViewState = {
+    rows: UIRow[];
+    columns: ColumnSchema[];
+    totalRows: number;
+    visibleCount: number;
+    hasMore: boolean;
+    pageSize: number;
+    mobileEditor: MobileEditorState;
+};
+type TableSnapShot = {
+    rows: Array<{
+        id: number;
+        cells: Record<string, unknown>;
+        rowState: RowStateEnum;
+        collection: string;
+        rowType?: string;
+        changeFields: readonly string[];
+        isSaveDescription: boolean;
+    }>;
+};
+type ActiveCell = {
+    rowId: number;
+    columnId: string;
+} | null;
+type ValidCell = {
+    isValid: boolean;
+    cellError: CellError;
+};
+type TableState = {
+    table: Table;
+    expandedRows: Record<string, boolean>;
+    selectedRows: Record<number, true>;
+    activeRowId: number | undefined;
+    activeCell: ActiveCell | undefined;
+    rangeAnchorRowId: number | undefined;
+    gridSearch: GridSearchState;
+    mobileEditor: MobileEditorState;
+};
+type TCell = {
+    value: unknown;
+    originalValue: unknown;
+    display: unknown;
+};
+type ItemType = {
+    type?: 'submenu' | 'item' | 'group' | 'divider';
+    label?: React.ReactNode;
+    children?: ItemType[];
+    disabled?: boolean;
+    ref?: React.Ref<HTMLLIElement | null>;
+    style?: React.CSSProperties;
+    className?: string;
+    isSelected?: boolean;
+    isOpen?: boolean;
+    isSubMenu?: boolean;
+    danger?: boolean;
+    icon?: React.ReactNode;
+    title?: string;
+    key: string;
+    theme?: 'dark' | 'light';
+    dashed?: boolean;
+    rootClassName?: string;
+    itemIcon?: React.ReactNode;
+    expandIcon?: React.ReactNode;
+    popupClassName?: string;
+    popupOffset?: number[];
+    popupStyle?: React.CSSProperties;
+    onClick?: () => void;
+    extra?: React.ReactNode;
+};
+type ValidationCallback = (result: ValidationCallbackResult) => void;
+type ValidationCallbackResult = {
+    valid: boolean;
+    errors?: Map<string, CellError>;
+    data?: any;
+};
+interface CellError {
+    rowId: number;
+    caption: string;
+    message: string;
+}
+
+interface BaseTableCommand {
+    readonly store: string;
+    readonly tableKey: string;
+    /** When set, undoable events from separate executes merge into one undo unit. */
+    readonly correlationId?: string;
+}
+type Actor = {
+    readonly userId: string;
+    readonly roles: string[];
+};
+/**
+ * Base invariant:
+ * هر Command دقیقاً متعلق به یک Table است
+ */
+interface MoveActiveCellCommand {
+    readonly type: 'MOVE_ACTIVE_CELL';
+    readonly store: string;
+    readonly tableKey: string;
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly direction: 'next' | 'prev';
+}
+interface MoveActiveCellVerticalCommand {
+    readonly type: 'MOVE_ACTIVE_CELL_VERTICAL';
+    readonly store: string;
+    readonly tableKey: string;
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly direction: 'up' | 'down';
+}
+interface MoveVerticalSelectedRows {
+    readonly type: 'MOVE_VERTICAL_SELECTED_ROWS';
+    readonly tableKey: string;
+    readonly direction: 'up' | 'down';
+}
+interface MoveVerticalActiveRow {
+    readonly type: 'MOVE_VERTICAL_ACTIVE_ROW';
+    readonly tableKey: string;
+    readonly direction: 'up' | 'down';
+}
+interface ActiveCellCommand {
+    readonly type: 'ACTIVE_CELL';
+    readonly tableKey: string;
+    readonly rowId: number;
+    readonly columnId: string;
+}
+interface ActiveRowCommand extends BaseTableCommand {
+    readonly type: 'ACTIVE_ROW';
+    readonly tableKey: string;
+    readonly rowId: number;
+}
+interface ActiveFirstCellCommand {
+    readonly type: 'ACTIVATE_FIRST_CELL';
+    readonly tableKey: string;
+    readonly rowId: number;
+}
+interface ChangeCellValueCommand extends BaseTableCommand {
+    readonly type: 'CHANGE_CELL_VALUE';
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly newValue: unknown;
+}
+interface SaveDescriptionCommand extends BaseTableCommand {
+    readonly type: 'SAVE_DESCRIPTION';
+    readonly rowId: number;
+    readonly flag: boolean;
+}
+interface ChangeCellDisplayValueCommand extends BaseTableCommand {
+    readonly type: 'CHANGE_CELL_DISPLAY_VALUE';
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly newValue: string;
+}
+interface AddEmptyRowCommand extends BaseTableCommand {
+    readonly type: 'ADD_EMPTY_ROW';
+    readonly autoActivate: boolean;
+}
+interface AddNewRowsCommand extends BaseTableCommand {
+    readonly type: 'ADD_NEW_ROWS';
+    readonly detailFieldKey: string;
+    readonly rows: {
+        key: string;
+        value: unknown;
+        display: unknown;
+    }[][];
+    readonly autoActivate?: boolean;
+}
+interface DuplicateRowCommand extends BaseTableCommand {
+    readonly type: 'DUPLICATE_ROW';
+    readonly rowId: number;
+}
+/**
+ * Clone one source row (clipboard paste). Engine batches these with a shared
+ * correlationId so undo reverses the whole paste unit.
+ */
+interface PasteRowCommand extends BaseTableCommand {
+    readonly type: 'PASTE_ROW';
+    readonly sourceRowId: number;
+    /** When set (pasteInsert), place the clone relative to this row. */
+    readonly placeAtRowId?: number;
+}
+interface DeleteRowCommand extends BaseTableCommand {
+    readonly type: 'ROW_DELETED';
+    readonly rowId: number;
+}
+/** Undo-stack redo: re-insert a previously added row with original identity/values. */
+interface RestoreAddedRowCommand extends BaseTableCommand {
+    readonly type: 'RESTORE_ADDED_ROW';
+    readonly rowId: number;
+    readonly cells: Readonly<Record<string, {
+        readonly value: unknown;
+        readonly display?: unknown;
+        readonly originalValue?: unknown;
+    }>>;
+    readonly collection?: string;
+    readonly isSaveDescription?: boolean;
+}
+interface DeleteRowsCommand extends BaseTableCommand {
+    readonly type: 'ROWS_DELETED';
+}
+interface ExpandRowCommand {
+    readonly type: 'ROW_EXPANDED';
+    readonly tableKey: string;
+    readonly rowId: number;
+    readonly value: boolean;
+}
+interface SelectRowCommand {
+    readonly type: 'ROW_SELECTED';
+    readonly tableKey: string;
+    readonly rowId: number;
+}
+interface ToggleRowSelectionCommand {
+    readonly type: "ROW_SELECTION_TOGGLED";
+    readonly tableKey: string;
+    readonly rowId: number;
+}
+interface ToggleRowExpandCommand {
+    readonly type: 'ROW_EXPAND_TOGGLED';
+    readonly tableKey: string;
+    readonly rowId: number;
+}
+interface SelectRangeCommand {
+    readonly type: "ROW_RANGE_SELECTED";
+    readonly tableKey: string;
+    readonly rowId: number;
+}
+interface SelectActiveRowToLastCommand {
+    readonly type: "SELECT_FROM_ACTIVE_TO_LAST";
+    readonly tableKey: string;
+    readonly anchorRowId: number;
+}
+interface RowReorderedCommand extends BaseTableCommand {
+    readonly type: 'ROW_REORDERED';
+    readonly draggedRowId: number;
+    readonly droppedRowId: number;
+    readonly position: 'before' | 'after';
+}
+interface SelectAllRowsCommand {
+    readonly type: 'TOGGLE_SELECT_ALL_ROWS';
+    readonly tableKey: string;
+}
+interface SelectPageRowsCommand {
+    readonly type: 'TOGGLE_SELECT_PAGE_ROWS';
+    readonly tableKey: string;
+}
+interface CollapseAllRowsCommand {
+    readonly type: 'COLLAPSE_ALL_ROWS';
+    readonly tableKey: string;
+}
+interface ColumnReorderedCommand extends BaseTableCommand {
+    readonly type: 'COLUMN_REORDERED';
+    readonly sourceIndex: number;
+    readonly destIndex: number;
+}
+interface DeleteTableCommand extends BaseTableCommand {
+    readonly type: 'TABLE_DELETED';
+}
+interface SetActiveCollectionCommand extends BaseTableCommand {
+    readonly type: 'SET_ACTIVE_COLLECTION';
+    readonly activeCollection: string;
+}
+interface ResetTableCommand extends BaseTableCommand {
+    readonly type: 'TABLE_RESET';
+    readonly rowId: string;
+}
+interface RegisterTableCommand extends BaseTableCommand {
+    readonly type: 'TABLE_REGISTERED';
+    readonly store: string;
+    readonly table: Table;
+}
+interface DisposeTableCommand extends BaseTableCommand {
+    readonly type: 'TABLE_DISPOSED';
+}
+interface ChangeTableActionCommand extends BaseTableCommand {
+    readonly type: 'SET_TABLE_ACTION';
+    action: TableActions;
+}
+interface ChangePageCommand extends BaseTableCommand {
+    readonly type: 'CHANGE_PAGE';
+    readonly page: number;
+}
+interface ChangePageSizeCommand extends BaseTableCommand {
+    readonly type: 'CHANGE_PAGE_SIZE';
+    readonly pageSize: number;
+}
+interface ChangeUnitLevelCommand extends BaseTableCommand {
+    readonly type: 'SET_UNIT_LEVEL';
+    readonly level: number;
+}
+interface ApplyDynamicProjectionCommand extends BaseTableCommand {
+    readonly type: 'APPLY_DYNAMIC_PROJECTION';
+    readonly tableKey: string;
+    readonly rowId: number;
+    readonly columnId: string;
+}
+interface SetGridSearchCommand {
+    readonly type: 'SET_GRID_SEARCH';
+    readonly tableKey: string;
+    readonly search: GridSearchState;
+}
+interface SetMobileEditorCommand {
+    readonly type: 'SET_MOBILE_EDITOR';
+    readonly tableKey: string;
+    readonly editor: MobileEditorState;
+}
+type EngineTableCommand = SelectActiveRowToLastCommand | SelectRangeCommand | ToggleRowExpandCommand | SelectRowCommand | ColumnReorderedCommand | CollapseAllRowsCommand | RegisterTableCommand | DisposeTableCommand | DeleteRowsCommand | ToggleRowSelectionCommand | SelectAllRowsCommand | SelectPageRowsCommand | ActiveCellCommand | ActiveRowCommand | MoveActiveCellCommand | MoveActiveCellVerticalCommand | MoveVerticalSelectedRows | MoveVerticalActiveRow | ActiveFirstCellCommand | ExpandRowCommand | ChangeTableActionCommand | SetGridSearchCommand | SetMobileEditorCommand;
+type ApplicationTableCommand = ChangeCellValueCommand | SaveDescriptionCommand | ChangeCellDisplayValueCommand | AddEmptyRowCommand | AddNewRowsCommand | DuplicateRowCommand | PasteRowCommand | DeleteRowCommand | RestoreAddedRowCommand | DeleteTableCommand | SetActiveCollectionCommand | ResetTableCommand | RowReorderedCommand | ChangePageCommand | ChangePageSizeCommand | ApplyDynamicProjectionCommand | ChangeUnitLevelCommand;
+type TableCommand = EngineTableCommand | ApplicationTableCommand;
+
+interface BaseTableEvent {
+    readonly tableId: string;
+    readonly type: string;
+}
+interface CellChangedEvent extends BaseTableEvent {
+    type: 'CELL_CHANGED';
+    rowId: number;
+    columnId: string;
+    newValue: unknown;
+    previousValue: unknown;
+}
+interface DynamicProjectionEvent extends BaseTableEvent {
+    type: 'DYNAMIC_PROJECTION_DONE';
+    rowId: number;
+    columnId: string;
+}
+interface CellDisplayChangedEvent extends BaseTableEvent {
+    type: 'CELL_DISPLAY_CHANGED';
+    rowId: number;
+    columnId: string;
+    newValue: unknown;
+}
+interface RowAddedEvent extends BaseTableEvent {
+    type: 'ROW_ADDED';
+    rowId: string;
+}
+interface NewRowAddedEvent extends BaseTableEvent {
+    type: 'NEW_ROW_ADDED';
+    rowId: string;
+}
+interface RowDeletedEvent extends BaseTableEvent {
+    type: 'ROW_DELETED';
+    rowId: string;
+}
+interface NewRowRemovedEvent extends BaseTableEvent {
+    type: 'NEW_ROW_REMOVED';
+    rowId: string;
+}
+interface RowRestoredEvent extends BaseTableEvent {
+    type: 'ROW_RESTORED';
+    rowId: string;
+}
+interface RowReorderedEvent extends BaseTableEvent {
+    type: 'ROW_REORDERED';
+    sourceIndex: number;
+    destIndex: number;
+}
+interface RowDescriptionSaved extends BaseTableEvent {
+    type: 'ROW_DESCRIPTION_SAVED';
+    rowId: number;
+    description: boolean;
+}
+interface ColumnReorderedEvent extends BaseTableEvent {
+    type: 'COLUMN_REORDERED';
+    sourceIndex: number;
+    destIndex: number;
+}
+interface UnitColumnAddedEvent extends BaseTableEvent {
+    type: 'UNIT_COLUMN_ADDED';
+    reason: string;
+    details?: unknown;
+}
+interface PageChangedEvent extends BaseTableEvent {
+    type: 'PAGE_CHANGED';
+    page: number;
+}
+interface PageSizeChangedEvent extends BaseTableEvent {
+    type: 'PAGE_SIZE_CHANGED';
+    tableId: string;
+    pageSize: number;
+}
+interface TableDeletedEvent extends BaseTableEvent {
+    type: 'TABLE_DELETED';
+    tableId: string;
+}
+interface TableResetEvent extends BaseTableEvent {
+    type: 'TABLE_RESET';
+    tableId: string;
+}
+interface ActiveCollectionChangedEvent extends BaseTableEvent {
+    type: 'ACTIVE_COLLECTION_CHANGED';
+    tableId: string;
+}
+interface RowsLoadedEvent extends BaseTableEvent {
+    type: 'ROWS_LOADED';
+    count: number;
+}
+interface DynamicDataRequestedEvent extends BaseTableEvent {
+    type: 'DYNAMIC_DATA_REQUESTED';
+    requestId: string;
+    sourceColumn: string;
+    value: unknown;
+}
+interface ValidationFailedEvent extends BaseTableEvent {
+    type: 'VALIDATION_FAILED';
+    reason: string;
+    details?: unknown;
+}
+type TableEvent = CellChangedEvent | DynamicProjectionEvent | CellDisplayChangedEvent | RowAddedEvent | NewRowAddedEvent | RowDeletedEvent | NewRowRemovedEvent | RowRestoredEvent | RowReorderedEvent | RowDescriptionSaved | ColumnReorderedEvent | UnitColumnAddedEvent | PageChangedEvent | PageSizeChangedEvent | RowsLoadedEvent | DynamicDataRequestedEvent | ValidationFailedEvent | TableDeletedEvent | ActiveCollectionChangedEvent | TableResetEvent;
+
+type DynamicConfig = {
+    columnMeta: Map<string, ColumnSchema>;
+    remoteApi: RemoteApi;
+};
+declare class ChangeCellValueHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permissionPolicy;
+    private readonly dynamic?;
+    constructor(repo: TableRepository, audit: AuditLogger, permissionPolicy: PermissionPolicy, dynamic?: DynamicConfig | undefined);
+    execute(command: ChangeCellValueCommand, actor: Actor$1): Promise<TableEvent[]>;
+    private applyRemoteVisibilityRules;
+    private applyComputedColumns;
+    private validateCellValue;
+    private applyDynamicProjection;
+}
+declare class ChangeCellDisplayValueHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permissionPolicy;
+    constructor(repo: TableRepository, audit: AuditLogger, permissionPolicy: PermissionPolicy);
+    execute(command: ChangeCellDisplayValueCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+declare class SaveDescriptionHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permissionPolicy;
+    constructor(repo: TableRepository, audit: AuditLogger, permissionPolicy: PermissionPolicy);
+    execute(command: SaveDescriptionCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+declare class ApplyDynamicProjectionHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permissionPolicy;
+    private readonly dynamic?;
+    constructor(repo: TableRepository, audit: AuditLogger, permissionPolicy: PermissionPolicy, dynamic?: DynamicConfig | undefined);
+    execute(command: ApplyDynamicProjectionCommand, actor: Actor$1): Promise<TableEvent[]>;
+    private applyRemoteVisibilityRules;
+    private applyComputedColumns;
+    private validateCellValue;
+    private applyDynamicProjection;
+}
+
+declare class AddNewRowCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permission;
+    constructor(repo: TableRepository, audit: AuditLogger, permission: PermissionPolicy);
+    execute(command: AddEmptyRowCommand, actor: Actor$1): Promise<RowAdded | null>;
+}
+declare class AddNewRowsCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permission;
+    constructor(repo: TableRepository, audit: AuditLogger, permission: PermissionPolicy);
+    execute(command: AddNewRowsCommand, actor: Actor$1): Promise<RowAdded[] | null>;
+}
+declare class PasteRowCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permission;
+    constructor(repo: TableRepository, audit: AuditLogger, permission: PermissionPolicy);
+    execute(command: PasteRowCommand, actor: Actor$1): Promise<RowAdded | null>;
+}
+declare class DuplicateRowCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permission;
+    constructor(repo: TableRepository, audit: AuditLogger, permission: PermissionPolicy);
+    execute(command: DuplicateRowCommand, actor: Actor$1): Promise<RowAdded | null>;
+}
+declare class DeleteRowCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permission;
+    constructor(repo: TableRepository, audit: AuditLogger, permission: PermissionPolicy);
+    execute(command: DeleteRowCommand, actor: Actor$1): Promise<RowDeleted | RowRemoved | MinimumRowConstraintViolated | RowRestored | null>;
+}
+declare class RestoreAddedRowCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permission;
+    constructor(repo: TableRepository, audit: AuditLogger, permission: PermissionPolicy);
+    execute(command: RestoreAddedRowCommand, actor: Actor$1): Promise<RowAdded | null>;
+}
+declare class ReorderRowCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permission;
+    constructor(repo: TableRepository, audit: AuditLogger, permission: PermissionPolicy);
+    execute(command: RowReorderedCommand, actor: Actor$1): Promise<RowReordered | null>;
+}
+
+declare class ChangeUnitLevelHandler {
+    private readonly repo;
+    private readonly audit;
+    constructor(repo: TableRepository, audit: AuditLogger);
+    execute(command: ChangeUnitLevelCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+declare class ChangePageCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    constructor(repo: TableRepository, audit: AuditLogger);
+    execute(command: ChangePageCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+declare class ChangePageSizeCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    constructor(repo: TableRepository, audit: AuditLogger);
+    execute(command: ChangePageSizeCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+declare class DeleteTableCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permissionPolicy;
+    constructor(repo: TableRepository, audit: AuditLogger, permissionPolicy: PermissionPolicy);
+    execute(command: DeleteTableCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+declare class ResetTableCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    private readonly permissionPolicy;
+    constructor(repo: TableRepository, audit: AuditLogger, permissionPolicy: PermissionPolicy);
+    execute(command: ResetTableCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+declare class SetActiveCollectionCommandHandler {
+    private readonly repo;
+    private readonly audit;
+    constructor(repo: TableRepository, audit: AuditLogger);
+    private applyVisibility;
+    execute(command: SetActiveCollectionCommand, actor: Actor$1): Promise<TableEvent[]>;
+}
+
+interface GridEvent<TType extends string = string, TPayload = unknown> {
+    readonly eventId: string;
+    readonly type: TType;
+    readonly tableId: string;
+    readonly streamId: string;
+    readonly version: number;
+    readonly occurredAt: number;
+    readonly actorId: string;
+    readonly payload: TPayload;
+    readonly correlationId?: string;
+    readonly causationId?: string;
+}
+interface ExportRequestedPayload {
+    readonly format: 'xlsx' | 'pdf';
+    readonly collectionScope: 'active' | 'all' | string[];
+    readonly fileName?: string;
+    readonly sheetName?: string;
+    readonly direction?: 'rtl' | 'ltr';
+}
+interface ImportRequestedPayload {
+    readonly format: 'xlsx';
+    readonly collectionScope: 'active' | 'all' | string[];
+    readonly sheetName?: string;
+    readonly byteLength?: number;
+}
+
+type AppendResult = {
+    ok: true;
+    version: number;
+} | {
+    ok: false;
+    conflict: {
+        expectedVersion: number;
+        actualVersion: number;
+    };
+};
+type Unsubscribe = () => void;
+interface EventStore {
+    append(streamId: string, events: GridEvent[], expectedVersion: number): Promise<AppendResult>;
+    read(streamId: string, fromVersion?: number): Promise<GridEvent[]>;
+    /** Ordered global stream for catch-up of cross-stream projections. */
+    readAll(fromPosition?: number): Promise<GridEvent[]>;
+    subscribe(streamId: string, onEvent: (event: GridEvent) => void): Unsubscribe;
+    subscribeAll(onEvent: (event: GridEvent) => void): Unsubscribe;
+}
+
+interface CellUndoEntry {
+    readonly kind: 'CELL_CHANGED';
+    readonly tableId: string;
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly newValue: unknown;
+    readonly previousValue: unknown;
+}
+type RowCellSnapshot = {
+    readonly value: unknown;
+    readonly display?: unknown;
+    readonly originalValue?: unknown;
+};
+interface RowAddedUndoEntry {
+    readonly kind: 'ROW_ADDED';
+    readonly tableId: string;
+    readonly rowId: number;
+    /** Captured at record time so redo can restore identity + values. */
+    readonly cells: Readonly<Record<string, RowCellSnapshot>>;
+    readonly collection?: string;
+    readonly isSaveDescription?: boolean;
+}
+/**
+ * Compensating entry for a delete:
+ * - soft: Unchanged→Deleted (undo/redo = toggle ROW_DELETED)
+ * - hard: Added row removed from map (undo = RESTORE_ADDED_ROW)
+ */
+interface RowDeletedUndoEntry {
+    readonly kind: 'ROW_DELETED';
+    readonly tableId: string;
+    readonly rowId: number;
+    readonly mode: 'soft' | 'hard';
+    readonly cells: Readonly<Record<string, RowCellSnapshot>>;
+    readonly collection?: string;
+    readonly isSaveDescription?: boolean;
+}
+type AtomicUndoEntry = CellUndoEntry | RowAddedUndoEntry | RowDeletedUndoEntry;
+type UndoDispatchCommand = {
+    type: 'CHANGE_CELL_VALUE';
+    store: string;
+    tableKey: string;
+    rowId: number;
+    columnId: string;
+    newValue: unknown;
+} | {
+    type: 'ROW_DELETED';
+    store: string;
+    tableKey: string;
+    rowId: number;
+} | {
+    type: 'RESTORE_ADDED_ROW';
+    store: string;
+    tableKey: string;
+    rowId: number;
+    cells: Readonly<Record<string, RowCellSnapshot>>;
+    collection?: string;
+    isSaveDescription?: boolean;
+};
+type CellUndoDispatch = (command: UndoDispatchCommand) => Promise<void>;
+/**
+ * Compensating undo/redo stack for domain edits.
+ * - CELL_CHANGED: restore previousValue / re-apply newValue
+ * - ROW_ADDED: delete on undo; RESTORE_ADDED_ROW on redo
+ * - ROW_DELETED soft: toggle ROW_DELETED; hard: RESTORE_ADDED_ROW / ROW_DELETED
+ * - Same correlationId merges into one undo unit (paste / cut+paste)
+ */
+declare class CellUndoStack {
+    private undoEntries;
+    private redoEntries;
+    private applying;
+    record(event: CellChangedEvent, correlationId?: string): void;
+    recordRowAdded(event: {
+        tableId: string;
+        rowId: number;
+        cells?: Readonly<Record<string, RowCellSnapshot>>;
+        collection?: string;
+        isSaveDescription?: boolean;
+    }, correlationId?: string): void;
+    recordRowDeleted(event: {
+        tableId: string;
+        rowId: number;
+        mode: 'soft' | 'hard';
+        cells?: Readonly<Record<string, RowCellSnapshot>>;
+        collection?: string;
+        isSaveDescription?: boolean;
+    }, correlationId?: string): void;
+    recordMany(entries: AtomicUndoEntry[], correlationId?: string): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undoDepth(): number;
+    redoDepth(): number;
+    undo(store: string, dispatch: CellUndoDispatch): Promise<boolean>;
+    redo(store: string, dispatch: CellUndoDispatch): Promise<boolean>;
+    clear(): void;
+    private pushAtomic;
+    private applyCompensating;
+    private applyForward;
+}
+
+declare class TableAppService {
+    private readonly changeCellValue;
+    private readonly changeCellDisplayValue;
+    private readonly saveDescription;
+    private readonly addEmptyRow;
+    private readonly addNewRows;
+    private readonly duplicateRow;
+    private readonly deleteRow;
+    private readonly reorderRow;
+    private readonly setUnitLevel;
+    private readonly setPageSize;
+    private readonly setPage;
+    private readonly setActiveCollection;
+    private readonly deleteTable;
+    private readonly resetTable;
+    private readonly applyDynamicProjection;
+    private readonly restoreAddedRow?;
+    private readonly pasteRow?;
+    private eventStore?;
+    private undoStack?;
+    private repo?;
+    constructor(changeCellValue: ChangeCellValueHandler, changeCellDisplayValue: ChangeCellDisplayValueHandler, saveDescription: SaveDescriptionHandler, addEmptyRow: AddNewRowCommandHandler, addNewRows: AddNewRowsCommandHandler, duplicateRow: DuplicateRowCommandHandler, deleteRow: DeleteRowCommandHandler, reorderRow: ReorderRowCommandHandler, setUnitLevel: ChangeUnitLevelHandler, setPageSize: ChangePageSizeCommandHandler, setPage: ChangePageCommandHandler, setActiveCollection: SetActiveCollectionCommandHandler, deleteTable: DeleteTableCommandHandler, resetTable: ResetTableCommandHandler, applyDynamicProjection: ApplyDynamicProjectionHandler, restoreAddedRow?: RestoreAddedRowCommandHandler | undefined, pasteRow?: PasteRowCommandHandler | undefined);
+    setEventStore(eventStore: EventStore): void;
+    setUndoStack(undoStack: CellUndoStack): void;
+    setRepository(repo: TableRepository): void;
+    execute(command: ApplicationTableCommand, actor: Actor): Promise<RowAdded | RowDeleted | RowRemoved | MinimumRowConstraintViolated | RowRestored | RowReordered | RowAdded[] | TableEvent[] | null>;
+    private dispatch;
+    private recordUndoableEvents;
+    private captureRowSnapshot;
+    private appendToEventStore;
+    private normalizeResult;
+    private resolveRowId;
+    private toGridPayload;
+    private createCorrelationId;
+}
+
+declare class ConsoleAuditLogger implements AuditLogger {
+    log(event: unknown): void;
+    error(event: unknown): void;
+    warn(event: unknown): void;
+    info(event: unknown): void;
+}
+
+declare class TableEngine {
+    private readonly app;
+    private readonly repo;
+    private readonly actor;
+    private tableStore?;
+    private tableKey?;
+    readonly errors: Map<string, CellError>;
+    readonly searchResult: Map<string, CellError>;
+    private readonly errHandler;
+    private readonly selection;
+    private readonly rowMgr;
+    private readonly nav;
+    private readonly viewBuilder;
+    constructor(app: TableAppService, repo: TableRepository, actor: Actor, audit: ConsoleAuditLogger);
+    private registerTable;
+    private deleteTable;
+    private disposeTable;
+    private resetTable;
+    private getStore;
+    /**
+     * Default case در dispatch:
+     * command را به AppService می‌دهد و سپس repo را reload می‌کند.
+     */
+    private executeAppCommand;
+    /**
+     * Paste goes through AppService (PASTE_ROW + optional ROW_DELETED for cut)
+     * with one correlationId so undo reverses the whole unit.
+     */
+    private executePasteAction;
+    dispatch(command: TableCommand): Promise<void>;
+    private setGridSearch;
+    private setMobileEditor;
+    getViewState(): TableViewState | undefined;
+    getAllRows(): Row[] | null;
+    getAllUIRows(): UIRow[] | null;
+    getMobileViewState(): MobileTableViewState | undefined;
+    getRowView(rowId: number): UIRow | null;
+    getSnapShot(collectionScope: CollectionScope): TableSnapShot | null;
+    getExpandedRowData(rowId: number): Record<string, unknown> | null;
+    getActiveCell(): TableState['activeCell'] | null;
+    getActiveRow(): number | null;
+    getSelectedRows(): Record<number, boolean> | undefined;
+    getCell(rowId: number, columnId: string): Cell | undefined;
+    getMobileEditor(): TableState['mobileEditor'] | undefined;
+    isActiveCell(rowId: number, columnId: string): boolean;
+    isSelectedRow(rowId: number): boolean;
+    isCutRow(rowId: number): boolean;
+    isActiveRow(rowId: number): boolean;
+    private validateCell;
+    validation(cb: ValidationCallback): void;
+    isValidCell(rowId: number, caption: string): ValidCell;
+    subscribe(cb: () => void): (() => void) | null;
+    /**
+     * Selector-based subscription over engine-derived view data.
+     * `selector` closes over engine getters (snapshot, activeCell, …).
+     */
+    subscribeSelected<TSelected>(selector: () => TSelected, listener: (selected: TSelected) => void, isEqual?: (a: TSelected, b: TSelected) => boolean): (() => void) | null;
+    subscribeColumn<T = unknown>(columnId: string, collections: CollectionScope, cb: (items: Array<{
+        id: number;
+        rowNum: unknown;
+        value: T;
+    }>) => void): (() => void) | null;
+}
+
+interface ChangelogEntry {
+    readonly eventId: string;
+    readonly type: string;
+    readonly tableId: string;
+    readonly occurredAt: number;
+    readonly actorId: string;
+    readonly payload: unknown;
+}
+interface ChangelogQuery {
+    tableId?: string;
+    rowId?: number | string;
+    columnId?: string;
+    type?: string;
+    since?: number;
+    limit?: number;
+}
+declare class ChangelogProjection {
+    private readonly eventStore;
+    private entries;
+    private unsubscribe;
+    private subscribers;
+    private seenEventIds;
+    private started;
+    constructor(eventStore: EventStore);
+    /**
+     * Catch up via readAll, then subscribe for live events.
+     * Dedupes by eventId so subscribe-before-replay races are safe.
+     */
+    start(): Promise<void>;
+    stop(): void;
+    query(filter?: ChangelogQuery): ChangelogEntry[];
+    count(filter?: ChangelogQuery): number;
+    subscribe(notify: (entries: ChangelogEntry[]) => void, filter?: ChangelogQuery): Unsubscribe;
+    clear(): void;
+    private project;
+    private notifySubscribers;
+}
+
+type HistorySeverity = 'info' | 'warning' | 'error';
+type HistoryCategory = 'data' | 'structure' | 'view' | 'system';
+interface HistoryQuery extends ChangelogQuery {
+    severity?: HistorySeverity;
+    category?: HistoryCategory;
+}
+interface HistoryItem {
+    readonly id: string;
+    readonly type: string;
+    readonly title: string;
+    readonly description: string;
+    readonly occurredAt: number;
+    readonly tableId: string;
+    readonly actorId: string;
+    readonly severity: HistorySeverity;
+    readonly category: HistoryCategory;
+    readonly raw: ChangelogEntry;
+}
+declare class HistoryPanelViewModel {
+    private readonly changelogProjection;
+    constructor(changelogProjection: ChangelogProjection);
+    query(filter?: HistoryQuery): HistoryItem[];
+    count(filter?: HistoryQuery): number;
+    subscribe(cb: (items: HistoryItem[]) => void, filter?: HistoryQuery): Unsubscribe;
+    private toHistoryItem;
+}
+
+/**
+ * Session-centric view / keyboard intents.
+ * These are not domain commands; GridSession maps them to engine dispatches.
+ */
+type ViewIntent = {
+    type: 'ADD_EMPTY_ROW';
+    autoActivate?: boolean;
+} | {
+    type: 'DUPLICATE_ROW';
+    rowId: number;
+} | {
+    type: 'DELETE_ROW';
+    rowId: number;
+} | {
+    type: 'TOGGLE_ROW_SELECTION';
+    rowId: number;
+} | {
+    type: 'SELECT_FROM_ACTIVE_TO_LAST';
+    anchorRowId: number;
+} | {
+    type: 'ACTIVATE_FIRST_CELL';
+    rowId: number;
+} | {
+    type: 'MOVE_ACTIVE_CELL';
+    rowId: number;
+    columnId: string;
+    direction: 'next' | 'prev';
+} | {
+    type: 'MOVE_ACTIVE_CELL_VERTICAL';
+    rowId: number;
+    columnId: string;
+    direction: 'up' | 'down';
+} | {
+    type: 'MOVE_VERTICAL_SELECTED_ROWS';
+    direction: 'up' | 'down';
+} | {
+    type: 'MOVE_VERTICAL_ACTIVE_ROW';
+    direction: 'up' | 'down';
+} | {
+    type: 'COLLAPSE_ALL_ROWS';
+} | {
+    type: 'CHANGE_PAGE';
+    page: number;
+} | {
+    type: 'CHANGE_PAGE_SIZE';
+    pageSize: number;
+} | {
+    type: 'SET_TABLE_ACTION';
+    action: TableActions;
+} | {
+    type: 'SET_GRID_SEARCH';
+    search: GridSearchState;
+} | {
+    type: 'SET_MOBILE_EDITOR';
+    editor: MobileEditorState;
+} | {
+    type: 'CHANGE_VIEWPORT';
+    scrollOffset: number;
+    viewportSize?: number;
+    rowHeight?: number;
+    overscan?: number;
+} | {
+    type: 'UNDO';
+} | {
+    type: 'REDO';
+};
+type ViewIntentDispatcher = (intent: ViewIntent) => Promise<void>;
+
+type GridSessionSubscribeSelected = <TSelected>(selector: () => TSelected, listener: (selected: TSelected) => void, isEqual?: (a: TSelected, b: TSelected) => boolean) => () => void;
+/**
+ * Framework-agnostic session facade (target shape of useGrid / createGrid).
+ * Adapters should prefer this over raw Engine.
+ */
+interface GridSession {
+    readonly store: string;
+    readonly tableKey: string;
+    dispatchViewIntent: ViewIntentDispatcher;
+    handleKeydown(event: KeyboardEvent, ctx: {
+        activeRowId: number | null;
+        activeColumnId: string | null;
+    }): Promise<void>;
+    getSnapShot(collectionScope?: CollectionScope): TableSnapShot | null;
+    getViewState(): ReturnType<TableEngine['getViewState']>;
+    subscribe(cb: () => void): () => void;
+    subscribeSelected: GridSessionSubscribeSelected;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): Promise<boolean>;
+    redo(): Promise<boolean>;
+    getChangelog(filter?: Omit<ChangelogQuery, 'tableId'>): ChangelogEntry[];
+    getChangelogCount(filter?: Omit<ChangelogQuery, 'tableId'>): number;
+    subscribeChangelog(cb: (entries: ChangelogEntry[]) => void, filter?: Omit<ChangelogQuery, 'tableId'>): () => void;
+    getHistoryItems(filter?: Omit<HistoryQuery, 'tableId'>): HistoryItem[];
+    getHistoryItemCount(filter?: Omit<HistoryQuery, 'tableId'>): number;
+    subscribeHistoryItems(cb: (items: HistoryItem[]) => void, filter?: Omit<HistoryQuery, 'tableId'>): () => void;
+    getEngine(): TableEngine;
+    /** Current virtual-scroll viewport (view state; not domain). */
+    getViewport(): Viewport;
+    getVisibleRange(totalRows?: number): VisibleRange;
+    projectVisibleRows<T>(rows: readonly T[], totalRows?: number): T[];
+}
+
+interface UICommandBase {
+    readonly type: string;
+}
+interface UICellChangeEvent extends UICommandBase {
+    readonly type: 'UI_CELL_CHANGE';
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly value: unknown;
+}
+interface UIDescriptionSaveEvent extends UICommandBase {
+    readonly type: 'UI_DESCRIPTION_SAVE';
+    readonly rowId: number;
+    readonly flag: boolean;
+}
+interface UICellChangeDisplayEvent extends UICommandBase {
+    readonly type: 'UI_CELL_CHANGE_DISPLAY';
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly value: string;
+}
+interface UIMoveActiveCellEvent extends UICommandBase {
+    readonly type: 'UI_MOVE_ACTIVE_CELL';
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly direction: "next" | "prev";
+}
+interface UIMoveActiveVerticalCellEvent extends UICommandBase {
+    readonly type: 'UI_MOVE_ACTIVE_CELL_VERTICAL';
+    readonly rowId: number;
+    readonly columnId: string;
+    readonly direction: 'up' | 'down';
+}
+interface UIActiveFirstCellEvent extends UICommandBase {
+    readonly type: 'UI_ACTIVE_FIRST_CELL';
+    readonly rowId: number;
+}
+interface UIActiveCellEvent extends UICommandBase {
+    readonly type: 'UI_ACTIVE_CELL';
+    readonly rowId: number;
+    readonly columnId: string;
+}
+interface ChangePageSizeUiCommand extends UICommandBase {
+    readonly type: 'CHANGE_PAGE_SIZE';
+    readonly pageSize: number;
+}
+interface ChangePageUiCommand extends UICommandBase {
+    readonly type: 'CHANGE_PAGE';
+    readonly page: number;
+}
+interface ActiveRowUiCommand extends UICommandBase {
+    readonly type: 'UI_ACTIVE_ROW';
+    readonly rowId: number;
+}
+interface AddEmptyRowUiCommand extends UICommandBase {
+    readonly type: 'ADD_EMPTY_ROW';
+}
+interface AddNewRowsUiCommand extends UICommandBase {
+    readonly type: 'ADD_NEW_ROWS';
+    readonly detailFieldKey: string;
+    readonly rows: {
+        key: string;
+        value: unknown;
+        display: unknown;
+    }[][];
+}
+interface DuplicateRowUiCommand extends UICommandBase {
+    readonly type: 'DUPLICATE_ROW';
+    readonly rowId: number;
+}
+interface DeleteRowUiCommand extends UICommandBase {
+    readonly type: 'ROW_DELETED';
+    readonly rowId: number;
+}
+interface DeleteSelectedRowsUiCommand extends UICommandBase {
+    readonly type: 'UI_DELETE_SELECTED_ROW';
+}
+interface DeleteTableUiCommand extends UICommandBase {
+    readonly type: 'TABLE_DELETED';
+}
+interface RegisterTableUiCommand extends UICommandBase {
+    readonly type: 'TABLE_REGISTERED';
+    readonly storeName: string;
+    readonly table: Table;
+}
+interface ToggleRowExpandedUiCommand extends UICommandBase {
+    readonly type: 'TOGGLE_ROW_EXPANDED';
+    readonly rowId: number;
+}
+interface ReorderRowUiCommand extends UICommandBase {
+    readonly type: 'ROW_REORDERED';
+    readonly draggedRowId: number;
+    readonly droppedRowId: number;
+    readonly position: 'before' | 'after';
+}
+interface ToggleRowSelectedUiCommand extends UICommandBase {
+    readonly type: 'TOGGLE_ROW_SELECTED';
+}
+interface TogglePageRowSelectedUiCommand extends UICommandBase {
+    readonly type: 'TOGGLE_PAGE_ROW_SELECTED';
+}
+interface RowSelectedUiCommand extends UICommandBase {
+    readonly type: 'ROW_SELECTED';
+    readonly rowId: number;
+}
+interface ActionTableUiCommand extends UICommandBase {
+    readonly type: 'UI_ACTION_TABLE';
+    readonly action: TableActions;
+}
+interface ActiveCollectionUiCommand extends UICommandBase {
+    readonly type: 'UI_CHANGE_ACTIVE_COLLECTION';
+    readonly activeCollection: string;
+}
+interface KeyDownUiCommand extends UICommandBase {
+    readonly type: 'KEY_DOWN';
+    readonly event: KeyboardEvent;
+    readonly ctx: {
+        tableKey: string;
+        activeRowId: number | null;
+        activeColumnId: string | null;
+    };
+}
+interface SetGridSearchUiCommand extends UICommandBase {
+    readonly type: 'UI_SET_GRID_SEARCH';
+    readonly search: GridSearchState;
+}
+interface ClearGridSearchUiCommand extends UICommandBase {
+    readonly type: 'UI_CLEAR_GRID_SEARCH';
+}
+interface OpenMobileAddUiCommand extends UICommandBase {
+    readonly type: 'UI_OPEN_MOBILE_ADD';
+}
+interface OpenMobileEditUiCommand extends UICommandBase {
+    readonly type: 'UI_OPEN_MOBILE_EDIT';
+    readonly rowId: number;
+}
+interface CloseMobileEditorUiCommand extends UICommandBase {
+    readonly type: 'UI_CLOSE_MOBILE_EDITOR';
+}
+type UITableCommand = ActiveRowUiCommand | ToggleRowSelectedUiCommand | TogglePageRowSelectedUiCommand | RowSelectedUiCommand | UIMoveActiveVerticalCellEvent | UIMoveActiveCellEvent | UIActiveCellEvent | UIActiveFirstCellEvent | UICellChangeEvent | UIDescriptionSaveEvent | UICellChangeDisplayEvent | ChangePageSizeUiCommand | ChangePageUiCommand | AddEmptyRowUiCommand | AddNewRowsUiCommand | DuplicateRowUiCommand | DeleteRowUiCommand | DeleteTableUiCommand | RegisterTableUiCommand | ToggleRowExpandedUiCommand | ReorderRowUiCommand | ActionTableUiCommand | ActiveCollectionUiCommand | DeleteSelectedRowsUiCommand | KeyDownUiCommand | SetGridSearchUiCommand | ClearGridSearchUiCommand | OpenMobileAddUiCommand | OpenMobileEditUiCommand | CloseMobileEditorUiCommand;
+
+declare class UITableController {
+    private readonly engine;
+    private readonly store;
+    private readonly tableKey;
+    private readonly audit;
+    private readonly changelogProjection?;
+    private readonly historyPanelViewModel?;
+    private readonly cellUndoStack?;
+    private readonly session?;
+    private readonly remoteApi?;
+    private disposed;
+    constructor(engine: TableEngine, store: string, tableKey: string, audit: AuditLogger, changelogProjection?: ChangelogProjection | undefined, historyPanelViewModel?: HistoryPanelViewModel | undefined, cellUndoStack?: CellUndoStack | undefined, session?: GridSession | undefined, remoteApi?: RemoteApi | undefined);
+    getRemoteApi(): RemoteApi | undefined;
+    private safe;
+    private changePageSize;
+    private changePage;
+    private onCellChange;
+    private onDescriptionSave;
+    private onCellDisplayChange;
+    private setActiveCell;
+    private setActiveRow;
+    private moveActiveCellVertical;
+    private reorderRow;
+    private addEmptyRow;
+    private openMobileAddEditor;
+    private addNewRows;
+    private duplicateRow;
+    private deleteRow;
+    private deleteRows;
+    private deleteTable;
+    private registerTable;
+    private toggleRowExpanded;
+    private toggleRowSelect;
+    private togglePageRowSelect;
+    private selectFromActiveToLast;
+    private activateFirstEditableCell;
+    private moveToNextCell;
+    private setTableAction;
+    private setActiveCollection;
+    private setGridSearch;
+    private setMobileEditor;
+    getViewState(): TableViewState | null | undefined;
+    getMobileViewState(): MobileTableViewState | null | undefined;
+    getRowView(rowId: number): UIRow | null;
+    getAllRows(): Row[] | null;
+    getAllUIRows(): UIRow[] | null;
+    getSnapShot(collectionScope?: CollectionScope): TableSnapShot | null;
+    getCell(rowId: number, columnId: string): Cell | null | undefined;
+    getChangelog(filter?: Omit<ChangelogQuery, 'tableId'>): ChangelogEntry[];
+    getChangelogCount(filter?: Omit<ChangelogQuery, 'tableId'>): number;
+    subscribeChangelog(cb: (entries: ChangelogEntry[]) => void, filter?: Omit<ChangelogQuery, 'tableId'>): () => void;
+    getHistoryItems(filter?: Omit<HistoryQuery, 'tableId'>): HistoryItem[];
+    getHistoryItemCount(filter?: Omit<HistoryQuery, 'tableId'>): number;
+    subscribeHistoryItems(cb: (items: HistoryItem[]) => void, filter?: Omit<HistoryQuery, 'tableId'>): () => void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    undo(): Promise<boolean>;
+    redo(): Promise<boolean>;
+    getActiveRow(): number | null;
+    getSelectedRows(): Record<number, boolean> | null | undefined;
+    getActiveCell(): ActiveCell | undefined;
+    getMobileEditor(): MobileEditorState | undefined;
+    resetMobileVisibleRows(size?: number): void;
+    loadMoreMobileRows(step?: number): void;
+    revealAllMobileRows(minSize?: number): void;
+    isActiveCell(rowId: number, columnId: string): boolean | null;
+    isActiveRow(rowId: number): boolean | null;
+    isSelectedRow(rowId: number): boolean | null;
+    isCutRow(rowId: number): boolean | null;
+    subscribe(cb: () => void): (() => void) | null;
+    subscribeSelected<TSelected>(selector: () => TSelected, listener: (selected: TSelected) => void, isEqual?: (a: TSelected, b: TSelected) => boolean): () => void;
+    getSession(): GridSession | undefined;
+    getTableKey(): string;
+    subscribeColumn<T>(columnId: string, collections: CollectionScope, cb: (values: T[]) => void): (() => void) | null;
+    validation: () => (callback: (result: ValidationCallbackResult) => void) => void;
+    isValidCell(rowId: number, columnId: string): ValidCell | null;
+    onRowClick(rowId: number, modifiers: {
+        ctrlKey: boolean;
+        shiftKey: boolean;
+    }): void;
+    onRowSelect(rowId: number): void;
+    dispose(): void;
+    dispatch(command: UITableCommand): Promise<void>;
+    private dispatchInternal;
+}
+
+type ExportColumnDef = {
+    readonly fieldName: string;
+    readonly fieldCaption?: string;
+    readonly fieldType?: string;
+    readonly order?: number;
+};
+type ExportCellSource = {
+    readonly value: unknown;
+    readonly display?: unknown;
+};
+type ExportRowSource = {
+    readonly id: number;
+    readonly rowState: string;
+    readonly cells: Readonly<Record<string, ExportCellSource>>;
+};
+type ExportSource = {
+    readonly columns: readonly ExportColumnDef[];
+    readonly rows: readonly ExportRowSource[];
+};
+/**
+ * Read-only query surface for plugins (never mutates aggregates).
+ */
+interface GridQueryPort {
+    getSnapShot(collectionScope?: CollectionScope): TableSnapShot | null;
+    getExportSource(collectionScope?: CollectionScope): ExportSource | null;
+}
+type PluginEventBus = {
+    subscribeAll(onEvent: (event: GridEvent) => void): Unsubscribe;
+    publish(event: GridEvent): Promise<void>;
+};
+interface GridPluginContext {
+    readonly tableId: string;
+    readonly bus: PluginEventBus;
+    readonly session: GridSession;
+    readonly query: GridQueryPort;
+    readonly eventStore: EventStore;
+    /**
+     * Out-of-band binary for IMPORT_REQUESTED (not stored on the event bus /
+     * IndexedDB payload — only correlationId is published).
+     */
+    resolveImportData?: (correlationId: string) => Uint8Array | undefined;
+}
+interface GridPlugin {
+    readonly name: string;
+    register(ctx: GridPluginContext): void;
+    dispose?(): void;
+}
+
+type RequestExportOptions = {
+    format: 'xlsx' | 'pdf';
+    collectionScope?: ExportRequestedPayload['collectionScope'];
+    correlationId?: string;
+    fileName?: string;
+    sheetName?: string;
+    direction?: 'rtl' | 'ltr';
+};
+type RequestImportOptions = {
+    format: 'xlsx';
+    data: Blob | ArrayBuffer | Uint8Array;
+    collectionScope?: ImportRequestedPayload['collectionScope'];
+    correlationId?: string;
+    sheetName?: string;
+};
+type PluginHostDeps = {
+    tableId: string;
+    actorId: string;
+    eventStore: EventStore;
+    session: GridSession;
+    query: GridQueryPort;
+};
+/**
+ * Registers plugins and publishes plugin/view-stream events (e.g. EXPORT_REQUESTED).
+ */
+declare class PluginHost {
+    private readonly deps;
+    private readonly plugins;
+    private readonly disposers;
+    private readonly importPayloads;
+    private version;
+    constructor(deps: PluginHostDeps);
+    private takeImportPayload;
+    private createBus;
+    register(plugins: readonly GridPlugin[]): void;
+    list(): readonly GridPlugin[];
+    requestExport(options: RequestExportOptions): Promise<void>;
+    requestImport(options: RequestImportOptions): Promise<void>;
+    dispose(): void;
+}
+
+/**
+ * Core column definition without React/DOM bindings.
+ * Host adapters attach renderers via ColumnViewBinding.
+ */
+interface ColumnDefinition {
+    readonly fieldName: string;
+    readonly fieldCaption: string;
+    readonly fieldType: FieldType;
+    readonly fieldCollection?: string;
+    readonly order?: number;
+    readonly editable?: boolean;
+    readonly isUnique?: boolean;
+    readonly hidden?: boolean;
+    readonly disable?: boolean;
+    readonly noCache?: boolean;
+    readonly expandable?: boolean;
+    readonly rules?: IRule[];
+    readonly options?: ReadonlyArray<{
+        label?: string;
+        value?: string | number;
+        title?: string;
+    }>;
+    readonly visibility: ColumnVisibilityRule;
+    readonly dynamicSource?: {
+        endpoint: string;
+        dependsOn?: string[];
+        dependOn?: IDependOn | IDependOn[];
+        params?: Record<string, string>;
+    };
+    readonly computed?: {
+        dependsOn: readonly string[];
+    };
+    readonly selectOptions?: ReadonlyArray<{
+        label: string;
+        value: string | number;
+    }>;
+    readonly minWidth?: number;
+    readonly labelValue?: 'selectDisplay' | 'selectValue';
+}
+/**
+ * Presentation binding kept outside Domain (Adapter / Host).
+ * `render` is intentionally untyped here to avoid React import in core.
+ */
+interface ColumnViewBinding {
+    readonly fieldName: string;
+    readonly className?: string;
+    readonly minWidth?: number;
+    readonly style?: unknown;
+    readonly render?: (...args: unknown[]) => unknown;
+    readonly displayFormat?: (value: unknown) => unknown;
+    readonly onChange?: (...args: unknown[]) => void;
+    readonly indexOptions?: (...args: unknown[]) => unknown[];
+    readonly popUpWidth?: number;
+    readonly dynamicSelectFilterOption?: (inputValue: string, option: unknown) => boolean;
+}
+
+type CollectionRowMap = Record<string, object>;
+type RowInput = {
+    id: number;
+    values?: Record<string, unknown>;
+    collection?: string;
+    rowType?: string;
+};
+type RowAccessControl = {
+    allowRoles?: string[];
+    denyRoles?: string[];
+    rule?: (ctx: {
+        actor: Actor$1;
+        table: Table;
+        row?: Row;
+    }) => boolean;
+};
+type CreateERPTableConfig = {
+    store: string;
+    tableKey: string;
+    activeCollection?: string;
+    tableType?: string;
+    actor: Actor$1;
+    rowAccess?: RowAccessControl;
+    columns: ColumnSchema[];
+    rows: RowInput[];
+    repo?: TableRepository;
+    audit?: AuditLogger;
+    permissionPolicy?: PermissionPolicy;
+    tableHeight?: number;
+    recordPerPage?: number;
+    remoteApi?: RemoteApi;
+    /**
+     * Override event store. Default: IndexedDbEventStore in the browser,
+     * InMemoryEventStore in Node/tests.
+     */
+    eventStore?: EventStore;
+    /** Optional plugins (Excel/PDF export+import, …) registered at composition root. */
+    plugins?: readonly GridPlugin[];
+};
+type CreateERPTableResult = {
+    engine: TableEngine;
+    controller: UITableController;
+    session: GridSession;
+    table: Table;
+    tableKey: string;
+    columnMeta: Map<string, ColumnSchema>;
+    columnDefinitions: ColumnDefinition[];
+    columnBindings: ColumnViewBinding[];
+    eventStore: EventStore;
+    changelogProjection: ChangelogProjection;
+    historyPanelViewModel: HistoryPanelViewModel;
+    cellUndoStack: CellUndoStack;
+    pluginHost: PluginHost;
+};
+
+type ERPTableLocale = 'fa' | 'en';
+type ERPTableMessages = Record<string, string>;
+
+type ERPTableToastKind = 'success' | 'error';
+type ERPTableHostValue = {
+    locale: ERPTableLocale;
+    direction: 'rtl' | 'ltr';
+    remoteApi?: RemoteApi;
+    messages?: Partial<ERPTableMessages>;
+    onToast?: (kind: ERPTableToastKind, message: string, detail?: unknown) => void;
+};
+declare function ERPTableHostProvider({ children, locale, direction, remoteApi, messages, onToast, }: ERPTableHostValue & {
+    children: ReactNode;
+}): React__default.JSX.Element;
+
+interface ERPTableProps extends CreateERPTableConfig {
+    onReady?: (controller: UITableController) => void;
+    tableTitle?: ReactNode;
+    header?: ReactNode;
+    footer?: boolean | ReactNode;
+    activeCollection?: string;
+    tableHeight?: number;
+    multiSelectConfig: IMultiSelectConfig;
+    moreDetailComponent?: React__default.ComponentType<{
+        data: unknown;
+    }>;
+    /**
+     * Desktop virtual scroll. Default **false** to match ERP pagination.
+     * Pass true to enable GridSession virtualization.
+     */
+    virtualization?: boolean;
+    locale?: ERPTableLocale;
+    direction?: 'rtl' | 'ltr';
+    messages?: Partial<ERPTableMessages>;
+    onToast?: (kind: ERPTableToastKind, message: string, detail?: unknown) => void;
+}
+declare function ERPTable(props: ERPTableProps): React__default.JSX.Element | null;
+
+interface CellRendererProps {
+    tableKey: string;
+    row: UIRow;
+    columnId: string;
+    idx: number;
+    meta?: ColumnSchema;
+    controller: UITableController;
+    tabIndex: number;
+    mode?: "view" | "cell" | "form";
+}
+declare const CellRenderer: React__default.FC<CellRendererProps>;
+
+type UseERPTableResult = {
+    ready: false;
+} | {
+    ready: true;
+    controller: UITableController;
+    session: GridSession;
+    rows: TableSnapShot;
+    changelog: ChangelogEntry[];
+    changelogCount: number;
+    historyItems: HistoryItem[];
+    historyItemCount: number;
+    canUndo: boolean;
+    canRedo: boolean;
+    getChangelog: (filter?: Omit<ChangelogQuery, 'tableId'>) => ChangelogEntry[];
+    getHistoryItems: (filter?: Omit<HistoryQuery, 'tableId'>) => HistoryItem[];
+    subscribeChangelog: (cb: (entries: ChangelogEntry[]) => void, filter?: Omit<ChangelogQuery, 'tableId'>) => () => void;
+    subscribeHistoryItems: (cb: (items: HistoryItem[]) => void, filter?: Omit<HistoryQuery, 'tableId'>) => () => void;
+    subscribeSelected: GridSession['subscribeSelected'];
+    getViewport: GridSession['getViewport'];
+    getVisibleRange: GridSession['getVisibleRange'];
+    projectVisibleRows: GridSession['projectVisibleRows'];
+    changeViewport: (input: {
+        scrollOffset: number;
+        viewportSize?: number;
+        rowHeight?: number;
+        overscan?: number;
+    }) => Promise<void>;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+};
+declare function useERPTable(config: CreateERPTableConfig): UseERPTableResult;
+
+declare function createERPTable(config: CreateERPTableConfig): Promise<CreateERPTableResult>;
+
+/**
+ * Maps host/legacy ColumnSchema into core ColumnDefinition + view bindings.
+ * Domain/runtime should prefer ColumnDefinition; React renderers stay in bindings.
+ */
+declare function toColumnDefinition(schema: ColumnSchema): ColumnDefinition;
+declare function toColumnViewBinding(schema: ColumnSchema): ColumnViewBinding;
+declare function mapColumnSchemas(schemas: ColumnSchema[]): {
+    definitions: ColumnDefinition[];
+    bindings: ColumnViewBinding[];
+};
+
+type Listener$1 = (event: GridEvent) => void;
+declare class InMemoryEventStore implements EventStore {
+    private streams;
+    private globalLog;
+    private listeners;
+    private globalListeners;
+    append(streamId: string, events: GridEvent[], expectedVersion: number): Promise<AppendResult>;
+    read(streamId: string, fromVersion?: number): Promise<GridEvent[]>;
+    readAll(fromPosition?: number): Promise<GridEvent[]>;
+    subscribe(streamId: string, onEvent: Listener$1): Unsubscribe;
+    subscribeAll(onEvent: Listener$1): Unsubscribe;
+    getStreamVersion(streamId: string): number;
+    getGlobalPosition(): number;
+}
+
+/**
+ * Minimal async key-value backend so IndexedDbEventStore can run in Node tests
+ * without a real IndexedDB, and in browsers via an IDB adapter.
+ */
+interface KvStore {
+    get<T = unknown>(key: string): Promise<T | undefined>;
+    put(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    getAllKeys(): Promise<string[]>;
+    getAll<T = unknown>(): Promise<T[]>;
+    clear(): Promise<void>;
+}
+interface KvDatabase {
+    objectStore(name: string): KvStore;
+}
+declare class MemoryKvDatabase implements KvDatabase {
+    private stores;
+    objectStore(name: string): KvStore;
+}
+/**
+ * Browser IndexedDB adapter. Opens (or creates) a DB with the given object stores.
+ * Falls back callers should use MemoryKvDatabase in Node/tests.
+ */
+declare function openIndexedDbDatabase(dbName: string, storeNames: string[], version?: number): Promise<KvDatabase>;
+
+type Listener = (event: GridEvent) => void;
+/**
+ * Durable EventStore backed by IndexedDB (or any KvDatabase).
+ * Same OCC contract as InMemoryEventStore.
+ */
+declare class IndexedDbEventStore implements EventStore {
+    private readonly db;
+    private listeners;
+    private globalListeners;
+    private ready;
+    constructor(db: KvDatabase);
+    static open(dbName?: string): Promise<IndexedDbEventStore>;
+    /** Test / Node helper — durable API with in-memory persistence backend. */
+    static inMemory(): IndexedDbEventStore;
+    append(streamId: string, events: GridEvent[], expectedVersion: number): Promise<AppendResult>;
+    read(streamId: string, fromVersion?: number): Promise<GridEvent[]>;
+    readAll(fromPosition?: number): Promise<GridEvent[]>;
+    subscribe(streamId: string, onEvent: Listener): Unsubscribe;
+    subscribeAll(onEvent: Listener): Unsubscribe;
+}
+
+/**
+ * Aggregate snapshot for fast reload: lastSnapshot + events after version.
+ */
+interface AggregateSnapshot<TPayload = unknown> {
+    readonly tableId: string;
+    readonly streamId: string;
+    readonly version: number;
+    readonly takenAt: number;
+    readonly payload: TPayload;
+}
+interface SnapshotStore<TPayload = unknown> {
+    save(snapshot: AggregateSnapshot<TPayload>): Promise<void>;
+    loadLatest(streamId: string): Promise<AggregateSnapshot<TPayload> | null>;
+    clear(streamId: string): Promise<void>;
+}
+
+type SnapshotStrategyOptions = {
+    /** Take a snapshot every N appended domain events (default 200). */
+    readonly everyNEvents?: number;
+};
+/**
+ * After appends, periodically persists a snapshot of the selected payload.
+ * load(stream) = latest snapshot + events with version > snapshot.version
+ */
+declare class SnapshotStrategy<TPayload = unknown> {
+    private readonly snapshots;
+    private readonly eventStore;
+    private readonly capture;
+    private readonly everyN;
+    private counts;
+    constructor(snapshots: SnapshotStore<TPayload>, eventStore: EventStore, capture: (streamId: string) => Promise<TPayload> | TPayload, options?: SnapshotStrategyOptions);
+    /** Call after a successful EventStore.append for the stream. */
+    onAppend(streamId: string, tableId: string, appendedCount: number): Promise<void>;
+    loadWithCatchUp(streamId: string): Promise<{
+        snapshot: AggregateSnapshot<TPayload> | null;
+        eventsAfter: GridEvent[];
+    }>;
+}
+
+declare class InMemorySnapshotStore<TPayload = unknown> implements SnapshotStore<TPayload> {
+    private byStream;
+    save(snapshot: AggregateSnapshot<TPayload>): Promise<void>;
+    loadLatest(streamId: string): Promise<AggregateSnapshot<TPayload> | null>;
+    clear(streamId: string): Promise<void>;
+}
+
+/** Default RemoteApi for Node/tests/package builds — host injects a real adapter. */
+declare class NoopRemoteApi implements RemoteApi {
+    request<TResponse = unknown>(): Promise<TResponse>;
+}
+
+declare class EngineErrorHandler {
+    private readonly audit;
+    constructor(audit: ConsoleAuditLogger);
+    /**
+     * همه‌ی خطاها — چه DomainError چه runtime error — از اینجا رد می‌شن
+     * و از طریق ConsoleAuditLogger لاگ می‌شن.
+     */
+    handle(error: unknown, context?: string): void;
+    /** برای جاهایی که store یا table پیدا نشد */
+    notFound(entity: string, key: string, context?: string): void;
+}
+
+/**
+ * Browser RemoteApi used by ERP after npm install.
+ * Reads auth cookie `_auth` and redux-persist `persist:arianERP` the same way
+ * the ERP FetchRemoteApi did, then POSTs JSON (relative URLs work on the ERP host).
+ */
+declare class FetchRemoteApi implements RemoteApi {
+    private readonly err?;
+    private readonly options;
+    constructor(err?: EngineErrorHandler | undefined, options?: {
+        baseUrl?: string;
+    });
+    request<TResponse = any>(input: {
+        endpoint: string;
+        params?: Record<string, any>;
+        method?: 'GET' | 'POST';
+    }): Promise<TResponse>;
+}
+
+/**
+ * Plugin-facing event catalog (stable type tokens for subscribe / export plugins).
+ * Keep in sync with `application/events` and `domain/types/GridEvent`.
+ */
+type EventCatalogEntry = {
+    readonly type: string;
+    readonly category: 'cell' | 'row' | 'column' | 'table' | 'view' | 'dynamic' | 'error' | 'plugin';
+    readonly undoable: boolean;
+    readonly description: string;
+};
+declare const EVENT_CATALOG: readonly EventCatalogEntry[];
+declare function getEventCatalogEntry(type: string): EventCatalogEntry | undefined;
+declare function listUndoableEventTypes(): string[];
+
+type BenchmarkSample = {
+    readonly name: string;
+    readonly iterations: number;
+    readonly totalMs: number;
+    readonly avgMs: number;
+    readonly maxMs: number;
+};
+type PerformanceBudget = {
+    readonly name: string;
+    /** Maximum allowed average milliseconds per iteration. */
+    readonly maxAvgMs: number;
+    /** Maximum allowed single-iteration milliseconds. */
+    readonly maxMaxMs?: number;
+};
+type BenchmarkResult = {
+    readonly sample: BenchmarkSample;
+    readonly budget: PerformanceBudget;
+    readonly ok: boolean;
+    readonly reasons: string[];
+};
+/**
+ * Tiny synchronous/async micro-benchmark helper for core hot paths.
+ * Not a substitute for browser profiling — guards CI regressions.
+ */
+declare function runBenchmark(name: string, iterations: number, fn: () => void | Promise<void>): Promise<BenchmarkSample>;
+declare function checkBudget(sample: BenchmarkSample, budget: PerformanceBudget): BenchmarkResult;
+/** Default budgets for Phase 4 CI guards (generous for CI variance). */
+declare const DEFAULT_PERFORMANCE_BUDGETS: {
+    readonly inMemoryAppend100: {
+        readonly name: "inMemoryAppend100";
+        readonly maxAvgMs: 25;
+        readonly maxMaxMs: 80;
+    };
+    readonly indexedDbAppend100: {
+        readonly name: "indexedDbAppend100";
+        readonly maxAvgMs: 80;
+        readonly maxMaxMs: 200;
+    };
+    readonly selectorNotifyNoop: {
+        readonly name: "selectorNotifyNoop";
+        readonly maxAvgMs: 5;
+        readonly maxMaxMs: 20;
+    };
+};
+
+/**
+ * Pure virtual-window calculator — no DOM / window / document.
+ * Input: totalRows + Viewport → VisibleRange for Adapter rendering.
+ */
+declare class ViewportCalculator {
+    static calculate(totalRows: number, viewport: Viewport): VisibleRange;
+    /** Contiguous index list for the visible window. */
+    static indices(range: VisibleRange): number[];
+    /** Slice a dense array by VisibleRange (O(window), not O(n)). */
+    static projectRows<T>(rows: readonly T[], range: VisibleRange): T[];
+    /**
+     * Project from sparse structure: ordered id list + Map by id.
+     * Suitable for 100k+ tables without materializing full UI rows.
+     */
+    static projectByIndex<T>(orderedIds: readonly number[], byId: ReadonlyMap<number, T>, range: VisibleRange): T[];
+}
+
+/**
+ * Sparse ordered index for large tables: O(1) id lookup + O(window) projection.
+ * Keeps full row payloads in a Map; visible window never walks all rows.
+ */
+declare class SparseRowIndex<T> {
+    private readonly byId;
+    private orderedIds;
+    constructor(entries?: Iterable<readonly [number, T]>);
+    get size(): number;
+    getOrderedIds(): readonly number[];
+    getById(id: number): T | undefined;
+    set(id: number, value: T): void;
+    /** Replace order without rebuilding payloads (e.g. after sort). */
+    setOrder(orderedIds: readonly number[]): void;
+    clear(): void;
+    /** Project only the visible window — O(window), not O(n). */
+    projectVisible(range: {
+        startIndex: number;
+        endIndex: number;
+    }): T[];
+}
+
+type VirtualListProps<T> = {
+    session: GridSession;
+    items: readonly T[];
+    /** Scrollport height in pixels. */
+    height: number;
+    rowHeight?: number;
+    overscan?: number;
+    className?: string;
+    style?: React__default.CSSProperties;
+    getItemKey?: (item: T, absoluteIndex: number) => string | number;
+    renderItem: (item: T, absoluteIndex: number) => React__default.ReactNode;
+};
+/**
+ * Thin React adapter for Core ViewportCalculator.
+ * Renders spacers + absolute-positioned visible rows only.
+ */
+declare function VirtualList<T>({ session, items, height, rowHeight, overscan, className, style, getItemKey, renderItem, }: VirtualListProps<T>): React__default.JSX.Element;
+
+type VirtualWindowModel<T> = {
+    readonly range: VisibleRange;
+    readonly visibleItems: readonly T[];
+    /** Absolute row indices matching visibleItems. */
+    readonly absoluteIndices: readonly number[];
+    readonly spacerTop: number;
+    readonly spacerBottom: number;
+    readonly totalHeight: number;
+};
+/**
+ * Pure adapter helper: map items + viewport → render window.
+ * No React / DOM — unit-testable in Node.
+ */
+declare function buildVirtualWindow<T>(items: readonly T[], viewport: Viewport): VirtualWindowModel<T>;
+
+type UseVirtualWindowResult<T> = VirtualWindowModel<T> & {
+    readonly onScroll: (scrollTop: number, clientHeight?: number) => void;
+};
+/**
+ * Syncs GridSession viewport with a scrollable container and returns
+ * only the visible item window for rendering.
+ */
+declare function useVirtualWindow<T>(session: GridSession | null | undefined, items: readonly T[], options?: {
+    rowHeight?: number;
+    overscan?: number;
+    initialViewportSize?: number;
+}): UseVirtualWindowResult<T>;
+
+/**
+ * Adapter: TableEngine → GridQueryPort for export plugins.
+ */
+declare function createEngineGridQuery(engine: TableEngine): GridQueryPort;
+
+/**
+ * Port so PDF libraries (jsPDF, etc.) stay out of Core.
+ * Host or plugin package injects a concrete renderer.
+ */
+interface PdfRenderer {
+    render(source: ExportSource, options?: {
+        title?: string;
+        direction?: 'rtl' | 'ltr';
+    }): Promise<Blob>;
+}
+
+type ExcelExportPluginOptions = {
+    /** Skip browser download (useful in tests / Node). */
+    download?: boolean;
+    onBlob?: (blob: Blob, meta: {
+        fileName: string;
+        rowCount: number;
+        columnCount: number;
+    }) => void;
+};
+/**
+ * Subscribes to EXPORT_REQUESTED (format=xlsx); never mutates Domain.
+ */
+declare class ExcelExportPlugin implements GridPlugin {
+    private readonly options;
+    readonly name = "excel-export";
+    private unsub;
+    constructor(options?: ExcelExportPluginOptions);
+    register(ctx: GridPluginContext): void;
+    dispose(): void;
+    private onEvent;
+}
+
+type ExcelImportPluginOptions = {
+    onImported?: (meta: {
+        rowCount: number;
+        columnCount: number;
+    }) => void;
+};
+/**
+ * Subscribes to IMPORT_REQUESTED (format=xlsx); mutates domain only via
+ * session/engine commands (never touches Entity directly).
+ */
+declare class ExcelImportPlugin implements GridPlugin {
+    private readonly options;
+    readonly name = "excel-import";
+    private unsub;
+    constructor(options?: ExcelImportPluginOptions);
+    register(ctx: GridPluginContext): void;
+    dispose(): void;
+    private onEvent;
+}
+
+type ExportActiveCollectionResult = {
+    rowCount: number;
+    columnCount: number;
+};
+type ExportActiveCollectionOptions = {
+    fileName?: string;
+    sheetName?: string;
+    direction?: 'rtl' | 'ltr';
+    rowHeaderLabel?: string;
+    /** When false, skip browser download (tests). */
+    download?: boolean;
+};
+/**
+ * Imperative facade used by ERP toolbar buttons.
+ * Prefer PluginHost.requestExport + ExcelExportPlugin for event-driven hosts.
+ */
+declare function exportActiveCollectionToExcel(controller: UITableController, options?: ExportActiveCollectionOptions): Promise<ExportActiveCollectionResult>;
+
+type ExportTable = {
+    columns: Array<{
+        fieldName: string;
+        caption: string;
+    }>;
+    /** Parallel to columns; already stringified cell text */
+    rows: string[][];
+};
+/**
+ * Builds a dense string matrix from ExportSource (plugin query port).
+ */
+declare function buildExportTable(source: ExportSource): ExportTable;
+
+type BuildXlsxOptions = {
+    sheetName?: string;
+    direction?: 'rtl' | 'ltr';
+    rowHeaderLabel?: string;
+};
+declare function buildXlsxBlob(table: ExportTable, options?: BuildXlsxOptions): Blob;
+
+type ParsedXlsxSheet = {
+    /** First row cells (header captions / field names). */
+    headers: string[];
+    /** Body rows; each row length matches headers (padded with ''). */
+    rows: string[][];
+};
+/**
+ * Parses a minimal OOXML .xlsx (store or deflate) into a string matrix.
+ * Supports shared strings and inlineStr (as produced by buildXlsxBlob).
+ */
+declare function parseXlsxBlob(data: Blob | ArrayBuffer | Uint8Array, options?: {
+    sheetName?: string;
+}): Promise<ParsedXlsxSheet>;
+
+type ImportCellKv = {
+    key: string;
+    value: unknown;
+    display: unknown;
+};
+type MappedImportRows = {
+    columns: Array<{
+        fieldName: string;
+        fieldType?: string;
+    }>;
+    /** One KeyValue[] per data row (no index column). */
+    rows: ImportCellKv[][];
+};
+/**
+ * Maps sheet headers to export/query columns by caption or fieldName.
+ * Skips index/static columns.
+ */
+declare function mapImportedSheet(sheet: ParsedXlsxSheet, columns: readonly ExportColumnDef[]): MappedImportRows;
+
+type ApplyImportedRowsResult = {
+    rowCount: number;
+};
+/**
+ * Applies imported cell matrices through the engine (ADD_NEW_ROWS) so
+ * CachedTableRepository / IndexedDB persistence stays on the normal path.
+ *
+ * Uses a synthetic unique `index` token only for dedupe in Table.addNewRows;
+ * addNewRow still auto-assigns the real index cell.
+ */
+declare function applyImportedRows(session: GridSession, rows: ImportCellKv[][]): Promise<ApplyImportedRowsResult>;
+
+type PdfExportPluginOptions = {
+    renderer?: PdfRenderer;
+    download?: boolean;
+    onBlob?: (blob: Blob, meta: {
+        fileName: string;
+        rowCount: number;
+    }) => void;
+};
+/**
+ * Subscribes to EXPORT_REQUESTED (format=pdf); Domain stays untouched.
+ */
+declare class PdfExportPlugin implements GridPlugin {
+    private readonly options;
+    readonly name = "pdf-export";
+    private unsub;
+    private readonly renderer;
+    constructor(options?: PdfExportPluginOptions);
+    register(ctx: GridPluginContext): void;
+    dispose(): void;
+    private onEvent;
+}
+
+/**
+ * Minimal text PDF (no external lib) — Host can swap for jsPDF via PdfRenderer.
+ */
+declare class TextPdfRenderer implements PdfRenderer {
+    render(source: ExportSource, options?: {
+        title?: string;
+    }): Promise<Blob>;
+}
+
+export { type AggregateSnapshot, type AppendResult, type BenchmarkResult, type BenchmarkSample, CellRenderer, type CollectionRowMap, type ColumnDefinition, type ColumnSchema, type ColumnViewBinding, type CreateERPTableConfig, type CreateERPTableResult, DEFAULT_PERFORMANCE_BUDGETS, ERPTable, ERPTableHostProvider, type ERPTableHostValue, type ERPTableLocale, type ERPTableMessages, type ERPTableProps, EVENT_CATALOG, type EventCatalogEntry, type EventStore, ExcelExportPlugin, ExcelImportPlugin, type ExportSource, FetchRemoteApi, type FieldType, type GridPlugin, type GridPluginContext, type GridQueryPort, type GridSession, type IMultiSelectConfig, InMemoryEventStore, InMemorySnapshotStore, IndexedDbEventStore, type ItemType, type KvDatabase, type KvStore, MemoryKvDatabase, NoopRemoteApi, PdfExportPlugin, type PdfRenderer, type PerformanceBudget, PluginHost, type RemoteApi, type RequestExportOptions, type RequestImportOptions, type RowInput, RowStateEnum, type SnapshotStore, SnapshotStrategy, SparseRowIndex, TableEngine, type TableSnapShot, type TableViewState, TextPdfRenderer, type UIRow, UITableController, type UseERPTableResult, type UseVirtualWindowResult, type ValidCell, type ViewIntent, Viewport, ViewportCalculator, VirtualList, type VirtualListProps, type VirtualWindowModel, type VisibleRange, applyImportedRows, buildExportTable, buildVirtualWindow, buildXlsxBlob, checkBudget, createERPTable, createEngineGridQuery, exportActiveCollectionToExcel, getEventCatalogEntry, listUndoableEventTypes, mapColumnSchemas, mapImportedSheet, openIndexedDbDatabase, parseXlsxBlob, runBenchmark, toColumnDefinition, toColumnViewBinding, useERPTable, useVirtualWindow };