persian-data-grid 0.5.0 → 0.7.0

package/dist/UITableController-C71LXBiX.d.ts

@@ -0,0 +1,678 @@
+import { d as CellRange, e as TableEngine, G as GridEvent, a as Unsubscribe, E as EventStore, f as Table, g as TableActions, h as GridSearchState, F as FilterModel, i as ChangelogProjection, H as HistoryPanelViewModel, j as CellUndoStack, b as GridSession, k as TableViewState, l as ColumnDef, m as GetRowId, M as MobileTableViewState, U as UIRow, R as Row, A as AggFunc, c as CollectionScope, T as TableSnapShot, n as Cell, o as ChangelogQuery, p as ChangelogEntry, q as HistoryQuery, r as HistoryItem, s as ActiveCell, t as CellEditValue, u as MobileEditorState, v as ValidationCallbackResult, V as ValidCell } from './GridSession-CeIfVFck.js';
+import { A as AuditLogger, R as RemoteApi } from './RemoteApi-CCQxiSf1.js';
+
+/**
+ * Pure clipboard payload builder (PR-106).
+ * No DOM — keyboard/UI wiring writes via infrastructure.
+ */
+
+type ClipboardCellSnapshot = {
+    value: unknown;
+    display: string;
+};
+type ClipboardRowSnapshot = {
+    id: number;
+    cells: Record<string, ClipboardCellSnapshot | undefined>;
+    /** Infinite/server placeholder row — skipped in clipboard output. */
+    loading?: boolean;
+};
+type ClipboardColumnMeta = {
+    id: string;
+    header: string;
+};
+type ProcessCellForClipboardParams = {
+    value: unknown;
+    display: string;
+    colId: string;
+    rowIndex: number;
+    rowId: number;
+};
+type ClipboardCopyBuildOptions = {
+    /** When true, use formatted display strings (valueFormatter output). Default false. */
+    copyFormattedValue?: boolean;
+    /** Prepend a header row with column captions. Default false. */
+    copyHeadersToClipboard?: boolean;
+    /** Eastern digits → ASCII for Excel. Default true. */
+    copyDigitsAsLatin?: boolean;
+    processCellForClipboard?: (params: ProcessCellForClipboardParams) => string;
+};
+type ClipboardPayload = {
+    plainText: string;
+    html: string;
+    ranges: readonly CellRange[];
+};
+declare function resolveCopyRanges(ranges: readonly CellRange[], activeCell: {
+    rowIndex: number;
+    colId: string;
+} | null | undefined): CellRange[];
+declare function buildClipboardPayload(input: {
+    ranges: readonly CellRange[];
+    rows: readonly ClipboardRowSnapshot[];
+    columns: readonly ClipboardColumnMeta[];
+    activeCell?: {
+        rowIndex: number;
+        colId: string;
+    } | null;
+    options?: ClipboardCopyBuildOptions;
+}): ClipboardPayload | null;
+
+type ClipboardCopyEvent = {
+    plainText: string;
+    html: string;
+    ranges: readonly CellRange[];
+};
+type ClipboardPasteEvent = {
+    text: string;
+    applied: number;
+    skipped: number;
+    rowsAdded: number;
+};
+type GridPasteRuntimeOptions = {
+    /** When true (default), paste past the last row adds empty rows. */
+    pasteAddsRows?: boolean;
+    onClipboardPaste?: (event: ClipboardPasteEvent) => boolean | void;
+};
+type GridClipboardRuntimeOptions = ClipboardCopyBuildOptions & GridPasteRuntimeOptions & {
+    onClipboardCopy?: (event: ClipboardCopyEvent) => boolean | void;
+};
+type PasteGridResult = {
+    applied: number;
+    skipped: number;
+    rowsAdded: number;
+};
+declare function writeSystemClipboard(payload: Pick<ClipboardPayload, 'plainText' | 'html'>): Promise<void>;
+declare function copyGridSelectionToClipboard(engine: TableEngine, options?: GridClipboardRuntimeOptions): Promise<boolean>;
+declare function cutGridSelectionToClipboard(engine: TableEngine, store: string, tableKey: string, options?: GridClipboardRuntimeOptions): Promise<boolean>;
+declare function readSystemClipboardText(): Promise<string>;
+declare function pasteGridFromClipboard(engine: TableEngine, store: string, tableKey: string, options?: GridClipboardRuntimeOptions): Promise<PasteGridResult>;
+
+/** Conflict resolution policy (PR-138). */
+type SyncConflictPolicy = 'lastWriteWins' | 'serverWins' | 'manual';
+type SyncCellKey = {
+    readonly rowId: number;
+    readonly columnId: string;
+};
+/** One side of a cell conflict (local or remote). */
+type SyncConflictSide = {
+    readonly eventId: string;
+    readonly value: unknown;
+    readonly occurredAt: number;
+    readonly version: number;
+};
+type SyncConflict = {
+    readonly id: string;
+    readonly key: SyncCellKey;
+    readonly local: SyncConflictSide;
+    readonly remote: SyncConflictSide;
+};
+type ManualResolution = 'local' | 'remote';
+type SyncTransport = {
+    /** Push local events to the remote log. Returns accepted event ids. */
+    push(events: readonly GridEvent[]): Promise<{
+        acceptedIds: readonly string[];
+    }>;
+    /** Pull remote events after `since` cursor. */
+    pull(since: number): Promise<{
+        events: readonly GridEvent[];
+        cursor: number;
+    }>;
+};
+type SyncResult = {
+    readonly pushed: number;
+    readonly pulled: number;
+    readonly applied: number;
+    readonly conflicts: readonly SyncConflict[];
+};
+/**
+ * SyncPort: push local pending events, pull remote, resolve cell conflicts.
+ * OCC on EventStore remains the local concurrency gate; this port is
+ * cross-client merge (PR-138).
+ */
+type SyncPort = {
+    getPolicy(): SyncConflictPolicy;
+    setPolicy(policy: SyncConflictPolicy): void;
+    getOpenConflicts(): readonly SyncConflict[];
+    /** Push + pull + apply policy. */
+    sync(): Promise<SyncResult>;
+    /**
+     * Resolve one manual conflict. `choice: 'local'` keeps local value;
+     * `'remote'` applies the server value.
+     */
+    resolveConflict(conflictId: string, choice: ManualResolution): Promise<void>;
+    subscribeConflicts(listener: (conflicts: readonly SyncConflict[]) => void): () => void;
+    /**
+     * Release listeners / deferred state when the grid is torn down. After
+     * this, `sync()` is a no-op that returns an empty result. Optional so
+     * custom SyncPort implementations keep compiling.
+     */
+    dispose?(): void;
+};
+
+/** Peer presence snapshot (PR-139). */
+type PresencePeer = {
+    readonly peerId: string;
+    readonly actorId: string;
+    readonly label: string;
+    readonly color: string;
+    /** Active cell, if any. */
+    readonly rowId: number | null;
+    readonly columnId: string | null;
+    readonly updatedAt: number;
+};
+type PresenceLocalState = {
+    readonly peerId: string;
+    readonly actorId: string;
+    readonly label: string;
+    readonly color: string;
+    rowId: number | null;
+    columnId: string | null;
+};
+type PresenceMessage = {
+    readonly kind: 'presence';
+    readonly peer: PresencePeer;
+} | {
+    readonly kind: 'leave';
+    readonly peerId: string;
+};
+type PresenceTransport = {
+    publish(message: PresenceMessage): void;
+    subscribe(listener: (message: PresenceMessage) => void): () => void;
+};
+type PresencePort = {
+    getLocal(): PresenceLocalState;
+    getPeers(): readonly PresencePeer[];
+    /** Update local cursor / focus cell and broadcast. */
+    setActiveCell(rowId: number | null, columnId: string | null): void;
+    /** Announce leave and stop. */
+    dispose(): void;
+    subscribe(listener: (peers: readonly PresencePeer[]) => void): () => void;
+};
+
+/** Host / test seam for online detection (no DOM in application/). */
+type ConnectivitySource = {
+    getOnline(): boolean;
+    subscribe(listener: (online: boolean) => void): Unsubscribe;
+};
+/** Optional durable set of synced event ids (host/infra; not DOM here). */
+type SyncWatermarkStore = {
+    load(): readonly string[];
+    save(ids: readonly string[]): void;
+};
+type Connectivity = 'online' | 'offline';
+type PendingChange = {
+    readonly eventId: string;
+    readonly type: string;
+    readonly occurredAt: number;
+    readonly summary: string;
+    /** Full event for SyncPort push (PR-138). */
+    readonly event: GridEvent;
+};
+type OfflineStatusOptions = {
+    readonly tableId: string;
+    readonly connectivity: ConnectivitySource;
+    readonly watermark?: SyncWatermarkStore;
+};
+/**
+ * Product offline session (PR-137): connectivity + pending local data mutations
+ * not yet marked synced (SyncPort in PR-138 will call `markSynced`).
+ */
+declare class OfflineStatus {
+    private readonly options;
+    private online;
+    private pending;
+    private syncedIds;
+    private connectivityUnsub;
+    private storeUnsub;
+    /** Incremented by every stop(); invalidates an in-flight start(). */
+    private lifecycle;
+    private readonly connectivityListeners;
+    private readonly pendingListeners;
+    constructor(options: OfflineStatusOptions);
+    start(eventStore: EventStore): Promise<void>;
+    /** Stop listening and drop all listeners. The instance is inert afterwards. */
+    dispose(): void;
+    stop(): void;
+    getConnectivity(): Connectivity;
+    getPendingChanges(): readonly PendingChange[];
+    getPendingCount(): number;
+    /** Mark pending mutations as synced (clears queue / advances watermark). */
+    markSynced(eventIds?: readonly string[]): void;
+    subscribeConnectivity(listener: (state: Connectivity) => void): Unsubscribe;
+    subscribePending(listener: (items: readonly PendingChange[]) => void): Unsubscribe;
+    private consider;
+    private emitConnectivity;
+    private emitPending;
+    private loadWatermark;
+    private persistWatermark;
+}
+/** Always-online source for Node tests / SSR. */
+declare const alwaysOnlineConnectivity: ConnectivitySource;
+
+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;
+    readonly shiftKey?: boolean;
+    readonly ctrlKey?: boolean;
+}
+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 ReorderColumnUiCommand extends UICommandBase {
+    readonly type: 'COLUMN_REORDERED';
+    readonly sourceIndex: number;
+    readonly destIndex: number;
+}
+interface ToggleRowSelectedUiCommand extends UICommandBase {
+    readonly type: 'TOGGLE_ROW_SELECTED';
+}
+interface TogglePageRowSelectedUiCommand extends UICommandBase {
+    readonly type: 'TOGGLE_PAGE_ROW_SELECTED';
+}
+interface ClearRowSelectionUiCommand extends UICommandBase {
+    readonly type: 'CLEAR_ROW_SELECTION';
+}
+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';
+}
+interface ResizeColumnUiCommand extends UICommandBase {
+    readonly type: 'UI_RESIZE_COLUMN';
+    readonly columnId: string;
+    readonly width: number;
+}
+interface SetColumnVisibleUiCommand extends UICommandBase {
+    readonly type: 'UI_SET_COLUMN_VISIBLE';
+    readonly columnId: string;
+    readonly visible: boolean;
+}
+interface SetSortModelUiCommand {
+    readonly type: 'UI_SET_SORT_MODEL';
+    readonly sortModel: readonly {
+        readonly colId: string;
+        readonly sort: 'asc' | 'desc';
+    }[];
+}
+interface SetQuickFilterTextUiCommand {
+    readonly type: 'UI_SET_QUICK_FILTER_TEXT';
+    readonly quickFilterText: string;
+}
+interface SetFilterModelUiCommand {
+    readonly type: 'UI_SET_FILTER_MODEL';
+    readonly filterModel: FilterModel;
+}
+interface SetRowGroupColumnsUiCommand {
+    readonly type: 'UI_SET_ROW_GROUP_COLUMNS';
+    readonly columns: readonly string[];
+}
+interface SetGroupDefaultExpandedUiCommand {
+    readonly type: 'UI_SET_GROUP_DEFAULT_EXPANDED';
+    readonly expanded: boolean;
+}
+interface ToggleRowGroupUiCommand {
+    readonly type: 'UI_TOGGLE_ROW_GROUP';
+    readonly groupKey: string;
+}
+type UITableCommand = ActiveRowUiCommand | ToggleRowSelectedUiCommand | TogglePageRowSelectedUiCommand | ClearRowSelectionUiCommand | RowSelectedUiCommand | UIMoveActiveVerticalCellEvent | UIMoveActiveCellEvent | UIActiveCellEvent | UIActiveFirstCellEvent | UICellChangeEvent | UIDescriptionSaveEvent | UICellChangeDisplayEvent | ChangePageSizeUiCommand | ChangePageUiCommand | AddEmptyRowUiCommand | AddNewRowsUiCommand | DuplicateRowUiCommand | DeleteRowUiCommand | DeleteTableUiCommand | RegisterTableUiCommand | ToggleRowExpandedUiCommand | ReorderRowUiCommand | ReorderColumnUiCommand | ActionTableUiCommand | ActiveCollectionUiCommand | DeleteSelectedRowsUiCommand | KeyDownUiCommand | SetGridSearchUiCommand | ClearGridSearchUiCommand | OpenMobileAddUiCommand | OpenMobileEditUiCommand | CloseMobileEditorUiCommand | ResizeColumnUiCommand | SetColumnVisibleUiCommand | SetSortModelUiCommand | SetQuickFilterTextUiCommand | SetFilterModelUiCommand | SetRowGroupColumnsUiCommand | SetGroupDefaultExpandedUiCommand | ToggleRowGroupUiCommand;
+
+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 readonly offlineStatus?;
+    private disposed;
+    private layoutViewportWidth;
+    private clipboardOptions;
+    private syncPort?;
+    private presencePort?;
+    /** Set by releaseResources(); the first call's promise is reused (idempotent). */
+    private releasePromise?;
+    private resourceTeardown?;
+    constructor(engine: TableEngine, store: string, tableKey: string, audit: AuditLogger, changelogProjection?: ChangelogProjection | undefined, historyPanelViewModel?: HistoryPanelViewModel | undefined, cellUndoStack?: CellUndoStack | undefined, session?: GridSession | undefined, remoteApi?: RemoteApi | undefined, offlineStatus?: OfflineStatus | undefined);
+    getRemoteApi(): RemoteApi | undefined;
+    getOfflineStatus(): OfflineStatus | undefined;
+    getSyncPort(): SyncPort | undefined;
+    setSyncPort(port: SyncPort | undefined): void;
+    getPresencePort(): PresencePort | undefined;
+    setPresencePort(port: PresencePort | undefined): void;
+    /**
+     * Composition root hook: the callback that releases every resource the grid
+     * created (subscriptions, projections, plugins, owned event store).
+     * Run once by {@link releaseResources}.
+     */
+    setResourceTeardown(teardown: (() => void | Promise<void>) | undefined): void;
+    /** True once resources were released (via releaseResources or dispose). */
+    isReleased(): boolean;
+    getPresencePeers(): readonly PresencePeer[];
+    subscribePresencePeers(cb: (peers: readonly PresencePeer[]) => void): () => void;
+    /** Broadcast local active cell to peers (no-op without presence). */
+    publishPresenceCell(rowId: number | null, columnId: string | null): void;
+    getConnectivity(): Connectivity;
+    getPendingChangeCount(): number;
+    getPendingChanges(): readonly PendingChange[];
+    markPendingSynced(eventIds?: readonly string[]): void;
+    subscribeConnectivity(cb: (state: Connectivity) => void): () => void;
+    subscribePendingChanges(cb: (items: readonly PendingChange[]) => void): () => void;
+    getSyncPolicy(): SyncConflictPolicy | undefined;
+    setSyncPolicy(policy: SyncConflictPolicy): void;
+    getOpenSyncConflicts(): readonly SyncConflict[];
+    subscribeSyncConflicts(cb: (conflicts: readonly SyncConflict[]) => void): () => void;
+    syncNow(): Promise<SyncResult | null>;
+    resolveSyncConflict(conflictId: string, choice: ManualResolution): Promise<void>;
+    /** Apply a remote cell value (used by SyncPort; dual-writes via engine). */
+    applySyncedCellValue(rowId: number, columnId: string, value: unknown): Promise<void>;
+    configureClipboard(options: Partial<GridClipboardRuntimeOptions>): void;
+    getClipboardOptions(): GridClipboardRuntimeOptions;
+    applyFillHandleDrag(extendTo: {
+        rowIndex: number;
+        colIndex: number;
+    }, copyOnly: boolean): Promise<PasteGridResult>;
+    private safe;
+    private changePageSize;
+    private changePage;
+    /** Editor of this cell → session draft (written per `cellEditCommit`); otherwise write-through. */
+    private onCellChange;
+    private onDescriptionSave;
+    private onCellDisplayChange;
+    private setActiveCell;
+    private setActiveRow;
+    private moveActiveCellVertical;
+    private reorderRow;
+    private reorderColumns;
+    private addEmptyRow;
+    private openMobileAddEditor;
+    private addNewRows;
+    private duplicateRow;
+    private deleteRow;
+    private deleteRows;
+    private deleteTable;
+    private registerTable;
+    private toggleRowExpanded;
+    private toggleRowSelect;
+    private togglePageRowSelect;
+    private clearRowSelection;
+    private selectFromActiveToLast;
+    private activateFirstEditableCell;
+    private moveToNextCell;
+    private setTableAction;
+    private setActiveCollection;
+    private setGridSearch;
+    private setMobileEditor;
+    private resizeColumn;
+    setColumnVisible(columnId: string, visible: boolean): void;
+    setLayoutViewportWidth(width: number): void;
+    getLayoutViewportWidth(): number;
+    /** Measure header + cell text off-DOM and resize columns (PR-112). */
+    autoSizeColumns(colIds?: string[]): void;
+    setColumnPinned(columnId: string, pinned: 'start' | 'end' | null): void;
+    toggleColumnGroup(groupId: string): void;
+    /** Scale column widths to fit the last known scrollport width (PR-112). */
+    sizeColumnsToFit(containerWidth?: number): void;
+    /** Session-only sort (PR-90). Empty model restores document `index` order. */
+    setSortModel(sortModel: readonly {
+        colId: string;
+        sort: 'asc' | 'desc';
+    }[]): void;
+    /** Session-only quick filter (PR-93). Empty string shows all rows. */
+    setQuickFilterText(quickFilterText: string): void;
+    getQuickFilterText(): string;
+    /** Session-only column filter model (PR-94). */
+    setFilterModel(filterModel: FilterModel): void;
+    /** Session-only row grouping (PR-120). Only the first column is active. */
+    setRowGroupColumns(columns: readonly string[]): void;
+    getRowGroupColumns(): string[];
+    setGroupDefaultExpanded(expanded: boolean): void;
+    toggleRowGroup(groupKey: string): void;
+    getFilterModel(): FilterModel;
+    getViewState(): TableViewState | null | undefined;
+    applyHostRowData<TRow>(rowData: readonly TRow[], columnDefs?: ColumnDef<TRow>[], getRowId?: GetRowId<TRow>): void;
+    getMobileViewState(): MobileTableViewState | null | undefined;
+    getRowView(rowId: number): UIRow | null;
+    getAllRows(): Row[] | null;
+    getAllUIRows(): UIRow[] | null;
+    getUiRowAbsoluteIndex(rowId: number): number;
+    findColumnSearchMatches(columnId: string, query: string): {
+        rowId: number;
+        columnId: string;
+    }[];
+    getColumnTotals(): Record<string, number>;
+    getColumnAggs(): Record<string, unknown>;
+    getColumnAggValue(columnId: string, overrideAgg?: AggFunc): unknown;
+    subscribeColumnTotals(cb: (totals: Record<string, number>) => void): (() => void) | null;
+    subscribeColumnAggs(cb: (aggs: Record<string, unknown>) => void): (() => void) | null;
+    getSnapShot(collectionScope?: CollectionScope): TableSnapShot | null;
+    /** True in persistence 'paged-idb' mode (RAM holds one page window). */
+    isPagedWindow(): boolean;
+    /** Full IndexedDB snapshot for server save / export. */
+    getFullSnapShot(collectionScope?: CollectionScope): Promise<TableSnapShot | null>;
+    /**
+     * Stream serialized row records from IndexedDB in bounded batches (no full
+     * load). Heap holds one batch at a time. Return false from onBatch to stop.
+     */
+    iterateRowsFromDb(collectionScope: CollectionScope, onBatch: (records: {
+        rowId: number;
+        collection: string;
+        sortIndex: number;
+        rowState: string;
+        cells: Record<string, {
+            value: unknown;
+            originalValue: unknown;
+            display: unknown;
+        }>;
+    }[], ordinalBase: number) => Promise<boolean | void>, batchSize?: number): Promise<void>;
+    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;
+    refreshView(): void;
+    clearActiveCell(cancel?: boolean): Promise<void>;
+    startCellEdit(rowId: number, columnId: string): void;
+    cancelCellEdit(): void;
+    commitCellEdit(): Promise<number>;
+    /**
+     * Write what is still in the cell editor (the edit stays open) and wait
+     * until every pending cell write is durable. `getFullSnapShot` /
+     * `iterateRowsFromDb` / exports already do this; call it before reading
+     * synchronous APIs (`getRowView`, `getSnapShot`) for a save.
+     */
+    flushCellEdit(): Promise<void>;
+    /** DataGrid: focus / pointer left the grid (see `stopEditingWhenCellsLoseFocus`). */
+    leaveGridFocus(): Promise<void>;
+    private settleEditsForTeardown;
+    getEditDraft(rowId: number, columnId: string): CellEditValue | null;
+    isEditingCell(rowId: number, columnId: string): boolean;
+    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;
+    /**
+     * Streamed column subscription (Memory Iron Rule compliant): every row's
+     * {id, rowNum, value} is folded into  via  (heap = one batch,
+     * never the full dataset);  fires only when the column data changed.
+     *
+     * Legacy form  (cb receives the
+     * item array) is still supported.
+     */
+    subscribeColumn<T>(columnId: string, collections: CollectionScope, reducer: (acc: T, item: {
+        id: number;
+        rowNum: unknown;
+        value: unknown;
+    }) => T, seed: T, cb: (acc: T) => void): (() => void) | null;
+    subscribeColumn<T>(columnId: string, collections: CollectionScope, cb: (values: Array<{
+        id: number;
+        rowNum: unknown;
+        value: 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;
+    getCellRanges(): readonly CellRange[];
+    addCellRange(range: CellRange): void;
+    /**
+     * Full dispose: `TABLE_DISPOSED` (windowed repo: drop the RAM page window,
+     * other repos: `repo.delete` — unchanged data semantics) followed by
+     * {@link releaseResources}. Idempotent; the promise settles once teardown
+     * finished and never rejects.
+     */
+    dispose(): Promise<void>;
+    /**
+     * Resource-only teardown: stops subscriptions, projections, sync, presence,
+     * plugins, server row model and closes an event store the grid opened.
+     * Does NOT dispatch `TABLE_DISPOSED` — persisted table data is untouched.
+     * Idempotent (same promise on every call); never rejects.
+     */
+    releaseResources(): Promise<void>;
+    private runResourceTeardown;
+    dispatch(command: UITableCommand): Promise<void>;
+    private dispatchInternal;
+}
+
+export { type SyncWatermarkStore as A, type Connectivity as B, type ClipboardCellSnapshot as C, type PendingChange as D, alwaysOnlineConnectivity as E, type GridClipboardRuntimeOptions as G, type ManualResolution as M, OfflineStatus as O, type PresenceLocalState as P, type SyncConflict as S, UITableController as U, type PresenceMessage as a, type PresencePeer as b, type PresencePort as c, type PresenceTransport as d, type SyncConflictPolicy as e, type SyncConflictSide as f, type SyncPort as g, type SyncResult as h, type SyncTransport as i, type PasteGridResult as j, type ClipboardColumnMeta as k, type ClipboardCopyBuildOptions as l, type ClipboardCopyEvent as m, type ClipboardPasteEvent as n, type ClipboardPayload as o, type ClipboardRowSnapshot as p, type GridPasteRuntimeOptions as q, type ProcessCellForClipboardParams as r, buildClipboardPayload as s, copyGridSelectionToClipboard as t, cutGridSelectionToClipboard as u, pasteGridFromClipboard as v, readSystemClipboardText as w, resolveCopyRanges as x, writeSystemClipboard as y, type ConnectivitySource as z };