/**
 * Transaction layer: every edit to a Sheet goes through here so undo/redo
 * and formula recalculation stay consistent. See ARCHITECTURE.md §2.1 and §6.
 */
import { Sheet, Cell } from './model.js';
export interface CellEdit {
    row: number;
    col: number;
    before: Cell;
    after: Cell;
    /** Sheet dimensions immediately before/after this edit — needed so undo can
     *  restore the exact prior grid shape, not just cell contents. Discovered
     *  as a real bug via the fuzz test in tests/fuzz.test.ts (see ARCHITECTURE.md §6). */
    beforeDims: {
        rowCount: number;
        colCount: number;
    };
    afterDims: {
        rowCount: number;
        colCount: number;
    };
}
export interface Transaction {
    edits: CellEdit[];
    timestamp: number;
}
export interface CommitResult {
    transaction: Transaction;
    recalculated: string[];
}
export declare class TransactionalSheet {
    readonly sheet: Sheet;
    private undoStack;
    private redoStack;
    private maxHistory;
    constructor(sheet: Sheet, opts?: {
        maxHistory?: number;
    });
    /** Set a single cell's raw input. Formulas (leading '=') are stored and evaluated;
     *  everything else is stored as a literal value. Returns the committed transaction. */
    setCellInput(row: number, col: number, raw: string | number | boolean | null): CommitResult;
    undo(): boolean;
    redo(): boolean;
    canUndo(): boolean;
    canRedo(): boolean;
    private pushUndo;
    /**
     * Recalculate every formula cell. For the MVP this is a full sweep (correct,
     * not yet minimal) — each formula's own evaluator already does per-call cycle
     * detection via makeSheetResolver's visiting-set, so correctness holds even
     * though this isn't a topologically-minimal recompute yet.
     */
    recalculate(): string[];
    /** Cells that would need recalculation if `ref` changes — for future incremental recalc. */
    dependentsOf(ref: string): string[];
}