persian-data-grid 0.5.0 → 0.7.0

package/dist/createEngineGridQuery-BBkud5oE.d.ts

@@ -0,0 +1,939 @@
+import { ai as SortModel, F as FilterModel, E as EventStore, b as GridSession, b0 as ExportRequestedPayload, b1 as ImportRequestedPayload, ah as SortDirection, d as CellRange, l as ColumnDef, m as GetRowId$1, G as GridEvent, x as FieldType, b2 as IRule, b3 as ColumnVisibilityRule, b4 as IDependOn, C as ColumnSchema, D as DefaultOptionType, b5 as ResolveOnConfig, b6 as IBaseQueryResponse, b7 as HostRemoteApi, U as UIRow, a7 as ItemType, b8 as Actor, f as Table, R as Row, b9 as ColDefOrGroup, ba as TableRepository, bb as PermissionPolicy, bc as CellEditType, bd as CellEditCommit, be as EnterNavigation, ab as RowModelType, e as TableEngine, i as ChangelogProjection, H as HistoryPanelViewModel, j as CellUndoStack, a as Unsubscribe, z as AppendResult, ap as Viewport, aq as VisibleRange, A as AggFunc, y as AggFuncName } from './GridSession-CeIfVFck.js';
+import { h as SyncResult, e as SyncConflictPolicy, S as SyncConflict, M as ManualResolution, b as PresencePeer, U as UITableController, z as ConnectivitySource, i as SyncTransport, d as PresenceTransport, l as ClipboardCopyBuildOptions, q as GridPasteRuntimeOptions, O as OfflineStatus, g as SyncPort, c as PresencePort } from './UITableController-C71LXBiX.js';
+import { ReactNode, CSSProperties } from 'react';
+import { A as AuditLogger, R as RemoteApi } from './RemoteApi-CCQxiSf1.js';
+import { c as GridQueryPort, G as GridPlugin } from './GridPlugin-Bewn0X51.js';
+
+/**
+ * Host-provided row source for `rowModelType: 'infinite' | 'serverSide'` (PR-96).
+ * Block cache / LRU / `refreshServerSide` — PR-102.
+ */
+type GridDatasourceGetRowsParams = {
+    startRow: number;
+    endRow: number;
+    sortModel: SortModel;
+    filterModel: FilterModel;
+};
+type GridDatasourceGetRowsResult<TRow = unknown> = {
+    rows: TRow[];
+    /** Total row count when known; drives pagination. */
+    lastRow?: number;
+};
+interface GridDatasource<TRow = unknown> {
+    getRows(p: GridDatasourceGetRowsParams): Promise<GridDatasourceGetRowsResult<TRow>>;
+}
+
+type RequestExportOptions = {
+    format: 'xlsx' | 'pdf' | 'csv';
+    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;
+    /** Runs before an export reads rows (createGrid: write the open cell edit). */
+    beforeRead?: () => Promise<void>;
+};
+/**
+ * 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[];
+    has(pluginName: string): boolean;
+    requestExport(options: RequestExportOptions): Promise<void>;
+    requestImport(options: RequestImportOptions): Promise<void>;
+    dispose(): void;
+}
+
+/**
+ * Column layout state model (PR-115). Pure — no React/DOM.
+ * Used by GridApi get/apply and optional localStorage / EventStore persist.
+ */
+
+type ColumnPinnedState = 'start' | 'end' | null;
+type ColumnStateItem = {
+    colId: string;
+    width: number;
+    hide: boolean;
+    order: number;
+    pinned?: ColumnPinnedState;
+    sort?: SortDirection | null;
+    sortIndex?: number | null;
+};
+
+type GridRowNode<TRow = unknown> = {
+    id: string;
+    rowId: number;
+    data: TRow;
+};
+/** Column layout snapshot (PR-115). Includes pin + sort for persist/restore. */
+type GridColumnState = ColumnStateItem;
+type StartEditingCellParams = {
+    rowId: string | number;
+    colId: string;
+};
+type ExportDataAsExcelOptions = {
+    fileName?: string;
+};
+type CreateGridApiInput<TRow = unknown> = {
+    controller: UITableController;
+    pluginHost: PluginHost;
+    columnDefs?: ColumnDef<TRow>[];
+    getRowId?: GetRowId$1<TRow>;
+    /** Wired when `rowModelType` is infinite/serverSide (PR-102). */
+    refreshServerSide?: () => Promise<void>;
+};
+/**
+ * Imperative host API (PR-86). Thin adapter over `UITableController` +
+ * `PluginHost`. Does not expose `dispatch` or the full controller surface.
+ */
+type GridApi<TRow = unknown> = {
+    getRowNode(id: string | number): GridRowNode<TRow> | undefined;
+    setRowData(rowData: readonly TRow[]): void;
+    refreshCells(): void;
+    getSelectedRows(): TRow[];
+    deselectAll(): Promise<void>;
+    startEditingCell(params: StartEditingCellParams): Promise<void>;
+    stopEditing(cancel?: boolean): void | Promise<void>;
+    exportDataAsExcel(options?: ExportDataAsExcelOptions): Promise<void>;
+    undo(): Promise<boolean>;
+    redo(): Promise<boolean>;
+    getColumnState(): GridColumnState[];
+    applyColumnState(state: readonly GridColumnState[]): Promise<void>;
+    setColumnVisible(colId: string, visible: boolean): void;
+    /** Measure header + cell text off-DOM and resize columns (PR-112). */
+    autoSizeColumns(colIds?: string[]): void;
+    /** Scale column widths to fit the scrollport (PR-112). */
+    sizeColumnsToFit(containerWidth?: number): void;
+    getSortModel(): SortModel;
+    setSortModel(sortModel: SortModel): void;
+    getQuickFilter(): string;
+    setQuickFilter(quickFilterText: string): void;
+    getFilterModel(): FilterModel;
+    setFilterModel(filterModel: FilterModel): void;
+    /** Active row-group columns (PR-120). Only the first is used in 0.12.0. */
+    getRowGroupColumns(): string[];
+    setRowGroupColumns(columns: readonly string[]): void;
+    setGroupDefaultExpanded(expanded: boolean): void;
+    toggleRowGroup(groupKey: string): void;
+    /** Purge server block cache and refetch (PR-102). */
+    refreshServerSide(): Promise<void>;
+    /** Current cell ranges in UI row/column space (PR-105). */
+    getCellRanges(): readonly CellRange[];
+    /** Append a normalized range (PR-105). */
+    addCellRange(range: CellRange): void;
+    /** Online / offline (PR-137). */
+    getConnectivity(): 'online' | 'offline';
+    /** Local data mutations not yet marked synced (PR-137). */
+    getPendingChangeCount(): number;
+    markPendingSynced(eventIds?: readonly string[]): void;
+    /** Push/pull sync when `syncTransport` was configured (PR-138). */
+    sync(): Promise<SyncResult | null>;
+    setSyncPolicy(policy: SyncConflictPolicy): void;
+    getSyncPolicy(): SyncConflictPolicy | undefined;
+    getOpenSyncConflicts(): readonly SyncConflict[];
+    resolveSyncConflict(conflictId: string, choice: ManualResolution): Promise<void>;
+    /** Remote peers currently broadcasting a cell cursor (PR-139). */
+    getPresencePeers(): readonly PresencePeer[];
+};
+declare function createGridApi<TRow = unknown>(input: CreateGridApiInput<TRow>): GridApi<TRow>;
+
+/**
+ * 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[];
+    }>;
+}
+
+/**
+ * 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?: unknown;
+        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;
+}
+
+/** Select option with a renderable label. */
+type HostDefaultOptionType = Omit<DefaultOptionType, 'label'> & {
+    label?: ReactNode;
+};
+/** Remote flag resolution typed with the arianERP query envelope. */
+type HostResolveOnConfig<K = unknown> = ResolveOnConfig<K, IBaseQueryResponse<K>>;
+interface HostColumnSchema<T = unknown, K = unknown> extends Omit<ColumnSchema<T, K>, 'options' | 'resolveOn' | 'computed' | 'indexOptions' | 'onChange' | 'dynamicSelectFilterOption' | 'style'> {
+    options?: HostDefaultOptionType[];
+    resolveOn?: HostResolveOnConfig<K>;
+    computed?: {
+        dependsOn: readonly string[];
+        compute(row: Record<string, unknown>, remoteApi: HostRemoteApi): Promise<unknown>;
+        children?: [] | undefined;
+    };
+    /** Extra items of the row index menu. */
+    indexOptions?: (tableKey: string, rowId: number, row: UIRow, controller: UITableController) => ItemType[];
+    onChange?: (tableKey: string, rowId: number, row: UIRow, controller: UITableController, value: unknown, option?: HostDefaultOptionType) => void;
+    dynamicSelectFilterOption?: (inputValue: string, option: HostDefaultOptionType) => boolean;
+    style?: CSSProperties;
+}
+type CollectionRowMap = Record<string, object>;
+type GetRowId<TRow = unknown> = (row: TRow, index: number) => string;
+type RowInput = {
+    id: number;
+    values?: Record<string, unknown>;
+    collection?: string;
+    rowType?: string;
+    /** Host `TRow` reference (PR-82). Not deep-cloned. */
+    data?: unknown;
+    /** Stable id from `getRowId`. */
+    sourceId?: string;
+};
+type RowAccessControl = {
+    allowRoles?: string[];
+    denyRoles?: string[];
+    rule?: (ctx: {
+        actor: Actor;
+        table: Table;
+        row?: Row;
+    }) => boolean;
+};
+type CreateERPTableConfig<TRow = unknown> = {
+    /**
+     * Durable IndexedDB namespace. Omit for an in-memory grid (PR-83):
+     * no IndexedDB, `InMemoryEventStore`.
+     */
+    store?: string;
+    /**
+     * Table id. Omit and one is generated for this `createGrid` call
+     * (React: stable for the component lifetime).
+     */
+    tableKey?: string;
+    activeCollection?: string;
+    tableType?: string;
+    /**
+     * RBAC actor. Omit for `{ userId: 'anonymous', roles: ['admin'] }` (all access).
+     */
+    actor?: Actor;
+    rowAccess?: RowAccessControl;
+    /**
+     * ERP / legacy columns. Optional when `columnDefs` is set (PR-82).
+     * If both are set, `columns` wins.
+     * @deprecated Prefer `columnDefs` (D14). Remains working for ERP hosts.
+     */
+    columns?: HostColumnSchema[];
+    /**
+     * ERP / legacy rows. Optional when `rowData` is set (PR-82).
+     * If both are set, `rows` wins for the initial load.
+     * @deprecated Prefer `rowData` (D14). Remains working for ERP hosts.
+     */
+    rows?: RowInput[];
+    /**
+     * Host objects mapped to domain `Row` (PR-82 / D14).
+     * Each domain row keeps this object by reference (`row.data`).
+     */
+    rowData?: readonly TRow[];
+    /** Generic columns or nested groups. Mapped with `toColumnSchema` when `columns` is omitted. */
+    columnDefs?: ColDefOrGroup<NoInfer<TRow>>[];
+    /**
+     * Stable row identity. Default is the array index.
+     * Pass `(row) => String(row.id)` when the host has a real key.
+     */
+    getRowId?: GetRowId<NoInfer<TRow>>;
+    repo?: TableRepository;
+    /**
+     * Persistence strategy (requires `store`).
+     * - `'event-sourced'` (default): whole table in RAM, durable log in the
+     *   EventStore, optional virtualization, sort/filter over every row.
+     * - `'paged-idb'`: arianERP document-grid mode. IndexedDB holds EVERY row
+     *   (one record per row); RAM holds exactly one page window (heap is
+     *   O(page), never O(rows)); pagination drives loading; delete-selected /
+     *   select-all / search / save-snapshot stream from IndexedDB. Sort / filter
+     *   / virtualization act on the current page only; for unbounded sets use
+     *   `rowModelType: 'infinite'`.
+     */
+    persistence?: 'event-sourced' | 'paged-idb';
+    audit?: AuditLogger;
+    permissionPolicy?: PermissionPolicy;
+    tableHeight?: number;
+    recordPerPage?: number;
+    /** Used with `tableHeight` to derive pageSize. Default 40 (D12). */
+    rowHeight?: number;
+    /**
+     * Default `NoopRemoteApi` (D1) — no fetch, no ERP cookies.
+     * arianERP hosts import `FetchRemoteApi` from `persian-data-grid/adapters/arian-erp`.
+     */
+    remoteApi?: RemoteApi;
+    /**
+     * Override event store. Default: IndexedDbEventStore in the browser,
+     * InMemoryEventStore in Node/tests.
+     */
+    eventStore?: EventStore;
+    /**
+     * IndexedDB name prefix when `eventStore` is omitted (PR-80).
+     * Default `persian-data-grid-events` → `{prefix}:{store}`.
+     * 0.5.x databases used `erp-table-events` — pass that string (or
+     * `LEGACY_EVENT_STORE_PREFIX`) to keep existing local data.
+     */
+    eventStoreName?: string;
+    /**
+     * Online/offline detection (PR-137). Default: browser `navigator.onLine`.
+     * Inject a fake source in tests.
+     */
+    connectivity?: ConnectivitySource;
+    /**
+     * Optional sync transport (PR-138). When set, `GridSyncService` is wired and
+     * `api.sync()` / `<GridSyncPanel />` become available.
+     */
+    syncTransport?: SyncTransport;
+    /** Initial conflict policy when `syncTransport` is set (default lastWriteWins). */
+    syncConflictPolicy?: SyncConflictPolicy;
+    /**
+     * Presence transport (PR-139). When set (or `presence: true` for BroadcastChannel),
+     * peer cursors are tracked and `<GridPresencePanel />` works.
+     */
+    presenceTransport?: PresenceTransport;
+    /** Shorthand: enable BroadcastChannel presence for this table. */
+    presence?: boolean;
+    /** Display label for local peer (default actor.userId). */
+    presenceLabel?: string;
+    /**
+     * Opt-in aggregate snapshots (D7). Default stays dual-write repository only.
+     * When set, `SnapshotStrategy` snapshots every `snapshotEveryNEvents` (default 200)
+     * and `createGrid` runs catch-up on `grid.ready` (`last snapshot + events after version`).
+     */
+    snapshotStore?: SnapshotStore;
+    /** Snapshot cadence when `snapshotStore` is set. Default 200. */
+    snapshotEveryNEvents?: number;
+    /** Optional plugins (Excel/PDF export+import, …) registered at composition root. */
+    plugins?: readonly GridPlugin[];
+    /**
+     * Quick filter text (PR-93). Matching rows stay; others are hidden from the
+     * UI row index / pagination. Distinct from `GridSearchPanel` find-and-navigate.
+     * Updates after create: `api.setQuickFilter` / `controller.setQuickFilterText`.
+     */
+    quickFilterText?: string;
+    /**
+     * Single-level row grouping (PR-120 / RFC-002). Only the first column is
+     * active in 0.12.0; API accepts `string[]` for forward compatibility.
+     * Session-only — not EventStore. Updates: `api.setRowGroupColumns`.
+     */
+    groupBy?: string | readonly string[];
+    /**
+     * Whether row groups start expanded (PR-120). Default `true`.
+     */
+    groupDefaultExpanded?: boolean;
+    /**
+     * Start editing when a cell is activated (PR-126). Default `true`.
+     * When `false`, use Enter / F2 / double-click / `api.startEditingCell`.
+     */
+    singleClickEdit?: boolean;
+    /**
+     * Commit the draft when the grid loses focus / `stopEditing` (PR-126).
+     * Default `true`. Esc always cancels without writing EventStore.
+     */
+    stopEditingWhenCellsLoseFocus?: boolean;
+    /**
+     * `cell` (default) or `fullRow` — edit every editable column on the row (PR-126).
+     * Host `onRowValueChanged` still fires per committed cell change.
+     */
+    editType?: CellEditType;
+    /**
+     * When typed values become durable.
+     * - `'immediate'`: every editor change is written at once (the arianERP
+     *   table contract): `getRowView`, totals, `computed` / `resolveOn`, host
+     *   `onChange` code and saves always see what the user typed; `Esc` ends
+     *   editing and keeps the value.
+     * - `'deferred'` (PR-126): typing edits a session draft, written on commit
+     *   (move / Enter / Tab / focus leaves the grid / any durable read such as
+     *   `getFullSnapShot`, `iterateRowsFromDb`, export, dispose); `Esc` discards.
+     *
+     * Default: `'immediate'` with `persistence: 'paged-idb'`, else `'deferred'`.
+     */
+    cellEditCommit?: CellEditCommit;
+    /**
+     * `Enter` on an active cell. `'nextCell'` (default): next editable cell of
+     * the row, then the next row; past the last row a new row is added
+     * (`Shift+Enter` goes back) — the data-entry behaviour of the 0.5 line /
+     * arianERP. `'down'`: commit and move to the cell below (spreadsheet style).
+     */
+    enterNavigation?: EnterNavigation;
+    /**
+     * Row model (PR-96). Default `clientSide`.
+     * `infinite` / `serverSide` skip local sort/filter and call `datasource.getRows`.
+     * Full block cache is PR-102.
+     */
+    rowModelType?: RowModelType;
+    /**
+     * Server/infinite row source (PR-96). Required when `rowModelType` is not
+     * `clientSide`.
+     */
+    datasource?: GridDatasource<NoInfer<TRow>>;
+    /** Rows per server cache block (PR-102). Default 100. */
+    cacheBlockSize?: number;
+    /** Max blocks kept in LRU cache (PR-102). Default 10. */
+    maxBlocksInCache?: number;
+    /**
+     * Clipboard copy uses formatted display strings when true (PR-106).
+     * Default false (raw values for Excel round-trip).
+     */
+    copyFormattedValue?: boolean;
+    /** Include column header row in clipboard output (PR-106). Default false. */
+    copyHeadersToClipboard?: boolean;
+    /**
+     * Convert eastern digits to ASCII in clipboard text (PR-106).
+     * Default true.
+     */
+    copyDigitsAsLatin?: boolean;
+    /** Override per-cell clipboard text (PR-106). */
+    processCellForClipboard?: ClipboardCopyBuildOptions['processCellForClipboard'];
+    /**
+     * When true (default), clipboard paste past the last row adds rows (PR-107).
+     */
+    pasteAddsRows?: boolean;
+    /** Fires before paste is applied; return false to cancel (PR-107). */
+    onClipboardPaste?: GridPasteRuntimeOptions['onClipboardPaste'];
+    /**
+     * Persist column layout (width, order, pin, hide, sort) to localStorage
+     * under this key and restore on next create (PR-115).
+     * When set, also emits `COLUMN_STATE_CHANGED` on the EventStore on change.
+     */
+    stateKey?: string;
+};
+type CreateERPTableResult<TRow = unknown> = {
+    engine: TableEngine;
+    controller: UITableController;
+    session: GridSession;
+    table: Table;
+    store: string;
+    tableKey: string;
+    columnMeta: Map<string, ColumnSchema>;
+    columnDefinitions: ColumnDefinition[];
+    columnBindings: ColumnViewBinding[];
+    eventStore: EventStore;
+    snapshotStrategy?: SnapshotStrategy;
+    changelogProjection: ChangelogProjection;
+    historyPanelViewModel: HistoryPanelViewModel;
+    cellUndoStack: CellUndoStack;
+    pluginHost: PluginHost;
+    api: GridApi<TRow>;
+    /** Online/offline + pending local mutations (PR-137). */
+    offlineStatus: OfflineStatus;
+    /** Cross-client sync when `syncTransport` was provided (PR-138). */
+    syncPort?: SyncPort;
+    /** Peer presence when `presence` / `presenceTransport` was set (PR-139). */
+    presencePort?: PresencePort;
+};
+/** Same shape as `CreateERPTableConfig` (D24). */
+type CreateGridConfig<TRow = unknown> = CreateERPTableConfig<TRow>;
+/**
+ * Handle returned immediately by `createGrid`.
+ * `engine` / `controller` / `session` / `api` are filled when `ready` resolves.
+ */
+type CreateGridResult<TRow = unknown> = CreateERPTableResult<TRow> & {
+    readonly ready: Promise<CreateGridResult<TRow>>;
+};
+
+/**
+ * Catalog types that map to `onRowDataUpdated` (PR-85).
+ * Keep in sync with `EVENT_CATALOG` — do not invent a parallel bus.
+ */
+declare const ROW_DATA_UPDATED_CATALOG_TYPES: readonly ["ROW_ADDED", "NEW_ROW_ADDED", "ROW_DELETED", "NEW_ROW_REMOVED", "ROW_RESTORED", "ROW_REORDERED"];
+/** Single mapping table: EVENT_CATALOG token → React callback names. */
+declare const CATALOG_TO_HOST_CALLBACKS: Readonly<Record<string, readonly string[]>>;
+type CellValueChangedEvent<TRow = unknown> = {
+    oldValue: unknown;
+    newValue: unknown;
+    colId: string;
+    rowId: number;
+    data: TRow | undefined;
+};
+type RowValueChangedEvent<TRow = unknown> = {
+    rowId: number;
+    data: TRow | undefined;
+};
+type RowDataUpdatedEvent<TRow = unknown> = {
+    rowData: TRow[];
+    source: string;
+};
+type SelectionChangedEvent<TRow = unknown> = {
+    selectedRowIds: number[];
+    selectedRows: TRow[];
+};
+type CellFocusedEvent = {
+    rowId: number | null;
+    colId: string | null;
+};
+type CatalogHostEventHandlers<TRow = unknown> = {
+    onCellValueChanged?: (event: CellValueChangedEvent<TRow>) => void;
+    onRowValueChanged?: (event: RowValueChangedEvent<TRow>) => void;
+    onRowDataUpdated?: (event: RowDataUpdatedEvent<TRow>) => void;
+};
+type CatalogHostEventContext<TRow = unknown> = {
+    tableId: string;
+    getRowData: (rowId: number) => TRow | undefined;
+    getAllRowData: () => TRow[];
+};
+/**
+ * Map one `EVENT_CATALOG` GridEvent onto host React callbacks.
+ * Returns how many host notifications were emitted (0–2 for CELL_CHANGED).
+ */
+declare function dispatchCatalogHostEvent<TRow = unknown>(event: GridEvent, ctx: CatalogHostEventContext<TRow>, handlers: CatalogHostEventHandlers<TRow>): number;
+declare function subscribeCatalogHostEvents<TRow = unknown>(eventStore: EventStore, ctx: CatalogHostEventContext<TRow>, handlers: CatalogHostEventHandlers<TRow>): Unsubscribe;
+
+/** Internal repo/event-store namespace when the host omits `store` (PR-83). */
+declare const DEFAULT_MEMORY_STORE = "memory";
+/** Actor used when the host omits `actor` — every permission check passes. */
+declare const DEFAULT_GRID_ACTOR: Actor;
+declare function createGridTableKey(): string;
+type ResolvedGridIdentity = {
+    store: string;
+    tableKey: string;
+    actor: Actor;
+    persist: boolean;
+};
+/**
+ * Fill `store` / `tableKey` / `actor` when omitted.
+ * When `store` is set, identity is unchanged (PR-83: do not alter that path).
+ */
+declare function resolveCreateGridDefaults(config: Pick<CreateERPTableConfig, 'store' | 'tableKey' | 'actor'>): ResolvedGridIdentity;
+
+/**
+ * Sync composition root (D24). Returns immediately; EventStore / snapshot
+ * load runs in the background. Await `grid.ready` before using `engine` / `api`.
+ */
+declare function createGrid<TRow = unknown>(config?: CreateGridConfig<TRow>): CreateGridResult<TRow>;
+/**
+ * @deprecated Prefer {@link createGrid} (D24). `await createERPTable(cfg)` is
+ * equivalent to `await createGrid(cfg).ready`.
+ */
+declare function createERPTable<TRow = unknown>(config?: CreateERPTableConfig<TRow>): Promise<CreateGridResult<TRow>>;
+
+/**
+ * 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[];
+};
+
+/** Resolve the persisted column id (`colId` wins, then `field`). */
+declare function columnDefFieldName<TRow, TValue = unknown>(def: ColumnDef<TRow, TValue>): string;
+/**
+ * Generic `ColumnDef` → legacy/ERP `ColumnSchema`.
+ * Unmapped ColumnDef fields are stored on `schema.columnDef` for the reverse map.
+ */
+declare function toColumnSchema<TRow, TValue = unknown>(def: ColumnDef<TRow, TValue>): ColumnSchema;
+/**
+ * Legacy/ERP `ColumnSchema` → generic `ColumnDef`.
+ * `columnSchema` on the result is the source object so `toColumnSchema` is lossless.
+ */
+declare function toColumnDef<TRow = unknown, TValue = unknown>(schema: ColumnSchema): ColumnDef<TRow, TValue> & {
+    columnSchema: ColumnSchema;
+};
+declare function mapColumnDefs<TRow>(defs: ColumnDef<TRow>[]): ColumnSchema[];
+declare function mapColDefOrGroups<TRow>(items: ColDefOrGroup<TRow>[]): ColumnSchema[];
+declare function mapColumnSchemasToDefs<TRow = unknown>(schemas: ColumnSchema[]): Array<ColumnDef<TRow> & {
+    columnSchema: ColumnSchema;
+}>;
+
+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;
+    /** Release the underlying connection (IndexedDB). Stored data is untouched. */
+    close?(): void;
+}
+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;
+    private closed;
+    private closePromise?;
+    private readonly inflight;
+    constructor(db: KvDatabase);
+    static open(dbName?: string): Promise<IndexedDbEventStore>;
+    /** Test / Node helper — durable API with in-memory persistence backend. */
+    static inMemory(): IndexedDbEventStore;
+    /**
+     * Release the IndexedDB connection (stored events are untouched). Waits for
+     * appends already in flight; appends started afterwards are dropped (they
+     * resolve `ok` without writing) because the owning grid is gone. Idempotent.
+     */
+    close(): Promise<void>;
+    append(streamId: string, events: GridEvent[], expectedVersion: number): Promise<AppendResult>;
+    private appendInternal;
+    read(streamId: string, fromVersion?: number): Promise<GridEvent[]>;
+    readAll(fromPosition?: number): Promise<GridEvent[]>;
+    subscribe(streamId: string, onEvent: Listener): Unsubscribe;
+    subscribeAll(onEvent: Listener): Unsubscribe;
+}
+
+/** Default IndexedDB database prefix (PR-80). */
+declare const DEFAULT_EVENT_STORE_PREFIX = "persian-data-grid-events";
+/**
+ * Prefix used by `persian-data-grid@0.5.x`.
+ * Pass as `eventStoreName` to keep reading existing local data.
+ */
+declare const LEGACY_EVENT_STORE_PREFIX = "erp-table-events";
+/** Full IndexedDB name: `{prefix}:{store}`. */
+declare function eventStoreDbName(store: string, prefix?: string): string;
+
+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 — host injects FetchRemoteApi or a custom adapter. */
+declare class NoopRemoteApi implements RemoteApi {
+    request<TResponse = unknown>(): 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[];
+
+/**
+ * Horizontal column window (PR-98).
+ * Variable-width columns via cumulative widths + binary search.
+ * Pinned columns are excluded from the scrollable slice (always rendered by the host).
+ */
+type ColumnVisibleRange = {
+    /** Inclusive start into the scrollable-widths array. */
+    startIndex: number;
+    /** Exclusive end into the scrollable-widths array. */
+    endIndex: number;
+    /** px before the first visible scrollable column. */
+    spacerStart: number;
+    /** px after the last visible scrollable column. */
+    spacerEnd: number;
+    totalScrollableWidth: number;
+    visibleCount: number;
+};
+/** Prefix sums: `cum[i]` = sum(widths[0..i)). Length = widths.length + 1. */
+declare function buildCumulativeWidths(widths: readonly number[]): number[];
+/**
+ * @param scrollableWidths widths of non-pinned columns in document order
+ * @param scrollOffset absolute scroll from table inline-start (px)
+ * @param viewportSize visible width of the scrollport (px)
+ * @param pinnedStartWidth total width of inline-start pinned columns (px)
+ * @param overscan extra columns on each side
+ * @param pinnedEndWidth total width of inline-end pinned columns (px)
+ */
+declare function calculateColumnViewport(scrollableWidths: readonly number[], scrollOffset: number, viewportSize: number, pinnedStartWidth?: number, overscan?: number, pinnedEndWidth?: number): ColumnVisibleRange;
+
+/**
+ * Pure virtual-window calculator — no DOM / window / document.
+ * Vertical: totalRows + Viewport → VisibleRange.
+ * Horizontal (PR-98): scrollable widths + scroll → ColumnVisibleRange.
+ */
+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[];
+    /** Horizontal column window (PR-98). */
+    static calculateColumns(scrollableWidths: readonly number[], scrollOffset: number, viewportSize: number, pinnedStartWidth?: number, overscan?: number, pinnedEndWidth?: number): ColumnVisibleRange;
+    static projectColumns<T>(items: readonly T[], range: ColumnVisibleRange): T[];
+}
+
+/**
+ * Column aggregation model (PR-118 / RFC-002). Pure — no React/DOM.
+ * Built-in aggs are incremental; money uses integer minor units (no float sum).
+ */
+
+declare function isAggFuncName(value: unknown): value is AggFuncName;
+declare function isCustomAggFunc(agg: AggFunc | undefined): agg is (values: readonly unknown[]) => unknown;
+/**
+ * Coerce a cell value to integer minor units (rials).
+ * Rejects non-finite numbers; truncates toward zero (no float accumulation).
+ */
+declare function toMinorUnits(value: unknown): number | null;
+type AggAccumulator = {
+    kind: 'sum';
+    sum: number;
+    count: number;
+} | {
+    kind: 'avg';
+    sum: number;
+    count: number;
+} | {
+    kind: 'min';
+    min: number | null;
+    count: number;
+} | {
+    kind: 'max';
+    max: number | null;
+    count: number;
+} | {
+    kind: 'count';
+    count: number;
+} | {
+    kind: 'first';
+    value: unknown;
+    set: boolean;
+} | {
+    kind: 'last';
+    value: unknown;
+    set: boolean;
+};
+declare function createAccumulator(kind: AggFuncName): AggAccumulator;
+/** Add one value into an accumulator. Returns 'rebuild' when min/max need a full pass. */
+declare function accumulateAdd(acc: AggAccumulator, value: unknown): 'ok' | 'rebuild';
+/** Remove one value from an accumulator (cell edit old value). */
+declare function accumulateRemove(acc: AggAccumulator, value: unknown): 'ok' | 'rebuild';
+declare function readAccumulator(acc: AggAccumulator): unknown;
+/** Full (non-incremental) aggregate over a value list. */
+declare function applyAgg(agg: AggFunc | undefined, values: readonly unknown[]): unknown;
+type ColumnAggSpec = {
+    colId: string;
+    aggFunc: AggFunc;
+};
+/**
+ * Resolve which columns participate in footer aggregates (PR-119).
+ * - If any column declares `columnDef.aggFunc`, only those columns aggregate
+ *   (columns without aggFunc stay empty — verify).
+ * - Else legacy: `price` / `number` columns default to `sum` (0.5.x hosts).
+ */
+declare function resolveColumnAggSpecs(columns: readonly {
+    fieldName: string;
+    fieldType?: string;
+    columnDef?: {
+        aggFunc?: AggFunc;
+    } | undefined;
+}[]): ColumnAggSpec[];
+/**
+ * Incremental per-column aggregates (PR-118).
+ * Custom functions always rebuild; built-ins patch in O(1) when possible.
+ */
+declare class ColumnAggIndex {
+    private readonly states;
+    private dirty;
+    invalidate(): void;
+    get isDirty(): boolean;
+    clear(): void;
+    /**
+     * Rebuild all tracked columns. `valuesFor` supplies current values per colId.
+     */
+    rebuild(specs: readonly ColumnAggSpec[], valuesFor: (colId: string) => readonly unknown[]): void;
+    /**
+     * O(1) patch for a cell change. Returns false if a rebuild is required.
+     */
+    patch(colId: string, oldValue: unknown, newValue: unknown): boolean;
+    get(colId: string): unknown;
+    toRecord(): Record<string, unknown>;
+    /** Numeric-only view for legacy footer (`Record<string, number>`). */
+    toNumberRecord(): Record<string, number>;
+}
+
+type QuickFilterBlobAccessor = {
+    /** Searchable cell values for one row (value + display, etc.). */
+    getParts: (rowId: number) => readonly unknown[];
+};
+/** Normalize query / cell text for quick filter (digits + ي/ك). */
+declare function normalizeQuickFilterText(value: string): string;
+/**
+ * Flatten row parts into one searchable blob (PR-93).
+ * Empty / null parts are skipped.
+ */
+declare function buildQuickFilterBlob(parts: readonly unknown[]): string;
+/**
+ * Per-row text cache + inverted token → rowIds (PR-93).
+ * Typing reuses blobs (no per-keystroke cell walk). Cell edits update one row.
+ */
+declare class QuickFilterIndex {
+    private readonly blobs;
+    private readonly inverted;
+    clear(): void;
+    get size(): number;
+    getBlob(rowId: number): string;
+    rowIds(): IterableIterator<number>;
+    has(rowId: number): boolean;
+    removeRow(rowId: number): void;
+    setRow(rowId: number, parts: readonly unknown[]): void;
+    /** Rebuild from an ordered id list + accessor (full invalidate). */
+    rebuild(rowIds: readonly number[], accessor: QuickFilterBlobAccessor): void;
+    /**
+     * Candidate rows for one query part via inverted tokens (prefix / equality).
+     * Used to narrow before blob `includes` verification.
+     */
+    private candidatesForPart;
+    /**
+     * Filter `rowIds` whose cached blob contains every whitespace-separated
+     * query part (AND). Empty / blank query ⇒ shallow copy of `rowIds`.
+     */
+    filter(rowIds: readonly number[], quickFilterText: string | null | undefined): number[];
+}
+/**
+ * Pure quick filter over a blob getter (PR-93). Prefer {@link QuickFilterIndex}
+ * when filtering repeatedly (typing).
+ */
+declare function applyQuickFilter(rowIds: readonly number[], quickFilterText: string | null | undefined, getBlob: ((rowId: number) => string) | QuickFilterIndex): number[];
+
+/**
+ * Adapter: TableEngine → GridQueryPort for export plugins.
+ * When row grouping is active, projects the flat UI index (group + leaf).
+ */
+declare function createEngineGridQuery(engine: TableEngine): GridQueryPort;
+
+export { accumulateRemove as $, type AggAccumulator as A, type KvStore as B, CATALOG_TO_HOST_CALLBACKS as C, DEFAULT_EVENT_STORE_PREFIX as D, EVENT_CATALOG as E, QuickFilterIndex as F, type GetRowId as G, type HostColumnSchema as H, InMemoryEventStore as I, ROW_DATA_UPDATED_CATALOG_TYPES as J, type KvDatabase as K, LEGACY_EVENT_STORE_PREFIX as L, MemoryKvDatabase as M, NoopRemoteApi as N, type RequestExportOptions as O, PluginHost as P, type QuickFilterBlobAccessor as Q, type RowInput as R, type RequestImportOptions as S, type RowDataUpdatedEvent as T, type RowValueChangedEvent as U, type SelectionChangedEvent as V, type SnapshotStore as W, SnapshotStrategy as X, type StartEditingCellParams as Y, ViewportCalculator as Z, accumulateAdd as _, type AggregateSnapshot as a, applyAgg as a0, applyQuickFilter as a1, buildCumulativeWidths as a2, buildQuickFilterBlob as a3, calculateColumnViewport as a4, columnDefFieldName as a5, createAccumulator as a6, createERPTable as a7, createEngineGridQuery as a8, createGrid as a9, createGridApi as aa, createGridTableKey as ab, dispatchCatalogHostEvent as ac, eventStoreDbName as ad, getEventCatalogEntry as ae, isAggFuncName as af, isCustomAggFunc as ag, listUndoableEventTypes as ah, mapColumnDefs as ai, mapColumnSchemas as aj, mapColumnSchemasToDefs as ak, normalizeQuickFilterText as al, openIndexedDbDatabase as am, readAccumulator as an, resolveColumnAggSpecs as ao, resolveCreateGridDefaults as ap, subscribeCatalogHostEvents as aq, toColumnDef as ar, toColumnDefinition as as, toColumnSchema as at, toColumnViewBinding as au, toMinorUnits as av, type CatalogHostEventHandlers as aw, mapColDefOrGroups as ax, type CellFocusedEvent as b, type CellValueChangedEvent as c, type CollectionRowMap as d, ColumnAggIndex as e, type ColumnAggSpec as f, type ColumnDefinition as g, type ColumnViewBinding as h, type ColumnVisibleRange as i, type CreateERPTableConfig as j, type CreateERPTableResult as k, type CreateGridApiInput as l, type CreateGridConfig as m, type CreateGridResult as n, DEFAULT_GRID_ACTOR as o, DEFAULT_MEMORY_STORE as p, type EventCatalogEntry as q, type ExportDataAsExcelOptions as r, type GridApi as s, type GridColumnState as t, type GridDatasource as u, type GridDatasourceGetRowsParams as v, type GridDatasourceGetRowsResult as w, type GridRowNode as x, InMemorySnapshotStore as y, IndexedDbEventStore as z };