@elyx-code/project-logic-tree 0.0.6161 → 0.0.6162

package/dist/tree/state/condition/condition.d.ts

@@ -1,15 +1,19 @@
 import { EntityId, EntityType, ICondition, IConditionTransfer, IConditionReference, IConditionShallowTransfer, ElementShallowTransfer, IConditionGenerationTarget, ElementGenerationTarget, ConditionTypesUnion, EntityVersion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
-import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState } from '../types';
 import { ActionInputMapState } from '../input-map';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { ActionOutputMapState } from '../output-map';
 import { ActionDescriptorState } from '../action-descriptor';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class ConditionState extends VersionedState implements ICondition, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare enum ConditionDependencyField {
+    Parent = "parent"
+}
+export declare class ConditionState extends VersionedState implements ICondition, UserManagedEntityStateTemplate, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: ICondition | IConditionTransfer;
     readonly id: EntityId;
     x: number;
@@ -25,9 +29,14 @@ export declare class ConditionState extends VersionedState implements ICondition
     project: ProjectState;
     errors: EntityError[];
     parent: EntityWithLogicScopeState | ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: ICondition | IConditionTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.Condition;
@@ -55,49 +64,49 @@ export declare class ConditionState extends VersionedState implements ICondition
         errors: EntityGenerationError[];
         modifiedData: Partial<IConditionGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): ConditionState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ConditionState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ConditionState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ConditionState>>;
     hydrateAncestors(): IChangeSet<ConditionState>;
-    afterAllChildrenInitialized(): IChangeSet<ConditionState>;
-    addSelfToProject(): IChangeSet<ConditionState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ConditionState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ConditionState>;
     get calledBy(): CallerEntityState[];
     removeInput(input: ActionInputMapState): ConditionState;
     addInput(input: ActionInputMapState): ConditionState;
     addOutput(_: ActionOutputMapState): ConditionState;
     removeOutput(_: ActionOutputMapState): ConditionState;
-    addSuccessCaller(caller: PassThroughCallableEntityState): ConditionState;
-    addErrorCaller(caller: PassThroughCallableEntityState): ConditionState;
-    addEntryCaller(caller: EntryPointEntityState): ConditionState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): ConditionState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): ConditionState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): ConditionState;
     addErrorCall(call: CallableEntityState): ConditionState;
     addSuccessCall(call: CallableEntityState): ConditionState;
     removeCall(call: CallableEntityState): ConditionState;
-    removeCaller(caller: CallerEntityState): ConditionState;
-    setParent(parent: EntityWithLogicScopeState | ProjectState): ConditionState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): ConditionState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): ConditionState;
     setDeclaration(declaration: ActionDescriptorState): ConditionState;
-    initChildren(): ConditionState;
+    initChildren(changeSet?: ChangeSet | null): ConditionState;
     subscribe(): ConditionState;
     unsubscribe(): ConditionState;
-    sync(data: Partial<ICondition | IConditionTransfer | IConditionShallowTransfer>): ConditionState;
+    metaSync(data: Partial<ICondition | IConditionTransfer | IConditionShallowTransfer>, changeSet?: ChangeSet | null): ConditionState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ConditionState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ConditionState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ConditionState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ConditionState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ConditionState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IConditionShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: EntityState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<EntityState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IConditionTransfer | IConditionReference;
@@ -116,7 +125,7 @@ export declare class ConditionState extends VersionedState implements ICondition
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
     clone(parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): ConditionState;
-    removeUnrecognizedInputs(): IChangeSet<ConditionState>;
-    syncMissingFixedInputs(): IChangeSet<ConditionState>;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<ConditionState>;
+    syncMissingFixedInputs(changeSet?: ChangeSet | null): IChangeSet<ConditionState>;
 }
 export type ConditionPayloadUnion = ConditionTypesUnion | ConditionState;

package/dist/tree/state/condition/validation/validation-schema.d.ts

@@ -2023,8 +2023,6 @@ export declare function getConditionSchema(): z.ZodObject<z.objectUtil.extendSha
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     successCalls: ({
         id: string;
         type: EntityType.GenericReference;
@@ -2137,6 +2135,8 @@ export declare function getConditionSchema(): z.ZodObject<z.objectUtil.extendSha
         entityType: EntityType.ContinueStatement;
         entityId: string;
     })[];
+    x: number;
+    y: number;
     leftValue: Record<string, any> | {
         type: EntityType.InputMap;
     };
