@snowtop/ent 0.1.0-alpha8 → 0.1.0-alpha80

package/action/action.d.ts

@@ -7,14 +7,16 @@ export declare enum WriteOperation {
     Edit = "edit",
     Delete = "delete"
 }
-export interface Builder<T extends Ent> {
-    existingEnt?: T;
-    ent: EntConstructor<T>;
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export interface Builder<TEnt extends Ent<TViewer>, TViewer extends Viewer = Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    existingEnt: TExistingEnt;
+    ent: EntConstructor<TEnt, TViewer>;
     placeholderID: ID;
-    readonly viewer: Viewer;
-    build(): Promise<Changeset<T>>;
+    readonly viewer: TViewer;
+    build(): Promise<Changeset>;
     operation: WriteOperation;
-    editedEnt?(): Promise<T | null>;
+    editedEnt?(): Promise<TEnt | null>;
     nodeType: string;
 }
 export interface Executor extends Iterable<DataOperation>, Iterator<DataOperation> {
@@ -25,39 +27,39 @@ export interface Executor extends Iterable<DataOperation>, Iterator<DataOperatio
     postFetch?(queryer: Queryer, context?: Context): Promise<void>;
     executeObservers?(): Promise<void>;
 }
-export interface Changeset<T extends Ent> {
+export interface Changeset {
     executor(): Executor;
     viewer: Viewer;
     placeholderID: ID;
-    changesets?: Changeset<Ent>[];
+    changesets?: Changeset[];
     dependencies?: Map<ID, Builder<Ent>>;
 }
-export declare type TriggerReturn = void | Promise<Changeset<Ent> | void | (Changeset<Ent> | void)[]> | Promise<Changeset<Ent>>[];
-export interface Trigger<TBuilder extends Builder<Ent>, TData extends Data> {
-    changeset(builder: TBuilder, input: TData): TriggerReturn;
+export declare type TriggerReturn = void | Promise<Changeset | void | (Changeset | void)[]> | Promise<Changeset>[];
+export interface Trigger<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    changeset(builder: TBuilder, input: TInput): TriggerReturn;
 }
-export interface Observer<TBuilder extends Builder<Ent>, TData extends Data> {
-    observe(builder: TBuilder, input: TData): void | Promise<void>;
+export interface Observer<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    observe(builder: TBuilder, input: TInput): void | Promise<void>;
 }
-export interface Validator<TBuilder extends Builder<Ent>, TData extends Data> {
-    validate(builder: TBuilder, input: TData): Promise<void> | void;
+export interface Validator<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    validate(builder: TBuilder, input: TInput): Promise<void> | void;
 }
-export interface Action<TEnt extends Ent, TBuilder extends Builder<TEnt>, TData extends Data> {
+export interface Action<TEnt extends Ent<TViewer>, TBuilder extends Builder<TEnt, TViewer, TExistingEnt>, TViewer extends Viewer = Viewer, TInput extends Data = Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     readonly viewer: Viewer;
-    changeset(): Promise<Changeset<TEnt>>;
+    changeset(): Promise<Changeset>;
     builder: TBuilder;
     getPrivacyPolicy(): PrivacyPolicy<TEnt>;
-    triggers?: Trigger<TBuilder, TData>[];
-    observers?: Observer<TBuilder, TData>[];
-    validators?: Validator<TBuilder, TData>[];
-    getInput(): TData;
-    transformWrite?: <T2 extends Ent>(stmt: UpdateOperation<T2>) => Promise<TransformedUpdateOperation<T2>> | TransformedUpdateOperation<T2> | undefined;
+    getTriggers?(): (Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt> | Trigger<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[])[];
+    getObservers?(): Observer<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getValidators?(): Validator<TEnt, TBuilder, TViewer, TInput, TExistingEnt>[];
+    getInput(): TInput;
+    transformWrite?: (stmt: UpdateOperation<TEnt, TViewer>) => Promise<TransformedUpdateOperation<TEnt, TViewer>> | TransformedUpdateOperation<TEnt, TViewer> | null;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
-    viewerForEntLoad?(data: Data): Viewer | Promise<Viewer>;
+    viewerForEntLoad?(data: Data, context?: Context<TViewer>): TViewer | Promise<TViewer>;
 }
-export declare function saveBuilder<T extends Ent>(builder: Builder<T>): Promise<void>;
-export declare function saveBuilderX<T extends Ent>(builder: Builder<T>): Promise<void>;
+export declare function saveBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer>(builder: Builder<TEnt, TViewer>): Promise<void>;
+export declare function saveBuilderX<TEnt extends Ent<TViewer>, TViewer extends Viewer>(builder: Builder<TEnt, TViewer>): Promise<void>;
 interface Orchestrator {
     addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
     removeOutboundEdge(id2: ID, edgeType: string): void;

package/action/executor.d.ts

@@ -10,7 +10,7 @@ export declare class ListBasedExecutor<T extends Ent> implements Executor {
     private operations;
     private options?;
     private idx;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation<T>[], options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, T | null> | undefined);
     private lastOp;
     private createdEnt;
     resolveValue(val: ID): Ent | null;
@@ -29,7 +29,7 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     private lastOp;
     private allOperations;
     private executors;
-    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset<T>[], options?: OrchestratorOptions<T, Data>);
+    constructor(viewer: Viewer, placeholderID: ID, operations: DataOperation[], dependencies: Map<ID, Builder<T>>, changesets: Changeset[], options?: OrchestratorOptions<T, Data, Viewer>);
     [Symbol.iterator](): this;
     private handleCreatedEnt;
     next(): IteratorResult<DataOperation<Ent>>;
@@ -39,4 +39,4 @@ export declare class ComplexExecutor<T extends Ent> implements Executor {
     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<Ent>[]>;
+export declare function executeOperations(executor: Executor, context?: Context, trackOps?: true): Promise<DataOperation<Ent<Viewer<Ent<any> | null, ID | null>>>[]>;

package/action/executor.js

@@ -47,11 +47,11 @@ class ListBasedExecutor {
     }
     async executeObservers() {
         const action = this.options?.action;
-        if (!this.options || !action || !action.observers) {
+        if (!this.options || !action || !action.getObservers) {
             return;
         }
         const builder = this.options.builder;
-        await Promise.all(action.observers.map(async (observer) => {
+        await Promise.all(action.getObservers().map(async (observer) => {
             await observer.observe(builder, action.getInput());
         }));
     }

package/action/experimental_action.d.ts

@@ -1,40 +1,47 @@
+import { Orchestrator } from "./orchestrator";
 import { Viewer, Ent, Data } from "../core/base";
 import { Action, WriteOperation, Builder, Trigger, Observer, Changeset, Validator } from "./action";
-export interface ActionOptions<T extends Ent, TData extends Data> {
-    existingEnt?: T | null;
+export interface ActionOptions<TEnt extends Ent<TViewer>, TViewer extends Viewer, TData extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    existingEnt: TExistingEnt;
     input?: TData;
     operation?: WriteOperation;
 }
-interface EntBuilder<T extends Ent> extends Builder<T> {
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export interface EntBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> extends Builder<TEnt, TViewer, TExistingEnt> {
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<void>;
     saveX(): Promise<void>;
-    editedEnt(): Promise<T | null>;
-    editedEntX(): Promise<T>;
+    editedEnt(): Promise<TEnt | null>;
+    editedEntX(): Promise<TEnt>;
+    getInput(): TInput;
+    orchestrator: Orchestrator<TEnt, TInput, TViewer, TExistingEnt>;
 }
-export declare class BaseAction<TEnt extends Ent, TData extends Data> implements Action<TEnt, EntBuilder<TEnt>, TData> {
-    viewer: Viewer;
-    builderCtr: BuilderConstructor<TEnt, TData>;
-    builder: EntBuilder<TEnt>;
+export declare class BaseAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> implements Action<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt> {
+    viewer: TViewer;
+    builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>;
+    builder: EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
     private input;
-    triggers: Trigger<EntBuilder<TEnt>, TData>[];
-    observers: Observer<EntBuilder<TEnt>, TData>[];
-    validators: Validator<EntBuilder<TEnt>, TData>[];
-    getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent>;
-    constructor(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TData>, options?: ActionOptions<TEnt, TData> | null);
-    static createBuilder<TEnt extends Ent, TData extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TData>, options?: ActionOptions<TEnt, TData> | null): Builder<TEnt>;
-    static bulkAction<TEnt extends Ent, TData extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TData>, ...actions: Action<Ent, Builder<Ent>, Data>[]): BaseAction<TEnt, TData>;
-    changeset(): Promise<Changeset<TEnt>>;
+    getPrivacyPolicy(): import("../core/base").PrivacyPolicy<Ent<Viewer<Ent<any> | null, import("../core/base").ID | null>>, Viewer<Ent<any> | null, import("../core/base").ID | null>>;
+    getTriggers(): Trigger<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    getObservers(): Observer<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    getValidators(): Validator<TEnt, EntBuilder<TEnt, TViewer, TInput, TExistingEnt>, TViewer, TInput, TExistingEnt>[];
+    constructor(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>);
+    static createBuilder<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TExistingEnt>, options: ActionOptions<TEnt, TViewer, TInput, TExistingEnt>): Builder<TEnt>;
+    static bulkAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(ent: TEnt, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, ...actions: Action<Ent, Builder<Ent, any>>[]): BaseAction<TEnt, TViewer, TInput, TEnt>;
+    changeset(): Promise<Changeset>;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
     save(): Promise<TEnt | null>;
     saveX(): Promise<TEnt>;
-    getInput(): TData;
+    getInput(): TInput;
 }
-interface BuilderConstructor<TEnt extends Ent, TData extends Data> {
-    new (viewer: Viewer, operation: WriteOperation, action: Action<TEnt, EntBuilder<TEnt>, TData>, existingEnt?: TEnt | undefined): EntBuilder<TEnt>;
+export interface BuilderConstructor<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
+    new (viewer: TViewer, operation: WriteOperation, action: Action<TEnt, any, TViewer, TInput, TExistingEnt>, existingEnt: TExistingEnt): EntBuilder<TEnt, TViewer, TInput, TExistingEnt>;
 }
-export declare function updateRawObject<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TInput>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
-export declare function getSimpleEditAction<TEnt extends Ent, TInput extends Data>(viewer: Viewer, builderCtr: BuilderConstructor<TEnt, TInput>, existingEnt: TEnt, input: TInput): Action<TEnt, Builder<TEnt>, TInput>;
+export declare function updateRawObject<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): Promise<TEnt>;
+export declare function getSimpleEditAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleDeleteAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, TEnt>, existingEnt: TEnt, input: TInput): BaseAction<TEnt, TViewer, TInput, TEnt>;
+export declare function getSimpleInsertAction<TEnt extends Ent<TViewer>, TViewer extends Viewer, TInput extends Data>(viewer: TViewer, builderCtr: BuilderConstructor<TEnt, TViewer, TInput, null>, input: TInput): BaseAction<TEnt, TViewer, TInput, null>;
 export {};

package/action/experimental_action.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
+exports.getSimpleInsertAction = exports.getSimpleDeleteAction = exports.getSimpleEditAction = exports.updateRawObject = exports.BaseAction = void 0;
 const privacy_1 = require("../core/privacy");
 const action_1 = require("./action");
 class BaseAction {
     constructor(viewer, builderCtr, options) {
         this.viewer = viewer;
         this.builderCtr = builderCtr;
-        this.triggers = [];
-        this.observers = [];
-        this.validators = [];
         let operation = options?.operation;
         if (!operation) {
             if (options?.existingEnt) {
@@ -20,11 +17,20 @@ class BaseAction {
             }
         }
         this.input = options?.input || {};
-        this.builder = new builderCtr(viewer, operation, this, options?.existingEnt || undefined);
+        this.builder = new builderCtr(viewer, operation, this, options.existingEnt);
     }
     getPrivacyPolicy() {
         return privacy_1.AlwaysAllowPrivacyPolicy;
     }
+    getTriggers() {
+        return [];
+    }
+    getObservers() {
+        return [];
+    }
+    getValidators() {
+        return [];
+    }
     static createBuilder(viewer, builderCtr, options) {
         let action = new BaseAction(viewer, builderCtr, options);
         return action.builder;
@@ -35,7 +41,7 @@ class BaseAction {
         let action = new BaseAction(ent.viewer, builderCtr, {
             existingEnt: ent,
         });
-        action.triggers = [
+        action.getTriggers = () => [
             {
                 changeset: () => {
                     return actions.map((action) => action.changeset());
@@ -79,6 +85,7 @@ async function updateRawObject(viewer, builderCtr, existingEnt, input) {
     return action.saveX();
 }
 exports.updateRawObject = updateRawObject;
+// TODO need to fix types for all these
 // creates an action which has no privacy, triggers, observers etc
 // does do field validation
 // useful to batch a bunch of writes together with BaseAction.bulkAction
@@ -91,3 +98,19 @@ function getSimpleEditAction(viewer, builderCtr, existingEnt, input) {
     });
 }
 exports.getSimpleEditAction = getSimpleEditAction;
+function getSimpleDeleteAction(viewer, builderCtr, existingEnt, input) {
+    return new BaseAction(viewer, builderCtr, {
+        existingEnt: existingEnt,
+        operation: action_1.WriteOperation.Delete,
+        input,
+    });
+}
+exports.getSimpleDeleteAction = getSimpleDeleteAction;
+function getSimpleInsertAction(viewer, builderCtr, input) {
+    return new BaseAction(viewer, builderCtr, {
+        operation: action_1.WriteOperation.Insert,
+        input,
+        existingEnt: null,
+    });
+}
+exports.getSimpleInsertAction = getSimpleInsertAction;

package/action/orchestrator.d.ts

@@ -1,19 +1,22 @@
 import { ID, Data, Ent, Viewer, EntConstructor, LoadEntOptions } from "../core/base";
 import { AssocEdgeInputOptions, DataOperation } from "../core/ent";
-import { SchemaInputType } from "../schema/schema";
+import { SchemaInputType, FieldInfoMap } from "../schema/schema";
 import { Changeset, Executor } from "../action/action";
 import { WriteOperation, Builder, Action } from "../action";
-export interface OrchestratorOptions<TEnt extends Ent, TData extends Data> {
+declare type MaybeNull<T extends Ent> = T | null;
+declare type TMaybleNullableEnt<T extends Ent> = T | MaybeNull<T>;
+export interface OrchestratorOptions<TEnt extends Ent<TViewer>, TInput extends Data, TViewer extends Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     viewer: Viewer;
     operation: WriteOperation;
     tableName: string;
-    loaderOptions: LoadEntOptions<TEnt>;
+    loaderOptions: LoadEntOptions<TEnt, TViewer>;
     key: string;
-    builder: Builder<TEnt>;
-    action?: Action<TEnt, Builder<TEnt>, TData>;
+    builder: Builder<TEnt, TViewer, TExistingEnt>;
+    action?: Action<TEnt, Builder<TEnt, TViewer>, TViewer, TInput>;
     schema: SchemaInputType;
     editedFields(): Map<string, any> | Promise<Map<string, any>>;
-    updateInput?: (data: TData) => void;
+    updateInput?: (data: TInput) => void;
+    fieldInfo: FieldInfoMap;
 }
 interface edgeInputDataOpts {
     edgeType: string;
@@ -28,7 +31,7 @@ export declare enum edgeDirection {
     inboundEdge = 0,
     outboundEdge = 1
 }
-export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
+export declare class Orchestrator<TEnt extends Ent<TViewer>, TInput extends Data, TViewer extends Viewer, TExistingEnt extends TMaybleNullableEnt<TEnt> = MaybeNull<TEnt>> {
     private options;
     private edgeSet;
     private edges;
@@ -42,13 +45,14 @@ export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
     private defaultFieldsByFieldName;
     private defaultFieldsByTSName;
     private actualOperation;
-    private existingEnt?;
+    private existingEnt;
     private disableTransformations;
-    constructor(options: OrchestratorOptions<TEnt, TData>);
+    private memoizedGetFields;
+    constructor(options: OrchestratorOptions<TEnt, TInput, TViewer, TExistingEnt>);
     private addEdge;
     setDisableTransformations(val: boolean): void;
-    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;
+    addInboundEdge<T2 extends Ent>(id1: ID | Builder<T2, any>, edgeType: string, nodeType: string, options?: AssocEdgeInputOptions): void;
+    addOutboundEdge<T2 extends Ent>(id2: ID | Builder<T2, any>, 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[];
@@ -60,34 +64,51 @@ export declare class Orchestrator<TEnt extends Ent, TData extends Data> {
     private getEntForPrivacyPolicyImpl;
     private getSQLStatementOperation;
     private getWriteOpForSQLStamentOp;
-    getPossibleUnsafeEntForPrivacy(): Promise<TEnt | undefined>;
+    getPossibleUnsafeEntForPrivacy(): Promise<TEnt>;
+    getEditedData(): Promise<Data>;
+    /**
+     * @returns validated and formatted fields that would be written to the db
+     * throws an error if called before valid() or validX() has been called
+     */
+    getValidatedFields(): Data;
     private getFieldsInfo;
     private validate;
     private triggers;
     private validators;
     private isBuilder;
+    private getInputKey;
+    private getStorageKey;
     private getFieldsWithDefaultValues;
     private hasData;
     private transformFieldValue;
     private formatAndValidateFields;
     valid(): Promise<boolean>;
     validX(): Promise<void>;
+    /**
+     * @experimental API that's not guaranteed to remain in the future which returns
+     * a list of errors encountered
+     * 0 errors indicates valid
+     * NOTE that this currently doesn't catch errors returned by validators().
+     * If those throws, this still throws and doesn't return them
+     */
+    validWithErrors(): Promise<Error[]>;
     build(): Promise<EntChangeset<TEnt>>;
     private viewerForEntLoad;
     returnedRow(): Promise<Data | null>;
     editedEnt(): Promise<TEnt | null>;
     editedEntX(): Promise<TEnt>;
 }
-export declare class EntChangeset<T extends Ent> implements Changeset<T> {
+export declare class EntChangeset<T extends Ent> implements Changeset {
     viewer: Viewer;
     readonly placeholderID: ID;
     readonly ent: EntConstructor<T>;
     operations: DataOperation[];
-    dependencies?: Map<ID, Builder<Ent>> | undefined;
-    changesets?: Changeset<Ent>[] | undefined;
+    dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined;
+    changesets?: Changeset[] | undefined;
     private options?;
     private _executor;
-    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent>> | undefined, changesets?: Changeset<Ent>[] | undefined, options?: OrchestratorOptions<T, Data> | undefined);
+    constructor(viewer: Viewer, placeholderID: ID, ent: EntConstructor<T>, operations: DataOperation[], dependencies?: Map<ID, Builder<Ent<Viewer<Ent<any> | null, ID | null>>, Viewer<Ent<any> | null, ID | null>, Ent<Viewer<Ent<any> | null, ID | null>> | null>> | undefined, changesets?: Changeset[] | undefined, options?: OrchestratorOptions<T, Data, Viewer<Ent<any> | null, ID | null>, MaybeNull<T>> | undefined);
+    static changesetFrom(builder: Builder<any, any, any>, ops: DataOperation[]): EntChangeset<any>;
     executor(): Executor;
 }
 export {};