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

package/dist/tree/state/definition-entity/definition-entity.d.ts

@@ -1,18 +1,23 @@
 import { DefinitionEntityTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IDefinitionEntity, IDefinitionEntityGenerationTarget, IDefinitionEntityReference, IDefinitionEntityShallowTransfer, IDefinitionEntityTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { PropertyState } from '../property';
 import { FunctionDeclarationState } from '../function-declaration';
 import { ProjectState } from '../project/project';
 import { BuiltInBaseEntityState } from '../built-in-base-entity';
 import { ActionDescriptorState } from '../action-descriptor';
 import { EntityError, EntityGenerationError } from '../error';
-import { EntityState, IChangeSet } from '../types';
+import { EntityState, UserManagedEntityState } from '../types';
 import { DataTypeState } from '../data-type';
 import { VariableInputMapState } from '../input-map';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class DefinitionEntityState extends VersionedState implements BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, IDefinitionEntity, ChildEntityState {
+export declare enum DefinitionEntityDependencyField {
+    Extends = "extends",
+    Implements = "implements"
+}
+export declare class DefinitionEntityState extends VersionedState implements BaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, IDefinitionEntity, ChildEntityState {
     initialData: IDefinitionEntity | IDefinitionEntityTransfer;
     readonly id: EntityId;
     name: string;
@@ -30,9 +35,14 @@ export declare class DefinitionEntityState extends VersionedState implements Bas
     project: ProjectState;
     errors: EntityError[];
     parent: ProjectState | DataTypeState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestedProperties: PropertyState[];
     suggestedMethods: FunctionDeclarationState[];
     constructor(initialData: IDefinitionEntity | IDefinitionEntityTransfer, parentProjectState: ProjectState);
@@ -67,13 +77,22 @@ export declare class DefinitionEntityState extends VersionedState implements Bas
         errors: EntityGenerationError[];
         modifiedData: Partial<IDefinitionEntityGenerationTarget>;
     };
+    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(): DefinitionEntityState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<DefinitionEntityState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<DefinitionEntityState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<DefinitionEntityState>>;
     hydrateAncestors(): IChangeSet<DefinitionEntityState>;
-    afterAllChildrenInitialized(): IChangeSet<DefinitionEntityState>;
-    addSelfToProject(): IChangeSet<DefinitionEntityState>;
-    setParent(parent: ProjectState | DataTypeState): DefinitionEntityState;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    setParent(parent: ProjectState | DataTypeState, changeSet?: ChangeSet | null): DefinitionEntityState;
     addExtension(entity: DefinitionEntityState | BuiltInBaseEntityState): DefinitionEntityState;
     removeExtension(entity: DefinitionEntityState | BuiltInBaseEntityState): DefinitionEntityState;
     addImplementation(entity: DefinitionEntityState | BuiltInBaseEntityState): DefinitionEntityState;
@@ -88,32 +107,23 @@ export declare class DefinitionEntityState extends VersionedState implements Bas
     removeSuggestedMethod(method: FunctionDeclarationState): DefinitionEntityState;
     addAbstractMethod(method: ActionDescriptorState): DefinitionEntityState;
     removeAbstractMethod(method: ActionDescriptorState): DefinitionEntityState;
-    initChildren(): DefinitionEntityState;
-    syncImplementationProperties(): DefinitionEntityState;
-    addExtendedProperties(): DefinitionEntityState;
+    initChildren(changeSet?: ChangeSet | null): DefinitionEntityState;
+    syncImplementationProperties(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
+    addExtendedProperties(changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
     addSuggestions(): DefinitionEntityState;
     subscribe(): DefinitionEntityState;
     unsubscribe(): DefinitionEntityState;
-    sync(data: Partial<IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer>): DefinitionEntityState;
+    metaSync(data: Partial<IDefinitionEntity | IDefinitionEntityTransfer | IDefinitionEntityShallowTransfer>, changeSet?: ChangeSet | null): DefinitionEntityState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<DefinitionEntityState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IDefinitionEntityShallowTransfer | null>;
-    remove({ ignoreUpstream: _, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: DefinitionEntityState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IDefinitionEntityTransfer | IDefinitionEntityReference;
@@ -133,7 +143,7 @@ export declare class DefinitionEntityState extends VersionedState implements Bas
     getShallowErrors(): EntityError[];
     clone(parent?: ProjectState | DataTypeState | null, newId?: string | null, subscribe?: boolean): DefinitionEntityState;
     getFunctionDeclaration(id: EntityId): FunctionDeclarationState | undefined;
-    implement(newEntityName: string, newId?: string): {
+    implement(newEntityName: string, changeSet?: ChangeSet | null, newId?: string): {
         errors: [];
         implemented: DefinitionEntityState;
         entitiesChanges: {
@@ -151,6 +161,6 @@ export declare class DefinitionEntityState extends VersionedState implements Bas
         };
     };
     getAllInteractiveMethods(): FunctionDeclarationState[];
-    inferFromInputs(inputs: VariableInputMapState[]): DefinitionEntityState;
+    inferFromInputs(inputs: VariableInputMapState[], changeSet?: ChangeSet | null): IChangeSet<DefinitionEntityState>;
 }
 export type DefinitionEntityPayloadUnion = DefinitionEntityState | DefinitionEntityTypesUnion;

package/dist/tree/state/definition-entity/validation/validation-schema.d.ts

@@ -63,20 +63,20 @@ export declare function getDefinitionEntityMetaSchema(): z.ZodObject<z.objectUti
     name: string;
     description: string | null;
     version: number;
-    x: number;
-    y: number;
     static: boolean;
     abstract: boolean;
+    x: number;
+    y: number;
 }, {
     id: string;
     type: EntityType.DefinitionEntity;
     name: string;
     description: string | null;
     version: number;
-    x: number;
-    y: number;
     static: boolean;
     abstract: boolean;
+    x: number;
+    y: number;
 }>;
 export declare function getDefinitionEntityGenerationTargetSchema(): z.ZodObject<z.objectUtil.extendShape<{
     id: z.ZodString;
@@ -419,8 +419,6 @@ export declare function getDefinitionEntitySchema(): z.ZodObject<z.objectUtil.ex
     methods: (Record<string, any> | {
         type: EntityType.FunctionDeclaration;
     })[];
-    x: number;
-    y: number;
     properties: (Record<string, any> | {
         type: EntityType.Property;
     })[];
@@ -429,6 +427,8 @@ export declare function getDefinitionEntitySchema(): z.ZodObject<z.objectUtil.ex
     })[];
     static: boolean;
     abstract: boolean;
+    x: number;
+    y: number;
 }, {
     id: string;
     type: EntityType.DefinitionEntity;
@@ -459,8 +459,6 @@ export declare function getDefinitionEntitySchema(): z.ZodObject<z.objectUtil.ex
     methods: (Record<string, any> | {
         type: EntityType.FunctionDeclaration;
     })[];
-    x: number;
-    y: number;
     properties: (Record<string, any> | {
         type: EntityType.Property;
     })[];
@@ -469,4 +467,6 @@ export declare function getDefinitionEntitySchema(): z.ZodObject<z.objectUtil.ex
     })[];
     static: boolean;
     abstract: boolean;
+    x: number;
+    y: number;
 }>;

package/dist/tree/state/function-call/function-call.d.ts

@@ -1,15 +1,20 @@
 import { EntityId, EntityType, IFunctionCall, IFunctionCallTransfer, IFunctionCallReference, IFunctionCallShallowTransfer, ElementShallowTransfer, IFunctionCallGenerationTarget, ElementGenerationTarget, FunctionCallTypesUnion, 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, ValueReadingEntityState } from '../types';
+import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateTemplate } from '../base';
+import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, PassThroughCallableEntityState, UserManagedEntityState, ValueReadingEntityState } from '../types';
 import { FunctionDeclarationState } from '../function-declaration';
 import { ActionInputMapState } from '../input-map';
 import { ActionOutputMapState } from '../output-map';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class FunctionCallState extends VersionedState implements IFunctionCall, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare enum FunctionCallDependencyField {
+    Parent = "parent",
+    Declaration = "declaration"
+}
+export declare class FunctionCallState extends VersionedState implements IFunctionCall, BaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: IFunctionCall | IFunctionCallTransfer;
     readonly id: EntityId;
     x: number;
