import { ID, Data, Ent, Viewer, EntConstructor, LoadEntOptions } from "../core/base";
import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
import { SchemaInputType } from "../schema/schema";
import { Changeset, Executor } from "../action";
import { WriteOperation, Builder, Action } from "../action";
export interface OrchestratorOptions<T extends Ent> {
    viewer: Viewer;
    operation: WriteOperation;
    tableName: string;
    loaderOptions: LoadEntOptions<T>;
    key: string;
    builder: Builder<T>;
    action?: Action<T>;
    schema: SchemaInputType;
    editedFields(): Map<string, any>;
}
interface edgeInputDataOpts {
    edgeType: string;
    id: Builder<Ent> | ID;
    nodeType?: string;
    options?: AssocEdgeInputOptions;
}
export interface EdgeInputData extends edgeInputDataOpts {
    isBuilder(id: Builder<Ent> | ID): id is Builder<Ent>;
}
export declare enum edgeDirection {
    inboundEdge = 0,
    outboundEdge = 1
}
export declare class Orchestrator<T extends Ent> {
    private options;
    private edgeSet;
    private edges;
    private validatedFields;
    private logValues;
    private changesets;
    private dependencies;
    private fieldsToResolve;
    private mainOp;
    viewer: Viewer;
    constructor(options: OrchestratorOptions<T>);
    private addEdge;
    addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
    addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
    removeInboundEdge(id1: ID, edgeType: string): void;
    removeOutboundEdge(id2: ID, edgeType: string): void;
    getInputEdges(edgeType: string, op: WriteOperation): EdgeInputData[];
    clearInputEdges(edgeType: string, op: WriteOperation, id?: ID): void;
    private buildMainOp;
    private getEdgeOperation;
    private buildEdgeOps;
    private throwError;
    private validate;
    private triggers;
    private validators;
    private isBuilder;
    private validateFields;
    valid(): Promise<boolean>;
    validX(): Promise<void>;
    build(): Promise<EntChangeset<T>>;
    private viewerForEntLoad;
    returnedRow(): Promise<Data | null>;
    editedEnt(): Promise<T | null>;
    editedEntX(): Promise<T>;
}
export declare class EntChangeset<T extends Ent> implements Changeset<T> {
    viewer: Viewer;
    readonly placeholderID: ID;
    readonly ent: EntConstructor<T>;
    operations: DataOperation[];
    dependencies?: Map<ID, Builder<T>> | undefined;
    changesets?: Changeset<Ent>[] | undefined;
    private options?;
    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<T>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T> | undefined);
    executor(): Executor;
}
export {};