import TemplateProcessor, { Fork, Op, Snapshot } from "./TemplateProcessor.js";
import { JsonPointerString, MetaInfo } from "./MetaInfoProducer.js";
import { ExecutionPlan, Planner, SerializableExecutionPlan } from "./Planner.js";
import { ExecutionStatus } from "./ExecutionStatus.js";
import { TraversalState } from "./TraversalState.js";
export declare class ParallelPlanner implements Planner {
    private tp;
    private planCache;
    constructor(tp: TemplateProcessor);
    private logCircularDependency;
    getInitializationPlan(jsonPtr: JsonPointerString): ExecutionPlan;
    getMutationPlan(mutationTarget: JsonPointerString, data: any, op: Op): [ExecutionPlan, JsonPointerString[]];
    private prune;
    /**
     * There are situations when an expression can result in multiple parallel paths to the same node.
     * For example like ${a + a.b + a.c} where a is an expression (thus a.b and a.c are not materialized__)
     * will result in `parallel` containing three nodes of '/a'.
     * that cause
     * @param node
     * @private
     */
    private dedupLeaves;
    private pruneFunction;
    private markLeafMutation;
    private removeDegenerates;
    private makeInitializationPlan;
    private getDependenciesNode;
    /**
     * Produces a list of MetaInfos that have no dependees and therefore are places to begin following dependencies
     * from.
     * @private
     */
    private getInitializationPlanEntryPoints;
    execute(plan: ExecutionPlan): Promise<void>;
    private stepIsDescendantOfMutationTarget;
    immediateAndImplicitDependencies(metaInfo: MetaInfo, state: TraversalState): {
        newDependencies: JsonPointerString[];
        previouslyVisitedDependencies: JsonPointerString[];
    };
    restore(executionStatus: ExecutionStatus): Promise<void>;
    private validatePlan;
    private restoreFunctions;
    private restoreIntervalsAndTimers;
    restartIntervalsAndTimers(): Promise<JsonPointerString[]>;
    /**
     * to preserve backward compatibility of the from command, the parallel ple
     * @param jsonPtr
     */
    from(jsonPtr: JsonPointerString): JsonPointerString[];
    toJSON(mutationPlan: ExecutionPlan): SerializableExecutionPlan;
    executeDataChangeCallbacks(plan: ExecutionPlan): Promise<void>;
    fromJSON(planData: SerializableExecutionPlan, snapshot: Snapshot, forks: Map<string, Fork>): ExecutionPlan;
}
//# sourceMappingURL=ParallelPlanner.d.ts.map