@@ -28,9 +33,14 @@ export declare class FunctionCallState extends VersionedState implements IFuncti
     parent: EntityWithLogicScopeState | ProjectState;
     errors: EntityError[];
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: IFunctionCall | IFunctionCallTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.FunctionCall;
@@ -58,12 +68,21 @@ export declare class FunctionCallState extends VersionedState implements IFuncti
         errors: EntityGenerationError[];
         modifiedData: Partial<IFunctionCallGenerationTarget>;
     };
+    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(): FunctionCallState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<FunctionCallState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<FunctionCallState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<FunctionCallState>>;
     hydrateAncestors(): IChangeSet<FunctionCallState>;
-    afterAllChildrenInitialized(): IChangeSet<FunctionCallState>;
-    addSelfToProject(): IChangeSet<FunctionCallState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
     get calledBy(): CallerEntityState[];
     removeInput(input: ActionInputMapState): FunctionCallState;
     addInput(input: ActionInputMapState): FunctionCallState;
@@ -71,38 +90,29 @@ export declare class FunctionCallState extends VersionedState implements IFuncti
     removeOutput(output: ActionOutputMapState): FunctionCallState;
     addValueReader(entity: ValueReadingEntityState): FunctionCallState;
     removeValueReader(valueReader: ValueReadingEntityState): FunctionCallState;
