@elyx-code/project-logic-tree 0.0.6140 → 0.0.6142

package/dist/tree/built-in/operations/function-execution/parallel.d.ts

@@ -5,7 +5,7 @@ export declare class ParallelExecutionOperation extends ActionDescriptorState {
     readonly id = ExecutionOperations.Parallel;
     readonly name = ExecutionOperations.Parallel;
     readonly description = "Execute a list of actions one after the other";
-    readonly version = 1;
+    readonly version = "1";
     readonly autoexecutable = true;
     initialData: IActionDescriptor | IActionDescriptorTransfer;
     readonly type: EntityType.ActionDescriptor;

package/dist/tree/built-in/operations/function-execution/sequential.d.ts

@@ -6,7 +6,7 @@ export declare class SequentialExecutionOperation extends ActionDescriptorState
     readonly id = ExecutionOperations.Sequential;
     readonly name = ExecutionOperations.Sequential;
     readonly description = "Execute a list of actions one after the other";
-    readonly version = 1;
+    readonly version = "1";
     readonly autoexecutable = true;
     initialData: IActionDescriptor | IActionDescriptorTransfer;
     readonly type: EntityType.ActionDescriptor;

package/dist/tree/built-in/operations/function-execution/wait.d.ts

@@ -5,7 +5,7 @@ export declare class WaitOperation extends ActionDescriptorState {
     readonly id: string;
     readonly name: string;
     readonly description: string | null;
-    readonly version: number;
+    readonly version: string;
     readonly autoexecutable = false;
     initialData: IActionDescriptor | IActionDescriptorTransfer;
     readonly type: EntityType.ActionDescriptor;

package/dist/tree/state/action-descriptor/action-descriptor.d.ts

@@ -1,4 +1,4 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IActionDescriptor, IActionDescriptorGenerationTarget, IActionDescriptorReference, IActionDescriptorShallowTransfer, IActionDescriptorTransfer, IFunctionDeclarationTransfer, ActionDescriptorTypesUnion } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IActionDescriptor, IActionDescriptorGenerationTarget, IActionDescriptorReference, IActionDescriptorShallowTransfer, IActionDescriptorTransfer, IFunctionDeclarationTransfer, ActionDescriptorTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseState, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { ProjectState } from '../project/project';
@@ -14,6 +14,7 @@ import { OperationState } from '../operation';
 import { ConditionState } from '../condition';
 import { InputMapState } from '../input-map';
 import { OutputMapState } from '../output-map';
+import { VersionedState } from '../version';
 
 export declare enum ExecutionTerminationType {
     Success = "success",
@@ -27,10 +28,9 @@ export interface IPrimitiveExecutionResult {
     results: any[];
     error: any | null;
 }
-export declare class ActionDescriptorState implements IActionDescriptor, UserManagedEntityStateFunctionality, BaseState, ChildEntityState {
+export declare class ActionDescriptorState extends VersionedState implements IActionDescriptor, UserManagedEntityStateFunctionality, BaseState, ChildEntityState {
     initialData: IActionDescriptorTransfer | IActionDescriptor;
     readonly id: EntityId;
-    version: EntityVersion;
     name: string;
     description: string | null;
     readonly type: EntityType.ActionDescriptor;
@@ -43,8 +43,11 @@ export declare class ActionDescriptorState implements IActionDescriptor, UserMan
     project: ProjectState;
     initialized: boolean;
     autoexecutable: boolean;
-    constructor(initialFunctionData: IActionDescriptor | IActionDescriptorTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IActionDescriptor | IActionDescriptorTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.ActionDescriptor;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IArgumentDeclaration, IArgumentDeclarationGenerationTarget, IArgumentDeclarationReference, IArgumentDeclarationShallowTransfer, IArgumentDeclarationTransfer, ArgumentDeclarationTypesUnion } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IArgumentDeclaration, IArgumentDeclarationGenerationTarget, IArgumentDeclarationReference, IArgumentDeclarationShallowTransfer, IArgumentDeclarationTransfer, ArgumentDeclarationTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseState, ChildEntityState, EntityWithValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, ValueWritingEntityClass, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { EntityState, EntryPointEntityState, IChangeSet, ValueReadingEntityState } from '../types';
@@ -7,11 +7,11 @@ import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { LiteralValueState } from '../literal-value';
 import { ValueDescriptorState } from '../value-descriptor';
+import { VersionedState } from '../version';
 
-export declare class ArgumentDeclarationState implements IArgumentDeclaration, UserManagedEntityStateFunctionality, ValueWritingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
+export declare class ArgumentDeclarationState extends VersionedState implements IArgumentDeclaration, UserManagedEntityStateFunctionality, ValueWritingEntityClass, BaseState, ChildEntityState, EntityWithValueClass {
     initialData: IArgumentDeclaration | IArgumentDeclarationTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     name: string;
     description: string | null;
     index: number;
@@ -27,8 +27,11 @@ export declare class ArgumentDeclarationState implements IArgumentDeclaration, U
     parent: EntryPointEntityState;
     initialized: boolean;
     suggestion: boolean;
-    constructor(initialArgumentDeclarationData: IArgumentDeclaration | IArgumentDeclarationTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IArgumentDeclaration | IArgumentDeclarationTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.ArgumentDeclaration;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -80,6 +80,10 @@ export declare abstract class BaseState extends SharedStateFunctionality impleme
     abstract id: EntityId;
     abstract version: EntityVersion;
     abstract type: EntityType;
+    abstract previousVersion: string | null;
+    abstract createdAt: string | Date;
+    abstract deleted: boolean;
+    abstract author: string;
 }
 export declare abstract class BaseCanvasDraggableState {
     abstract x: number;

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

@@ -1,4 +1,4 @@
-import { BreakStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IBreakStatement, IBreakStatementGenerationTarget, IBreakStatementReference, IBreakStatementShallowTransfer, IBreakStatementTransfer } from '../../../definitions';
+import { BreakStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IBreakStatement, IBreakStatementGenerationTarget, IBreakStatementReference, IBreakStatementShallowTransfer, IBreakStatementTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
@@ -6,11 +6,11 @@ import { CallerEntityState, EntityState, EntryPointEntityState, IChangeSet, Pass
 import { ProjectState } from '../project/project';
 import { LoopState } from '../loop';
 import { EntityError, EntityGenerationError } from '../../state/error';
+import { VersionedState } from '../version';
 
-export declare class BreakStatementState implements IBreakStatement, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
+export declare class BreakStatementState extends VersionedState implements IBreakStatement, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
     initialData: IBreakStatement | IBreakStatementTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     x: number;
     y: number;
     readonly type: EntityType.BreakStatement;
@@ -24,8 +24,11 @@ export declare class BreakStatementState implements IBreakStatement, UserManaged
     parent: LoopState;
     initialized: boolean;
     suggestion: boolean;
-    constructor(initialBreakStatementData: IBreakStatement | IBreakStatementTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IBreakStatement | IBreakStatementTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.BreakStatement;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

package/dist/tree/state/built-in-base-entity/built-in-base-entity.d.ts

@@ -9,8 +9,9 @@ import { ActionDescriptorState } from '../action-descriptor';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { EntityState } from '../types';
 import { DefinitionEntityState } from '../definition-entity';
+import { VersionedState } from '../version';
 
-export declare class BuiltInBaseEntityState implements BaseState, IBuiltInBaseEntity {
+export declare class BuiltInBaseEntityState extends VersionedState implements BaseState, IBuiltInBaseEntity {
     initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer;
     readonly id: BaseEntityNames;
     readonly version: EntityVersion;
@@ -26,7 +27,7 @@ export declare class BuiltInBaseEntityState implements BaseState, IBuiltInBaseEn
     readonly interactive: boolean;
     errors: EntityError[];
     project: ProjectState;
-    constructor(initialEntityData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IBuiltInBaseEntity | IBuiltInBaseEntityTransfer, parentProjectState: ProjectState);
     static repository: IReadOnlyEntityPersistanceRepository;
     get allBasePropertiesFromExtendedAndImplementedEntities(): PropertyState[];
     get extendedPropertiesFromOriginalParents(): PropertyState[];

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

@@ -1,4 +1,4 @@
-import { EntityId, EntityType, EntityVersion, ICondition, IConditionTransfer, IConditionReference, IConditionShallowTransfer, ElementShallowTransfer, IConditionGenerationTarget, ElementGenerationTarget, ConditionTypesUnion } from '../../../definitions';
+import { EntityId, EntityType, ICondition, IConditionTransfer, IConditionReference, IConditionShallowTransfer, ElementShallowTransfer, IConditionGenerationTarget, ElementGenerationTarget, ConditionTypesUnion } 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';
@@ -7,11 +7,11 @@ 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';
 
-export declare class ConditionState implements ICondition, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare class ConditionState extends VersionedState implements ICondition, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: ICondition | IConditionTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     x: number;
     y: number;
     readonly type: EntityType.Condition;
@@ -26,8 +26,11 @@ export declare class ConditionState implements ICondition, UserManagedEntityStat
     errors: EntityError[];
     parent: EntityWithLogicScopeState | ProjectState;
     initialized: boolean;
-    constructor(initialConditionData: ICondition | IConditionTransfer, parentProjectState: ProjectState);
+    constructor(initialData: ICondition | IConditionTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.Condition;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { ContinueStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IContinueStatement, IContinueStatementGenerationTarget, IContinueStatementReference, IContinueStatementShallowTransfer, IContinueStatementTransfer } from '../../../definitions';
+import { ContinueStatementTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IContinueStatement, IContinueStatementGenerationTarget, IContinueStatementReference, IContinueStatementShallowTransfer, IContinueStatementTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
 import { ReturnDeclarationState } from '../return-declaration';
@@ -6,11 +6,11 @@ import { CallerEntityState, EntityState, EntryPointEntityState, IChangeSet, Pass
 import { ProjectState } from '../project/project';
 import { LoopState } from '../loop';
 import { EntityError, EntityGenerationError } from '../../state/error';
+import { VersionedState } from '../version';
 
-export declare class ContinueStatementState implements IContinueStatement, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
+export declare class ContinueStatementState extends VersionedState implements IContinueStatement, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState {
     initialData: IContinueStatement | IContinueStatementTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     x: number;
     y: number;
     readonly type: EntityType.ContinueStatement;
@@ -24,8 +24,11 @@ export declare class ContinueStatementState implements IContinueStatement, UserM
     parent: LoopState;
     initialized: boolean;
     suggestion: boolean;
-    constructor(initialContinueStatementData: IContinueStatement | IContinueStatementTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IContinueStatement | IContinueStatementTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.ContinueStatement;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { EntityId, EntityType, EntityVersion, IDataType, IDataTypeTransfer, IDataTypeReference, IDataTypeShallowTransfer, ElementShallowTransfer, IDataTypeGenerationTarget, ElementGenerationTarget, DataTypeParentChildRelation, DataTypeTypesUnion } from '../../../definitions';
+import { EntityId, EntityType, IDataType, IDataTypeTransfer, IDataTypeReference, IDataTypeShallowTransfer, ElementShallowTransfer, IDataTypeGenerationTarget, ElementGenerationTarget, DataTypeParentChildRelation, DataTypeTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
 import { DefinitionEntityState } from '../definition-entity';
@@ -16,12 +16,12 @@ import { LiteralValueState } from '../literal-value/literal-value';
 import { EntityError, EntityGenerationError } from '../error';
 import { InputMapState, VariableInputMapState } from '../input-map';
 import { OutputMapState } from '../output-map';
+import { VersionedState } from '../version';
 
 export type DataTypeStateEntityOption = DefinitionEntityState | PrimitiveEntityState | ActionDescriptorState | BuiltInBaseEntityState | LiteralValueState;
-export declare class DataTypeState implements IDataType, UserManagedEntityStateFunctionality, BaseState, ChildEntityState {
+export declare class DataTypeState extends VersionedState implements IDataType, UserManagedEntityStateFunctionality, BaseState, ChildEntityState {
     initialData: IDataType | IDataTypeTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     isList: boolean | null;
     asType: boolean | null;
     readonly type: EntityType.DataType;
@@ -37,8 +37,11 @@ export declare class DataTypeState implements IDataType, UserManagedEntityStateF
     errors: EntityError[];
     parent: PropertyState | ArgumentDeclarationState | ReturnDeclarationState | VariableDeclarationState | ValueDescriptorState | InputMapState | OutputMapState | DataTypeState;
     initialized: boolean;
-    constructor(initialDataTypeData: IDataType | IDataTypeTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IDataType | IDataTypeTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.DataType;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { DefinitionEntityTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IDefinitionEntity, IDefinitionEntityGenerationTarget, IDefinitionEntityReference, IDefinitionEntityShallowTransfer, IDefinitionEntityTransfer } from '../../../definitions';
+import { DefinitionEntityTypesUnion, ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IDefinitionEntity, IDefinitionEntityGenerationTarget, IDefinitionEntityReference, IDefinitionEntityShallowTransfer, IDefinitionEntityTransfer } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseCanvasDraggableState, BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
 import { PropertyState } from '../property';
@@ -10,11 +10,11 @@ import { EntityError, EntityGenerationError } from '../error';
 import { EntityState, IChangeSet } from '../types';
 import { DataTypeState } from '../data-type';
 import { VariableInputMapState } from '../input-map';
+import { VersionedState } from '../version';
 
-export declare class DefinitionEntityState implements BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, IDefinitionEntity, ChildEntityState {
+export declare class DefinitionEntityState extends VersionedState implements BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, IDefinitionEntity, ChildEntityState {
     initialData: IDefinitionEntity | IDefinitionEntityTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     name: string;
     description: string | null;
     x: number;
@@ -33,8 +33,11 @@ export declare class DefinitionEntityState implements BaseState, UserManagedEnti
     initialized: boolean;
     suggestedProperties: PropertyState[];
     suggestedMethods: FunctionDeclarationState[];
-    constructor(initialEntityData: IDefinitionEntity | IDefinitionEntityTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IDefinitionEntity | IDefinitionEntityTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.DefinitionEntity;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { EntityId, EntityType, EntityVersion, IFunctionCall, IFunctionCallTransfer, IFunctionCallReference, IFunctionCallShallowTransfer, ElementShallowTransfer, IFunctionCallGenerationTarget, ElementGenerationTarget, FunctionCallTypesUnion } from '../../../definitions';
+import { EntityId, EntityType, IFunctionCall, IFunctionCallTransfer, IFunctionCallReference, IFunctionCallShallowTransfer, ElementShallowTransfer, IFunctionCallGenerationTarget, ElementGenerationTarget, FunctionCallTypesUnion } 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';
@@ -7,11 +7,11 @@ 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';
 
-export declare class FunctionCallState implements IFunctionCall, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare class FunctionCallState extends VersionedState implements IFunctionCall, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: IFunctionCall | IFunctionCallTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     x: number;
     y: number;
     readonly type: EntityType.FunctionCall;
@@ -29,8 +29,11 @@ export declare class FunctionCallState implements IFunctionCall, BaseState, User
     errors: EntityError[];
     project: ProjectState;
     initialized: boolean;
-    constructor(initialFunctionCallData: IFunctionCall | IFunctionCallTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IFunctionCall | IFunctionCallTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.FunctionCall;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, FunctionDeclarationTypesUnion, IFunctionCallTransfer, IFunctionDeclaration, IFunctionDeclarationGenerationTarget, IFunctionDeclarationReference, IFunctionDeclarationShallowTransfer, IFunctionDeclarationTransfer, IInternalCallTransfer } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, 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 { ArgumentDeclarationState } from '../argument-declaration';
@@ -16,11 +16,11 @@ import { EntityError, EntityGenerationError } from '../error';
 import { FunctionCallState } from '../function-call';
 import { InternalCallState } from '../internal-call';
 import { ReturnDeclarationState } from '../return-declaration';
+import { VersionedState } from '../version';
 
-export declare class FunctionDeclarationState implements IFunctionDeclaration, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
+export declare class FunctionDeclarationState extends VersionedState implements IFunctionDeclaration, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
     initialData: IFunctionDeclarationTransfer | IFunctionDeclaration;
     readonly id: EntityId;
-    version: EntityVersion;
     name: string;
     description: string | null;
     x: number;
@@ -39,8 +39,11 @@ export declare class FunctionDeclarationState implements IFunctionDeclaration, B
     project: ProjectState;
     initialized: boolean;
     suggestion: boolean;
-    constructor(initialFunctionData: IFunctionDeclaration | IFunctionDeclarationTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IFunctionDeclaration | IFunctionDeclarationTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.FunctionDeclaration;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, GlobalEventNames, GlobalEventTypesUnion, IGlobalEvent, IGlobalEventGenerationTarget, IGlobalEventReference, IGlobalEventShallowTransfer, IGlobalEventTransfer } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, 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 { ArgumentDeclarationState } from '../argument-declaration';
@@ -9,11 +9,11 @@ import { InstalledProjectState } from '../installed-project';
 import { VariableInstanceState } from '../variable-instance';
 import { EntityError, EntityGenerationError } from '../../state/error';
 import { ActionDescriptorState } from '../action-descriptor';
+import { VersionedState } from '../version';
 
-export declare class GlobalEventState implements IGlobalEvent, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
+export declare class GlobalEventState extends VersionedState implements IGlobalEvent, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, ChildEntityState, EntityWithLogicScopeClass, EntryPointEntityClass {
     initialData: IGlobalEvent | IGlobalEventTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     name: GlobalEventNames;
     description: string | null;
     x: number;
@@ -29,8 +29,11 @@ export declare class GlobalEventState implements IGlobalEvent, UserManagedEntity
     errors: EntityError[];
     project: ProjectState;
     initialized: boolean;
-    constructor(initialEventData: IGlobalEvent | IGlobalEventTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IGlobalEvent | IGlobalEventTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.GlobalEvent;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

package/dist/tree/state/input-map/input-map.d.ts

@@ -1,4 +1,4 @@
-import { EntityId, EntityType, EntityVersion, IInputMap, IInputMapTransfer, IActionInputMap, IActionInputMapTransfer, IInputMapReference, IVariableInputMap, IVariableInputMapTransfer, IInputMapShallowTransfer, ElementShallowTransfer, IInputMapGenerationTarget, ElementGenerationTarget, InputMapTypesUnion } from '../../../definitions';
+import { EntityId, EntityType, IInputMap, IInputMapTransfer, IActionInputMap, IActionInputMapTransfer, IInputMapReference, IVariableInputMap, IVariableInputMapTransfer, IInputMapShallowTransfer, ElementShallowTransfer, IInputMapGenerationTarget, ElementGenerationTarget, InputMapTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseState, ChildEntityState, EntityWithValueClass, IEntityPersistanceOptions, IEditableEntityPersistanceRepository, UserManagedEntityStateFunctionality, ValueReadingEntityClass, IEntityJSONCloneOptions, IEntityRecursionOptions } from '../base';
 import { ArgumentDeclarationState } from '../argument-declaration';
@@ -17,11 +17,11 @@ import { SearchState } from '../search';
 import { EntityError, EntityGenerationError } from '../error';
 import { DataTypeState } from '../data-type';
 import { ValueDescriptorState } from '../value-descriptor';
+import { VersionedState } from '../version';
 
-export declare class InputMapState implements IInputMap, ValueReadingEntityClass, UserManagedEntityStateFunctionality, BaseState, ChildEntityState, EntityWithValueClass {
+export declare class InputMapState extends VersionedState implements IInputMap, ValueReadingEntityClass, UserManagedEntityStateFunctionality, BaseState, ChildEntityState, EntityWithValueClass {
     initialData: IInputMap | IInputMapTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     index: number;
     name: string | null;
     description: string | null;
@@ -35,8 +35,11 @@ export declare class InputMapState implements IInputMap, ValueReadingEntityClass
     parent: PassThroughCallableEntityState;
     initialized: boolean;
     suggestion: boolean;
-    constructor(initialVariableInputMapData: IInputMap | IInputMapTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IInputMap | IInputMapTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.InputMap;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

package/dist/tree/state/installed-project/installed-project.d.ts

@@ -1,4 +1,4 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IInstalledProject, IInstalledProjectGenerationTarget, IInstalledProjectReference, IInstalledProjectShallowTransfer, IInstalledProjectTransfer, IProjectReference, InstalledProjectTypesUnion } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IInstalledProject, IInstalledProjectGenerationTarget, IInstalledProjectReference, IInstalledProjectShallowTransfer, IInstalledProjectTransfer, IProjectReference, InstalledProjectTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseCanvasDraggableState, BaseState, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, UserManagedEntityStateFunctionality } from '../base';
 import { FunctionDeclarationState } from '../function-declaration';
@@ -6,11 +6,11 @@ import { GlobalEventState } from '../global-event';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../error';
 import { EntityState, IChangeSet } from '../types';
+import { VersionedState } from '../version';
 
-export declare class InstalledProjectState implements IInstalledProject, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, ChildEntityState {
+export declare class InstalledProjectState extends VersionedState implements IInstalledProject, UserManagedEntityStateFunctionality, BaseState, BaseCanvasDraggableState, ChildEntityState {
     initialData: IInstalledProject | IInstalledProjectTransfer;
     readonly id: EntityId;
-    readonly version: EntityVersion;
     readonly name: string;
     readonly description: string | null;
     x: number;
@@ -23,8 +23,11 @@ export declare class InstalledProjectState implements IInstalledProject, UserMan
     errors: EntityError[];
     project: ProjectState;
     initialized: boolean;
-    constructor(initialInstalledProjectData: IInstalledProject | IInstalledProjectTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IInstalledProject | IInstalledProjectTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.InstalledProject;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IInternalCall, IInternalCallGenerationTarget, IInternalCallReference, IInternalCallShallowTransfer, IInternalCallTransfer, InternalCallTypesUnion } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IInternalCall, IInternalCallGenerationTarget, IInternalCallReference, IInternalCallShallowTransfer, IInternalCallTransfer, InternalCallTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
 import { ActionInputMapState } from '../input-map';
@@ -7,11 +7,11 @@ import { CallableEntityState, CallerEntityState, EntityState, EntryPointEntitySt
 import { ProjectState } from '../project/project';
 import { FunctionDeclarationState } from '../function-declaration';
 import { EntityError, EntityGenerationError } from '../error';
+import { VersionedState } from '../version';
 
-export declare class InternalCallState implements IInternalCall, UserManagedEntityStateFunctionality, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare class InternalCallState extends VersionedState implements IInternalCall, UserManagedEntityStateFunctionality, BaseState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: IInternalCall | IInternalCallTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     index: number;
     readonly type: EntityType.InternalCall;
     declaration: FunctionDeclarationState;
@@ -29,8 +29,11 @@ export declare class InternalCallState implements IInternalCall, UserManagedEnti
     errors: EntityError[];
     initialized: boolean;
     suggestion: boolean;
-    constructor(initialOperationData: IInternalCall | IInternalCallTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IInternalCall | IInternalCallTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.InternalCall;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

package/dist/tree/state/literal-value/literal-value.d.ts

@@ -1,4 +1,4 @@
-import { ILiteralValue, ILiteralValueTransfer, EntityId, EntityType, EntityVersion, PrimitiveTypes, ILiteralValueReference, ValueAutogenerationOptions, LiteralValueType, ILiteralValueShallowTransfer, ElementShallowTransfer, ILiteralValueGenerationTarget, ElementGenerationTarget, LiteralValueTypesUnion } from '../../../definitions';
+import { ILiteralValue, ILiteralValueTransfer, EntityId, EntityType, PrimitiveTypes, ILiteralValueReference, ValueAutogenerationOptions, LiteralValueType, ILiteralValueShallowTransfer, ElementShallowTransfer, ILiteralValueGenerationTarget, ElementGenerationTarget, LiteralValueTypesUnion } from '../../../definitions';
 import { ProjectState } from '../project';
 import { DefinitionEntityState } from '../definition-entity';
 import { DataTypeState } from '../data-type';
@@ -16,13 +16,13 @@ import { VariableDeclarationState } from '../variable-declaration';
 import { ValueDescriptorState } from '../value-descriptor';
 import { OutputMapState } from '../output-map';
 import { VariableInstanceState } from '../variable-instance';
+import { VersionedState } from '../version';
 
 export type ValueAsTypeState = DefinitionEntityState | FunctionDeclarationState | OperationState;
-export declare class LiteralValueState implements BaseState, UserManagedEntityStateFunctionality, ChildEntityState, ILiteralValue {
+export declare class LiteralValueState extends VersionedState implements BaseState, UserManagedEntityStateFunctionality, ChildEntityState, ILiteralValue {
     initialData: ILiteralValue | ILiteralValueTransfer;
     readonly type: EntityType.LiteralValue;
     id: EntityId;
-    version: EntityVersion;
     name: PrimitiveTypes;
     autogeneration: ValueAutogenerationOptions | null;
     value: LiteralValueType;
@@ -33,8 +33,11 @@ export declare class LiteralValueState implements BaseState, UserManagedEntitySt
     project: ProjectState;
     initialized: boolean;
     standalone: boolean;
-    constructor(initialEntityData: ILiteralValue | ILiteralValueTransfer, parentProjectState: ProjectState);
+    constructor(initialData: ILiteralValue | ILiteralValueTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.LiteralValue;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];

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

@@ -1,5 +1,5 @@
 import { ZodError } from 'zod';
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, ILoop, ILoopGenerationTarget, ILoopReference, ILoopShallowTransfer, ILoopTransfer, LoopTypesUnion } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, ILoop, ILoopGenerationTarget, ILoopReference, ILoopShallowTransfer, ILoopTransfer, LoopTypesUnion } from '../../../definitions';
 import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, EntityWithLogicScopeClass, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
 import { ActionInputMapState } from '../input-map';
 import { ActionOutputMapState } from '../output-map';
@@ -15,11 +15,11 @@ import { ActionDescriptorState } from '../action-descriptor';
 import { ValueDescriptorState } from '../value-descriptor';
 import { ReturnDeclarationState } from '../return-declaration';
 import { ArgumentDeclarationState } from '../argument-declaration';
+import { VersionedState } from '../version';
 
-export declare class LoopState implements ILoop, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, EntityWithLogicScopeClass, PassThroughCallableEntityClass {
+export declare class LoopState extends VersionedState implements ILoop, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, EntityWithLogicScopeClass, PassThroughCallableEntityClass {
     initialData: ILoop | ILoopTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     x: number;
     y: number;
     readonly type: EntityType.Loop;
@@ -44,8 +44,11 @@ export declare class LoopState implements ILoop, BaseState, UserManagedEntitySta
     errors: EntityError[];
     project: ProjectState;
     initialized: boolean;
-    constructor(initialOperationData: ILoop | ILoopTransfer, parentProjectState: ProjectState);
+    constructor(initialData: ILoop | ILoopTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.Loop;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static CURRENT_ITERATION_NUMBER_ARG_NAME: string;
     static CURRENT_VALUE_ARG_NAME: string;
     static MUTABLE_BASE_PROPERTIES: string[];

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

@@ -1,4 +1,4 @@
-import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, EntityVersion, IOperation, IOperationGenerationTarget, IOperationReference, IOperationShallowTransfer, IOperationTransfer, OperationTypesUnion } from '../../../definitions';
+import { ElementGenerationTarget, ElementShallowTransfer, EntityId, EntityType, IOperation, IOperationGenerationTarget, IOperationReference, IOperationShallowTransfer, IOperationTransfer, OperationTypesUnion } from '../../../definitions';
 import { ZodError } from 'zod';
 import { BaseCanvasDraggableState, BaseState, CallableEntityClass, ChildEntityState, IEditableEntityPersistanceRepository, IEntityJSONCloneOptions, IEntityPersistanceOptions, IEntityRecursionOptions, PassThroughCallableEntityClass, UserManagedEntityStateFunctionality } from '../base';
 import { ActionDescriptorState } from '../action-descriptor/action-descriptor';
@@ -7,11 +7,11 @@ import { ActionOutputMapState } from '../output-map';
 import { CallableEntityState, CallerEntityState, EntityState, EntityWithLogicScopeState, EntryPointEntityState, IChangeSet, PassThroughCallableEntityState, ValueReadingEntityState } from '../types';
 import { ProjectState } from '../project/project';
 import { EntityError, EntityGenerationError } from '../../state/error';
+import { VersionedState } from '../version';
 
-export declare class OperationState implements IOperation, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
+export declare class OperationState extends VersionedState implements IOperation, BaseState, UserManagedEntityStateFunctionality, BaseCanvasDraggableState, CallableEntityClass, ChildEntityState, PassThroughCallableEntityClass {
     initialData: IOperation | IOperationTransfer;
     readonly id: EntityId;
-    version: EntityVersion;
     x: number;
     y: number;
     readonly type: EntityType.Operation;
@@ -29,8 +29,11 @@ export declare class OperationState implements IOperation, BaseState, UserManage
     errors: EntityError[];
     project: ProjectState;
     initialized: boolean;
-    constructor(initialOperationData: IOperation | IOperationTransfer, parentProjectState: ProjectState);
+    constructor(initialData: IOperation | IOperationTransfer, parentProjectState: ProjectState);
     static repository: IEditableEntityPersistanceRepository;
+    static type: EntityType.Operation;
+    static USER_MANAGED_PARENT_TYPES: EntityType[];
+    static PARENT_TYPES: EntityType[];
     static MUTABLE_BASE_PROPERTIES: string[];
     static INMUTABLE_BASE_PROPERTIES: string[];
     static BASE_PROPERTIES: string[];