import { Ent, EntConstructor, Viewer, ID, Data, PrivacyPolicy, Context } from "../core/base";
import { DataOperation, AssocEdgeInputOptions } from "../core/ent";
import { Queryer } from "../core/db";
export declare enum WriteOperation {
    Insert = "insert",
    Edit = "edit",
    Delete = "delete"
}
export interface Builder<T extends Ent> {
    existingEnt?: Ent;
    ent: EntConstructor<T>;
    placeholderID: ID;
    readonly viewer: Viewer;
    build(): Promise<Changeset<T>>;
    operation: WriteOperation;
    editedEnt?(): Promise<T | null>;
}
export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
    placeholderID: ID;
    resolveValue(val: any): Ent | null;
    execute(): Promise<void>;
    preFetch?(queryer: Queryer, context?: Context): Promise<void>;
    postFetch?(queryer: Queryer, context?: Context): Promise<void>;
    executeObservers?(): Promise<void>;
}
export interface Changeset<T extends Ent> {
    executor(): Executor;
    viewer: Viewer;
    placeholderID: ID;
    ent: EntConstructor<T>;
    changesets?: Changeset<Ent>[];
    dependencies?: Map<ID, Builder<T>>;
}
export declare type TriggerReturn = void | Promise<Changeset<Ent> | void | Changeset<Ent>[] | Changeset<Ent>> | Promise<Changeset<Ent>>[];
export interface Trigger<T extends Ent> {
    changeset(builder: Builder<T>, input: Data): TriggerReturn;
}
export interface Observer<T extends Ent> {
    observe(builder: Builder<T>, input: Data): void | Promise<void>;
}
export interface Validator<T extends Ent> {
    validate(builder: Builder<T>, input: Data): Promise<void> | void;
}
export interface Action<T extends Ent> {
    readonly viewer: Viewer;
    changeset(): Promise<Changeset<T>>;
    builder: Builder<T>;
    getPrivacyPolicy(): PrivacyPolicy;
    triggers?: Trigger<T>[];
    observers?: Observer<T>[];
    validators?: Validator<T>[];
    getInput(): Data;
    valid(): Promise<boolean>;
    validX(): Promise<void>;
    viewerForEntLoad?(data: Data): Viewer | Promise<Viewer>;
}
export declare function saveBuilder<T extends Ent>(builder: Builder<T>): Promise<void>;
export declare function saveBuilderX<T extends Ent>(builder: Builder<T>): Promise<void>;
interface Orchestrator {
    addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): any;
    removeOutboundEdge(id2: ID, edgeType: string): any;
    viewer: Viewer;
}
export declare function setEdgeTypeInGroup<T extends string>(orchestrator: Orchestrator, inputEnumValue: string, id1: ID, id2: ID, nodeType: string, m: Map<T, string>): Promise<void>;
export {};