-    addSuccessCaller(caller: PassThroughCallableEntityState): FunctionCallState;
-    addErrorCaller(caller: PassThroughCallableEntityState): FunctionCallState;
-    addEntryCaller(caller: EntryPointEntityState): FunctionCallState;
+    addSuccessCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): FunctionCallState;
+    addErrorCaller(caller: PassThroughCallableEntityState, changeSet?: ChangeSet | null): FunctionCallState;
+    addEntryCaller(caller: EntryPointEntityState, changeSet?: ChangeSet | null): FunctionCallState;
     addErrorCall(call: CallableEntityState): FunctionCallState;
     addSuccessCall(call: CallableEntityState): FunctionCallState;
     removeCall(call: CallableEntityState): FunctionCallState;
-    removeCaller(caller: CallerEntityState): FunctionCallState;
-    setParent(parent: EntityWithLogicScopeState | ProjectState): FunctionCallState;
+    removeCaller(caller: CallerEntityState, changeSet?: ChangeSet | null): FunctionCallState;
+    setParent(parent: EntityWithLogicScopeState | ProjectState, changeSet?: ChangeSet | null): FunctionCallState;
     setDeclaration(declaration: FunctionDeclarationState): FunctionCallState;
-    initChildren(): FunctionCallState;
+    initChildren(changeSet?: ChangeSet | null): FunctionCallState;
     subscribe(): FunctionCallState;
     unsubscribe(): FunctionCallState;
-    sync(data: Partial<IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer>): FunctionCallState;
+    metaSync(data: Partial<IFunctionCall | IFunctionCallTransfer | IFunctionCallShallowTransfer>, changeSet?: ChangeSet | null): FunctionCallState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionCallState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IFunctionCallShallowTransfer | null>;
-    remove({ ignoreUpstream, seenEntities, }?: {
+    remove({ ignoreUpstream }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: FunctionCallState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IFunctionCallTransfer | IFunctionCallReference;
@@ -121,9 +131,9 @@ export declare class FunctionCallState extends VersionedState implements IFuncti
     getErrors(): EntityError[];
     getShallowErrors(): EntityError[];
     clone(parent?: EntryPointEntityState | ProjectState | null, newId?: string | null, subscribe?: boolean): FunctionCallState;
-    removeUnrecognizedInputs(): IChangeSet<FunctionCallState>;
-    removeUnrecognizedOutputs(): IChangeSet<FunctionCallState>;
-    syncMissingFixedInputs(): IChangeSet<FunctionCallState>;
-    syncMissingFixedOutputs(): IChangeSet<FunctionCallState>;
+    removeUnrecognizedInputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    removeUnrecognizedOutputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    syncMissingFixedInputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
+    syncMissingFixedOutputs(changeSet?: ChangeSet | null): IChangeSet<FunctionCallState>;
 }
 export type FunctionCallPayloadUnion = FunctionCallState | FunctionCallTypesUnion;

package/dist/tree/state/function-call/validation/validation-schema.d.ts

@@ -2129,8 +2129,6 @@ export declare function getFunctionCallSchema(): z.ZodObject<z.objectUtil.extend
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2258,6 +2256,8 @@ export declare function getFunctionCallSchema(): z.ZodObject<z.objectUtil.extend
     } | {
         type: EntityType.VariableInstance;
     })[];
+    x: number;
+    y: number;
     error?: Record<string, any> | {
         type: EntityType.OutputMap;
     } | undefined;
@@ -2382,8 +2382,6 @@ export declare function getFunctionCallSchema(): z.ZodObject<z.objectUtil.extend
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     inputs: (Record<string, any> | {
         type: EntityType.InputMap;
     })[];
@@ -2511,6 +2509,8 @@ export declare function getFunctionCallSchema(): z.ZodObject<z.objectUtil.extend
     } | {
         type: EntityType.VariableInstance;
     })[];
