import { Component } from 'react';
export interface KeyToComponentIdsMap {
    [key: string]: Component[];
}
export declare type TargetToKeysMap = Map<object, string[]>;
/**
 * collect relation map of the dep key and the component ids
 */
declare class DepCollector {
    dependencyMap: WeakMap<object, KeyToComponentIdsMap>;
    /**
     * Using a small amount of memory to improve execute performance
     */
    reverseDependencyMap: WeakMap<Component<{}, {}, any>, TargetToKeysMap>;
    private componentIdStack;
    private clearCurrentComponentOldDeps;
    start(id: Component): void;
    collect(targetKey: object, propKey: string): void;
    end(): void;
    isObserved(targetKey: object, propKey: string): boolean;
}
export declare const depCollector: DepCollector;
export declare const enum EOperationTypes {
    SET = "set",
    ADD = "add",
    DELETE = "delete",
    CLEAR = "clear",
    GET = "get",
    HAS = "has",
    ITERATE = "iterate"
}
export interface KeyToDiffChangeMap {
    [key: string]: {
        beforeUpdate: any;
        didUpdate: any;
    };
}
export declare type History = WeakMap<object, KeyToDiffChangeMap>;
export declare type HistoryIdSet = Set<object>;
export interface HistoryNode {
    historyKey: HistoryIdSet;
    history: History;
}
export interface HistoryCollectorPayload {
    type: EOperationTypes;
    beforeUpdate: any;
    didUpdate: any;
}
/**
 * collect prop diff history record
 */
declare class HistoryCollector {
    currentHistory?: History;
    /**
     * Considering the memory cost and iteratable, using Set just only keep id.
     */
    currentHistoryIdSet?: HistoryIdSet;
    transactionHistories: HistoryNode[];
    waitTriggerComponentIds: Component[];
    cursor: number;
    collect(target: object, key: string, payload: HistoryCollectorPayload, isNeedRecord?: boolean): void;
    collectComponentId(target: object, key: string, type: EOperationTypes): void;
    endBatch(isClearHistory?: boolean): void;
    canUndo(): boolean;
    canRedo(): boolean;
    /**
     * @todo support multiple steps
     * revert to the previous history status
     */
    undo(stepNum?: number): void;
    /**
     * @todo support multiple steps
     * apply the next history status
     */
    redo(stepNum?: number): void;
    save(): void;
}
export declare const historyCollector: HistoryCollector;
export declare const undo: (stepNum?: number) => void;
export declare const redo: (stepNum?: number) => void;
export declare const getTimeTravelStatus: () => {
    canUndo: boolean;
    canRedo: boolean;
};
export {};