import { ProxyTarget, Target } from "./proxyObserve";
import { Observer } from "./Observer";
export interface TransactionOptions {
    timePositioning: boolean;
}
export declare class Transaction {
    constructor(options?: Partial<TransactionOptions>);
    static defaultTransaction: Transaction | undefined;
    static defaultTransactionOptions: Partial<TransactionOptions>;
    static createDefaultTransaction(options?: TransactionOptions): Transaction;
    private options;
    private dirtyProxies;
    private undoredo;
    private _updateSequence;
    private undoredoIntermediate;
    private parentTargetProxies;
    __contexts__: Map<Observer, Observer>;
    private withinProxy;
    private withinUndoRedo;
    getState(): {
        dirtyProxies: Map<ProxyTarget, Set<any>>;
        undoredo: (() => void)[][];
        _updateSequence: number;
    };
    setState(savedState: any): void;
    get updateSequence(): number;
    private set updateSequence(value);
    get timePositioning(): boolean | undefined;
    isDefault(): boolean;
    startTopLevelCall(): void;
    endTopLevelCall(): void;
    recordTimePosition(target: Target, key: any, oldValue: any, newValue: any): void;
    recordUndoRedo(undo: () => void, redo: () => void): void;
    addPosition(undoredoIntermediate: Array<() => void>): void;
    undo(): void;
    redo(): void;
    clearUndoRedo(): void;
    rollTo(updateSequence: number): void;
    setDirty(proxy: ProxyTarget, key: any): void;
    rollback(): void;
    commit(): void;
    get canUndo(): boolean;
    get canRedo(): boolean;
    referenceContext(): void;
    notifyContext(): void;
    addParentTargetProxy(target: Target, proxyTarget: ProxyTarget): void;
    getProxyFromParentTarget(target: Target): ProxyTarget | undefined;
}