+    x: number;
+    y: number;
     error?: Record<string, any> | {
         type: EntityType.OutputMap;
     } | undefined;

package/dist/tree/state/function-declaration/function-declaration.d.ts

@@ -1,9 +1,9 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, FunctionDeclarationTypesUnion, IFunctionCallTransfer, IFunctionDeclaration, IFunctionDeclarationGenerationTarget, IFunctionDeclarationReference, IFunctionDeclarationShallowTransfer, IFunctionDeclarationTransfer, IInternalCallTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { ArgumentDeclarationState } from '../argument-declaration';
 import { ReturnStatementState } from '../return-statement';
-import { CallableEntityState, CanvasEntityState, EntityState, EntityWithLogicScopeState, IChangeSet, VariableState } from '../types';
+import { CallableEntityState, CanvasEntityState, EntityState, EntityWithLogicScopeState, UserManagedEntityState, VariableState } from '../types';
 import { ProjectState } from '../project/project';
 import { InstalledProjectState } from '../installed-project';
 import { DefinitionEntityState } from '../definition-entity';
@@ -17,8 +17,12 @@ import { FunctionCallState } from '../function-call';
 import { InternalCallState } from '../internal-call';
 import { ReturnDeclarationState } from '../return-declaration';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class FunctionDeclarationState extends VersionedState implements IFunctionDeclaration, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
+export declare enum FunctionDeclarationDependencyField {
+    Implements = "implements"
+}
+export declare class FunctionDeclarationState extends VersionedState implements IFunctionDeclaration, BaseState, UserManagedEntityStateTemplate, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
     initialData: IFunctionDeclarationTransfer | IFunctionDeclaration;
     readonly id: EntityId;
     name: string;
@@ -31,15 +35,19 @@ export declare class FunctionDeclarationState extends VersionedState implements
     readonly type: EntityType.FunctionDeclaration;
     implements: ActionDescriptorState | null;
     inputs: ArgumentDeclarationState[];
-    returnStatements: ReturnStatementState[];
     calls: CallableEntityState[];
     parent: ProjectState | InstalledProjectState | DefinitionEntityState | LoopState | BuiltInBaseEntityState | PrimitiveEntityState;
     detachedChildren: CanvasEntityState[];
     errors: EntityError[];
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     suggestion: boolean;
     constructor(initialData: IFunctionDeclaration | IFunctionDeclarationTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
@@ -64,47 +72,48 @@ export declare class FunctionDeclarationState extends VersionedState implements
         errors: EntityGenerationError[];
         modifiedData: IFunctionDeclarationGenerationTarget;
     };
+    get returnStatements(): ReturnStatementState[];
     validateGeneratedUpdate(data: Partial<IFunctionDeclarationGenerationTarget>): {
         errors: EntityGenerationError[];
         modifiedData: Partial<IFunctionDeclarationGenerationTarget>;
     };
+    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(): FunctionDeclarationState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<FunctionDeclarationState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<FunctionDeclarationState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<FunctionDeclarationState>>;
     hydrateAncestors(): IChangeSet<FunctionDeclarationState>;
-    afterAllChildrenInitialized(): IChangeSet<FunctionDeclarationState>;
-    addSelfToProject(): IChangeSet<FunctionDeclarationState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
     replaceDetachedChild(existingChild: CanvasEntityState, newChild: CanvasEntityState): FunctionDeclarationState;
     subscribeDetachedChild(child: CanvasEntityState): FunctionDeclarationState;
-    addInputDeclaration(input: ArgumentDeclarationState): FunctionDeclarationState;
+    addInputDeclaration(input: ArgumentDeclarationState, changeSet?: ChangeSet | null): FunctionDeclarationState;
     removeInputDeclaration(input: ArgumentDeclarationState): FunctionDeclarationState;
-    setParent(parent: ProjectState | InstalledProjectState | DefinitionEntityState | LoopState | BuiltInBaseEntityState | PrimitiveEntityState): FunctionDeclarationState;
-    setImplements(implementsEntity: ActionDescriptorState): FunctionDeclarationState;
+    setParent(parent: ProjectState | InstalledProjectState | DefinitionEntityState | LoopState | BuiltInBaseEntityState | PrimitiveEntityState, changeSet?: ChangeSet | null): FunctionDeclarationState;
+    setImplements(implementsEntity: ActionDescriptorState | null, changeSet?: ChangeSet | null): FunctionDeclarationState;
     addCall(entity: CallableEntityState): FunctionDeclarationState;
     removeCall(entity: CallableEntityState): FunctionDeclarationState;