@@ -2262,8 +2262,6 @@ export declare function getConditionSchema(): z.ZodObject<z.objectUtil.extendSha
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     successCalls: ({
         id: string;
         type: EntityType.GenericReference;
@@ -2376,6 +2374,8 @@ export declare function getConditionSchema(): z.ZodObject<z.objectUtil.extendSha
         entityType: EntityType.ContinueStatement;
         entityId: string;
     })[];
+    x: number;
+    y: number;
     leftValue: Record<string, any> | {
         type: EntityType.InputMap;
     };

package/dist/tree/state/continue-statement/continue-statement.d.ts

@@ -1,14 +1,18 @@
 import { ContinueStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IContinueStatement, IContinueStatementGenerationTarget, IContinueStatementReference, IContinueStatementShallowTransfer, IContinueStatementTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
-import { CallerEntityState, EntityState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState } from '../types';
+import { CallerEntityState, EntityState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState } from '../types';
 import { ProjectState } from '../project/project';
 import { LoopState } from '../loop';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class ContinueStatementState extends VersionedState implements IContinueStatement, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
+export declare enum ContinueStatementDependencyField {
+    Parent = "parent"
+}
+export declare class ContinueStatementState extends VersionedState implements IContinueStatement, UserManagedEntityStateTemplate, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
     initialData: IContinueStatement | IContinueStatementTransfer;
     readonly id: EntityId;
     x: number;
@@ -22,9 +26,14 @@ export declare class ContinueStatementState extends VersionedState implements IC
     project: ProjectState;
     errors: EntityError[];
     parent: LoopState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IContinueStatement | IContinueStatementTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -53,43 +62,43 @@ export declare class ContinueStatementState extends VersionedState implements IC
         errors: EntityGenerationError[];
         modifiedData: Partial<IContinueStatementGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, field: string, changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): ContinueStatementState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<ContinueStatementState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<ContinueStatementState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<ContinueStatementState>>;
     hydrateAncestors(): IChangeSet<ContinueStatementState>;
-    afterAllChildrenInitialized(): IChangeSet<ContinueStatementState>;
-    addSelfToProject(): IChangeSet<ContinueStatementState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<ContinueStatementState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<ContinueStatementState>;
     get calledBy(): CallerEntityState[];
-    addSuccessCaller(caller: PassThroughCallableEntityState): ContinueStatementState;
-    addErrorCaller(caller: PassThroughCallableEntityState): ContinueStatementState;
-    addEntryCaller(caller: EntryPointEntityState): ContinueStatementState;
-    removeCaller(caller: CallerEntityState): ContinueStatementState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): ContinueStatementState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): ContinueStatementState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): ContinueStatementState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): ContinueStatementState;
     addOutputDeclaration(output: ReturnDeclarationState): ContinueStatementState;
     removeOutputDeclaration(output: ReturnDeclarationState): ContinueStatementState;
-    setParent(parent: LoopState): ContinueStatementState;
-    initChildren(): ContinueStatementState;
+    setParent(parent: LoopState, changeSet?: ChangeSet | null): ContinueStatementState;
+    initChildren(changeSet?: ChangeSet | null): ContinueStatementState;
     subscribe(): ContinueStatementState;
     unsubscribe(): ContinueStatementState;
-    sync(data: Partial<IContinueStatement | IContinueStatementTransfer | IContinueStatementShallowTransfer>): ContinueStatementState;
+    metaSync(data: Partial<IContinueStatement | IContinueStatementTransfer | IContinueStatementShallowTransfer>, changeSet?: ChangeSet | null): ContinueStatementState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ContinueStatementState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ContinueStatementState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ContinueStatementState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ContinueStatementState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<ContinueStatementState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IContinueStatementShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: EntityState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<EntityState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IContinueStatementTransfer | IContinueStatementReference;

package/dist/tree/state/continue-statement/validation/validation-schema.d.ts

@@ -995,11 +995,11 @@ export declare function getContinueStatementSchema(): z.ZodObject<z.objectUtil.e
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     outputs: (Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     })[];
+    x: number;
+    y: number;
     throws?: Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     } | undefined;
@@ -1106,11 +1106,11 @@ export declare function getContinueStatementSchema(): z.ZodObject<z.objectUtil.e
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     outputs: (Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     })[];
+    x: number;
+    y: number;
     throws?: Record<string, any> | {
         type: EntityType.ReturnDeclaration;
     } | undefined;

package/dist/tree/state/data-type/data-type.d.ts

