import { ID, Ent, Viewer, EntConstructor, Context } from "../core/base";
import { DataOperation } from "../core/ent";
import { Changeset, Executor } from "../action";
import { Builder } from "../action";
import { OrchestratorOptions } from "./orchestrator";
import { Queryer } from "../core/db";
export declare class ListBasedExecutor<T extends Ent> implements Executor {
    private viewer;
    placeholderID: ID;
    private ent;
    private operations;
    private options?;
    private idx;
    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], options?: OrchestratorOptions<T> | undefined);
    private lastOp;
    private createdEnt;
    resolveValue(val: ID): Ent | null;
    [Symbol.iterator](): this;
    next(): IteratorResult<DataOperation>;
    executeObservers(): Promise<void>;
    execute(): Promise<void>;
    preFetch?(queryer: Queryer, context: Context): Promise<void>;
    postFetch?(queryer: Queryer, context: Context): Promise<void>;
}
export declare class ComplexExecutor<T extends Ent> implements Executor {
    private viewer;
    placeholderID: ID;
    private ent;
    private options?;
    private idx;
    private mapper;
    private lastOp;
    private allOperations;
    private changesetMap;
    private nodeOpMap;
    private executors;
    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset<T>[], options?: OrchestratorOptions<T> | undefined);
    [Symbol.iterator](): this;
    private handleCreatedEnt;
    next(): IteratorResult<DataOperation>;
    resolveValue(val: ID): Ent | null;
    executeObservers(): Promise<void>;
    execute(): Promise<void>;
    preFetch?(queryer: Queryer, context: Context): Promise<void>;
    postFetch?(queryer: Queryer, context: Context): Promise<void>;
}
export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation[]>;