-    initChildren(): FunctionDeclarationState;
+    initChildren(changeSet?: ChangeSet | null): FunctionDeclarationState;
     subscribe(): FunctionDeclarationState;
     unsubscribe(): FunctionDeclarationState;
-    sync(data: Partial<IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer>): FunctionDeclarationState;
+    metaSync(data: Partial<IFunctionDeclaration | IFunctionDeclarationTransfer | IFunctionDeclarationShallowTransfer>, changeSet?: ChangeSet | null): FunctionDeclarationState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<FunctionDeclarationState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IFunctionDeclarationShallowTransfer | null>;
-    remove({ ignoreUpstream: _, seenEntities, }?: {
+    remove({ ignoreUpstream: _ }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: FunctionDeclarationState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<FunctionDeclarationState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IFunctionDeclarationTransfer | IFunctionDeclarationReference;

package/dist/tree/state/function-declaration/validation/validation-schema.d.ts

@@ -56,18 +56,18 @@ export declare function getFunctionDeclarationMetaSchema(): z.ZodObject<z.object
     name: string;
     description: string | null;
     version: number;
+    index: number | null;
     x: number;
     y: number;
-    index: number | null;
 }, {
     id: string;
     type: EntityType.FunctionDeclaration;
     name: string;
     description: string | null;
     version: number;
+    index: number | null;
     x: number;
     y: number;
-    index: number | null;
 }>;
 export declare function getFunctionDeclarationGenerationTargetSchema(): z.ZodObject<{
     id: z.ZodString;
@@ -444,12 +444,12 @@ export declare function getFunctionDeclarationSchema(): z.ZodObject<z.objectUtil
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     index: number | null;
     inputs: (Record<string, any> | {
         type: EntityType.ArgumentDeclaration;
     })[];
+    x: number;
+    y: number;
     returnStatements: (Record<string, any> | {
         type: EntityType.ReturnStatement;
     })[];
@@ -493,12 +493,12 @@ export declare function getFunctionDeclarationSchema(): z.ZodObject<z.objectUtil
         entityId: string;
     };
     version: number;
-    x: number;
-    y: number;
     index: number | null;
     inputs: (Record<string, any> | {
         type: EntityType.ArgumentDeclaration;
     })[];
+    x: number;
+    y: number;
     returnStatements: (Record<string, any> | {
         type: EntityType.ReturnStatement;
     })[];

package/dist/tree/state/global-event/global-event.d.ts

@@ -1,8 +1,8 @@
 import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, GlobalEventNames, GlobalEventTypesUnion, IGlobalEvent, IGlobalEventGenerationTarget, IGlobalEventReference, IGlobalEventShallowTransfer, IGlobalEventTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
-import { BaseCanvasDraggableState, BaseState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
+import { BaseCanvasDraggableState, BaseState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateTemplate } from '../base';
 import { ArgumentDeclarationState } from '../argument-declaration';
-import { CallableEntityState, CanvasEntityState, EntityState, IChangeSet } from '../types';
+import { CallableEntityState, CanvasEntityState, EntityState, UserManagedEntityState } from '../types';
 import { ReturnStatementState } from '../return-statement';
 import { ProjectState } from '../project/project';
 import { InstalledProjectState } from '../installed-project';
@@ -10,8 +10,9 @@ import { VariableInstanceState } from '../variable-instance';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { ActionDescriptorState } from '../action-descriptor';
 import { VersionedState } from '../version';
+import { ChangeSet, IChangeSet } from '../change-set';
 
-export declare class GlobalEventState extends VersionedState implements IGlobalEvent, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
+export declare class GlobalEventState extends VersionedState implements IGlobalEvent, UserManagedEntityStateTemplate, BaseState, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
     initialData: IGlobalEvent | IGlobalEventTransfer;
     readonly id: EntityId;
     name: GlobalEventNames;
@@ -22,15 +23,19 @@ export declare class GlobalEventState extends VersionedState implements IGlobalE
     readonly type: EntityType.GlobalEvent;
     inputs: ArgumentDeclarationState[];
     calls: CallableEntityState[];
-    returnStatements: ReturnStatementState[];
     parent: ProjectState | InstalledProjectState;
     implements: ActionDescriptorState;
     detachedChildren: CanvasEntityState[];
     errors: EntityError[];
     project: ProjectState;
+    detachedDependents: Record<EntityId, {
+        entity: UserManagedEntityState;
+        field: string;
+    }>;
     knownVersions: Map<string, EntityState> | null;
     activeVersion: boolean;
     initialized: boolean;
+    startedInitialization: boolean;
     constructor(initialData: IGlobalEvent | IGlobalEventTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
     static type: EntityType.GlobalEvent;
@@ -54,47 +59,48 @@ export declare class GlobalEventState extends VersionedState implements IGlobalE
         errors: EntityGenerationError[];
         modifiedData: IGlobalEventGenerationTarget;
     };
+    get returnStatements(): ReturnStatementState[];
     validateGeneratedUpdate(data: Partial<IGlobalEventGenerationTarget>): {
         errors: EntityGenerationError[];
         modifiedData: Partial<IGlobalEventGenerationTarget>;
     };
+    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(): GlobalEventState;
-    recursiveCaptureUpstreamVersions(): IChangeSet<GlobalEventState>;
+    recursiveCaptureUpstreamVersions(sharedTimestamp: null | string): IChangeSet<GlobalEventState>;
     restoreVersion(versionId: EntityVersion): Promise<IChangeSet<GlobalEventState>>;
     hydrateAncestors(): IChangeSet<GlobalEventState>;
-    afterAllChildrenInitialized(): IChangeSet<GlobalEventState>;
-    addSelfToProject(): IChangeSet<GlobalEventState>;
+    afterAllChildrenInitialized(changeSet?: ChangeSet | null): IChangeSet<GlobalEventState>;
+    addSelfToProject(changeSet?: ChangeSet | null): IChangeSet<GlobalEventState>;
     replaceDetachedChild(existingChild: CanvasEntityState, newChild: CanvasEntityState): GlobalEventState;
     subscribeDetachedChild(child: CanvasEntityState): GlobalEventState;
-    setParent(parent: ProjectState | InstalledProjectState): GlobalEventState;
-    setImplements(implementsEntity: ActionDescriptorState): GlobalEventState;
+    setParent(parent: ProjectState | InstalledProjectState, changeSet?: ChangeSet | null): GlobalEventState;
+    setImplements(implementsEntity: ActionDescriptorState, changeSet?: ChangeSet | null): GlobalEventState;
     addCall(entity: CallableEntityState): GlobalEventState;
     removeCall(entity: CallableEntityState): GlobalEventState;
-    addInputDeclaration(entity: ArgumentDeclarationState): GlobalEventState;
+    addInputDeclaration(input: ArgumentDeclarationState, changeSet?: ChangeSet | null): GlobalEventState;
     removeInputDeclaration(input: ArgumentDeclarationState): GlobalEventState;
-    initChildren(): GlobalEventState;
+    initChildren(changeSet?: ChangeSet | null): GlobalEventState;
     subscribe(): GlobalEventState;
     unsubscribe(): GlobalEventState;
-    sync(data: Partial<IGlobalEvent | IGlobalEventTransfer | IGlobalEventShallowTransfer>): GlobalEventState;
+    metaSync(data: Partial<IGlobalEvent | IGlobalEventTransfer | IGlobalEventShallowTransfer>, changeSet?: ChangeSet | null): GlobalEventState;
     APILoad(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<GlobalEventState>;
     APICreate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<GlobalEventState>;
     APIUpdate(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<GlobalEventState>;
     APIDelete(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<GlobalEventState>;
     APIClone(_?: IEntityPersistanceOptions, ...otherArgs: any[]): Promise<GlobalEventState>;
     APILoadVersion(_: IEntityPersistanceOptions | undefined, versionIdOrBeforeEqualDate: EntityVersion | Date, ...otherArgs: any[]): Promise<IGlobalEventShallowTransfer | null>;
-    remove({ ignoreUpstream: _, seenEntities, }?: {
+    remove({ ignoreUpstream: _ }?: {
         ignoreUpstream: boolean;
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        removed: EntityState[];
-    };
-    restore({ seenEntities }?: {
-        seenEntities: Set<string>;
-    }): {
-        affected: EntityState[];
-        self: GlobalEventState;
-    };
+    }, changeSet?: ChangeSet | null): IChangeSet;
+    restore({}?: {}, changeSet?: ChangeSet | null): IChangeSet<GlobalEventState>;
     toFlat(seenEntities?: Set<EntityId>): EntityState[];
     toFlatIds(seenEntities?: Set<EntityId>): EntityId[];
     toJSON(seenEntities?: Set<EntityId>): IGlobalEventTransfer | IGlobalEventReference;