@@ -1,10 +1,10 @@
 import { EntityId, EntityType, IDataType, IDataTypeTransfer, IDataTypeReference, IDataTypeShallowTransfer, ElementShallowTransfer, IDataTypeGenerationTarget, ElementGenerationTarget, DataTypeParentChildRelation, DataTypeTypesUnion, EntityVersion } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { DefinitionEntityState } from '../definition-entity';
 import { PrimitiveEntityState } from '../primitive-entity';
 import { ProjectState } from '../project/project';
-import { EntityState, IChangeSet } from '../types';
+import { EntityState, UserManagedEntityState } from '../types';
 import { PropertyState } from '../property';
 import { VariableDeclarationState } from '../variable-declaration';
 import { ArgumentDeclarationState } from '../argument-declaration';
@@ -17,9 +17,13 @@ import { EntityError, EntityGenerationError } from '../error';
 import { InputMapState, VariableInputMapState } from '../input-map';
 import { OutputMapState } from '../output-map';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
+export declare enum DataTypeDependencyField {
+    Entity = "entity"
+}
 export type DataTypeStateEntityOption = DefinitionEntityState | PrimitiveEntityState | ActionDescriptorState | BuiltInBaseEntityState | LiteralValueState;
-export declare class DataTypeState extends VersionedState implements IDataType, UserManagedEntityStateFunctionality, BaseState, ChildEntityState {
+export declare class DataTypeState extends VersionedState implements IDataType, UserManagedEntityStateTemplate, BaseState, ChildEntityState {
     initialData: IDataType | IDataTypeTransfer;
     readonly id: EntityId;
     isList: boolean | null;
@@ -36,9 +40,14 @@ export declare class DataTypeState extends VersionedState implements IDataType,
     project: ProjectState;
     errors: EntityError[];
     parent: PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | ValueDescriptorState | InputMapState | OutputMapState | DataTypeState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: IDataType | IDataTypeTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.DataType;
@@ -68,37 +77,37 @@ export declare class DataTypeState extends VersionedState implements IDataType,
         errors: EntityGenerationError[];
         modifiedData: Partial<IDataTypeGenerationTarget>;
     };
+    subscribeDependents(dependencies: {
+        entity: UserManagedEntityState;
+        field: string;
+    }[]): UserManagedEntityState;
+    syncDependents(): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRemoved(dependency: UserManagedEntityState, field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    onDetachedDependencyRestored(_dependency: UserManagedEntityState, field: string, _changeSet: ChangeSet | null): IChangeSet<UserManagedEntityState>;
+    subscribeToDependencies(): UserManagedEntityState;
+    increaseVersion(sharedTimestamp: null | string): UserManagedEntityState;
     captureVersion(): DataTypeState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<DataTypeState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<DataTypeState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<DataTypeState>>;
     hydrateAncestors(): IChangeSet<DataTypeState>;
-    afterAllChildrenInitialized(): IChangeSet<DataTypeState>;
-    addSelfToProject(): IChangeSet<DataTypeState>;
-    setParent(parent: PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | ValueDescriptorState | InputMapState | OutputMapState | DataTypeState): DataTypeState;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<DataTypeState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<DataTypeState>;
+    setParent(parent: PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | ValueDescriptorState | InputMapState | OutputMapState | DataTypeState, changeSet?: ChangeSet | null): DataTypeState;
     removeChildGroup(child: DataTypeState): DataTypeState;
-    initChildren(): DataTypeState;
+    initChildren(changeSet?: ChangeSet | null): DataTypeState;
     subscribe(): DataTypeState;
     unsubscribe(): DataTypeState;
-    sync(data: Partial<IDataType | IDataTypeTransfer | IDataTypeShallowTransfer>): DataTypeState;
+    metaSync(data: Partial<IDataType | IDataTypeTransfer | IDataTypeShallowTransfer>, changeSet?: ChangeSet | null): DataTypeState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DataTypeState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DataTypeState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DataTypeState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DataTypeState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DataTypeState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IDataTypeShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: DataTypeState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<DataTypeState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IDataTypeTransfer | IDataTypeReference;
@@ -123,6 +132,6 @@ export declare class DataTypeState extends VersionedState implements IDataType,
     setEntity(entity: DefinitionEntityState | PrimitiveEntityState | ActionDescriptorState | BuiltInBaseEntityState | LiteralValueState | null): DataTypeState;
     isObject(): boolean;
     hasStrictObjectStructure(): boolean;
-    inferFromInputs(inputs: VariableInputMapState[]): DataTypeState;
+    inferFromInputs(inputs: VariableInputMapState[], changeSet?: ChangeSet | null): IChangeSet<DataTypeState>;
 }
 export type DataTypePayloadUnion = DataTypeState | DataTypeTypesUnion;